Testen

Queuety stellt eine Klasse QueueFake bereit, die die echte Warteschlange durch einen In-Memory-Speicher ersetzt. Ausgeführte Jobs werden aufgezeichnet, statt in die Datenbank geschrieben zu werden. Auch create_batch() speichert Batch-Metadaten im Arbeitsspeicher. So kannst du das Ausführungsverhalten überprüfen, ohne Worker zu starten oder in die Datenbank zu schreiben. Bei der Ausführung über einen Handler-Namen wird der Handler weiterhin über die Registry aufgelöst. Rufe deshalb bei Handlern, die als Zeichenfolge angegeben sind, zuerst Queuety::init() auf. Instanzen von Contracts\Job, chain(), create_batch() und batch() funktionieren auch ohne diesen Aufruf.

Fake einrichten

Rufe Queuety::fake() am Anfang deines Tests auf. Die Methode gibt eine Instanz von QueueFake zurück, die alle nachfolgenden Ausführungen aufzeichnet.

use Queuety\Queuety;

class SendEmailTest extends \PHPUnit\Framework\TestCase {
    protected function setUp(): void {
        $this->fake = Queuety::fake();
    }

    protected function tearDown(): void {
        Queuety::reset();
    }
}

Queuety::fake() erstellt ein neues QueueFake und bindet es in die Fassade Queuety ein. Queuety::dispatch() und Dispatchable::dispatch() zeichnen übergebene Jobs auf. Queuety::chain() zeichnet jeden verketteten Job als normalen Push in Ausführungsreihenfolge auf. Queuety::create_batch() zeichnet sowohl die übergebenen Jobs als auch die von assert_batched() verwendeten Batch-Metadaten auf. Queuety::batch() zeichnet die übergebenen Jobs auf, erstellt aber keine gefälschten Batch-Metadaten.

Rufe Queuety::reset() in tearDown() auf, um den Fake zwischen Tests zurückzusetzen. Dabei wird der gesamte Zustand der Fassade gelöscht. Rufe daher Queuety::init() erneut auf, wenn ein späterer Test die echte Warteschlange benötigt.

Überprüfen, ob Jobs übergeben wurden

assert_pushed()

Überprüfe, ob eine bestimmte Job-Klasse mindestens einmal ausgeführt wurde.

public function test_welcome_email_is_sent(): void {
    $this->fake = Queuety::fake();

    // Code under test...
    register_new_user( 'user@example.com' );

    $this->fake->assert_pushed( SendWelcomeEmailJob::class );
}

Übergib optional einen Callback, um nach Payload oder anderen Attributen zu filtern. Der Callback erhält das aufgezeichnete Job-Datenarray mit den Schlüsseln handler, payload, queue und instance. instance ist bei Jobs, die über die Fassade oder das Trait null ausgeführt werden, Dispatchable. Filtere daher nach handler und payload.

$this->fake->assert_pushed( SendWelcomeEmailJob::class, function ( array $job ) {
    return $job['payload']['to'] === 'user@example.com';
} );

assert_pushed_times()

Überprüfe, ob ein Job exakt so oft übergeben wurde wie erwartet.

$this->fake->assert_pushed_times( SendEmailJob::class, 3 );

assert_not_pushed()

Überprüfe, ob ein Job nie ausgeführt wurde.

$this->fake->assert_not_pushed( DeleteAccountJob::class );

assert_nothing_pushed()

Überprüfe, ob überhaupt keine Jobs ausgeführt wurden.

public function test_no_jobs_on_invalid_input(): void {
    $this->fake = Queuety::fake();

    process_input( '' ); // invalid, should not dispatch anything

    $this->fake->assert_nothing_pushed();
}

Batches überprüfen

assert_batched()

Überprüfe, ob ein Batch ausgeführt wurde. Optional kannst du einen Callback übergeben, um nach Batch-Inhalten zu filtern.

$this->fake->assert_batched();

$this->fake->assert_batched( function ( array $batch ) {
    return count( $batch['jobs'] ) === 3;
} );

Der Callback erhält ein Array mit den Schlüsseln jobs und options.

Übergebene Jobs untersuchen

Mit pushed() rufst du alle aufgezeichneten Ausführungen für eine bestimmte Klasse ab, mit batches() alle aufgezeichneten Batches.

$emails = $this->fake->pushed( SendEmailJob::class );
// [ ['handler' => '...', 'payload' => [...], 'queue' => 'default', 'instance' => null], ... ]

$batches = $this->fake->batches();
// [ ['jobs' => [...], 'options' => [...]], ... ]

Zwischen Tests zurücksetzen

Rufe reset() für den Fake auf, um alle aufgezeichneten Jobs und Batches zu löschen, ohne eine neue Instanz zu erstellen.

$this->fake->reset();

Oder rufe Queuety::reset() auf, um den Fake und seinen gesamten internen Zustand vollständig abzubauen.

Vollständiges Beispiel

use PHPUnit\Framework\TestCase;
use Queuety\Queuety;

class OrderWorkflowTest extends TestCase {
    private \Queuety\Testing\QueueFake $fake;

    protected function setUp(): void {
        $this->fake = Queuety::fake();
    }

    protected function tearDown(): void {
        Queuety::reset();
    }

    public function test_order_dispatches_payment_job(): void {
        $order = create_order( [ 'total' => 99.99 ] );

        $this->fake->assert_pushed( ProcessPaymentJob::class, function ( array $job ) use ( $order ) {
            return $job['payload']['order_id'] === $order->id;
        } );
        $this->fake->assert_not_pushed( RefundJob::class );
    }

    public function test_bulk_import_dispatches_batch(): void {
        start_bulk_import( $rows );

        $this->fake->assert_batched( function ( array $batch ) use ( $rows ) {
            return count( $batch['jobs'] ) === count( $rows );
        } );
    }

    public function test_nothing_dispatched_without_data(): void {
        process_empty_queue();

        $this->fake->assert_nothing_pushed();
    }
}