# Testen

Queuety biedt een klasse `QueueFake` die de echte wachtrij vervangt door een in-memory opslag. Gedispatchte taken worden geregistreerd in plaats van naar de database geschreven, en `create_batch()` registreert batchmetagegevens eveneens in het geheugen. Zo kunt u het dispatchgedrag controleren zonder workers uit te voeren of naar de database te schrijven. Bij dispatch op basis van een handlernaam wordt de handler nog steeds via het register opgezocht. Roep daarom eerst `Queuety::init()` aan voor dispatches met een string-handler; instanties van `Contracts\Job`, `chain()`, `create_batch()` en `batch()` werken zonder die aanroep.

## De nepinstantie instellen

Roep `Queuety::fake()` aan aan het begin van uw test. Deze geeft een instantie van `QueueFake` terug die alle daaropvolgende dispatches registreert.

```php
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()` maakt een nieuwe `QueueFake` aan en koppelt deze aan de facade `Queuety`. `Queuety::dispatch()` en `Dispatchable::dispatch()` registreren toegevoegde taken. `Queuety::chain()` registreert elke gekoppelde taak als een gewone toevoeging, in dispatchvolgorde. `Queuety::create_batch()` registreert zowel de toegevoegde taken als de batchmetagegevens die door `assert_batched()` worden gebruikt. `Queuety::batch()` registreert de toegevoegde taken, maar maakt geen nep-batchmetagegevens aan.

Roep `Queuety::reset()` aan in `tearDown()` om de nepinstantie tussen tests te wissen. Alle facadestatus wordt gewist, dus roep `Queuety::init()` opnieuw aan als een latere test de echte wachtrij nodig heeft.

## Controleren of taken zijn toegevoegd

### `assert_pushed()`

Controleer of een specifieke taakkklasse minstens één keer is gedispatcht.

```php
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 );
}
```

Geef optioneel een callback mee om te filteren op payload of andere kenmerken. De callback ontvangt de array met geregistreerde taakgegevens met de sleutels `handler`, `payload`, `queue` en `instance`. Voor taken die via de facade of de trait `Dispatchable` zijn gedispatcht, is `instance` `null`. Filter daarom op `handler` en `payload`.

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

### `assert_pushed_times()`

Controleer of een taak exact een bepaald aantal keer is toegevoegd.

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

### `assert_not_pushed()`

Controleer of een taak nooit is gedispatcht.

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

### `assert_nothing_pushed()`

Controleer of er helemaal geen taken zijn gedispatcht.

```php
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 controleren

### `assert_batched()`

Controleer of een batch is gedispatcht. Geef optioneel een callback mee om te filteren op de inhoud van de batch.

```php
$this->fake->assert_batched();

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

De callback ontvangt een array met de sleutels `jobs` en `options`.

## Toegevoegde taken bekijken

Gebruik `pushed()` om alle geregistreerde dispatches voor een bepaalde klasse op te halen en `batches()` om alle geregistreerde batches op te halen.

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

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

## Tussen tests opnieuw instellen

Roep `reset()` aan op de nepinstantie om alle geregistreerde taken en batches te wissen zonder een nieuwe instantie aan te maken.

```php
$this->fake->reset();
```

Of roep `Queuety::reset()` aan om de nepinstantie en alle interne status volledig op te ruimen.

## Volledig voorbeeld

```php
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();
    }
}
```