# Test

Queuety leverer en `QueueFake`-klasse, der erstatter den rigtige kø med et lager i hukommelsen. Afsendte jobs registreres i stedet for at blive skrevet til databasen, og `create_batch()` registrerer også batchmetadata i hukommelsen. Dermed kan du kontrollere afsendelsesadfærd uden at køre workers eller skrive til databasen. Ved afsendelse efter handlernavn slås handleren stadig op i registret, så kald `Queuety::init()` først ved afsendelse med streng-handlernavne; `Contracts\Job`-instanser, `chain()`, `create_batch()` og `batch()` fungerer uden.

## Opsætning af den falske kø

Kald `Queuety::fake()` i starten af din test. Den returnerer en `QueueFake`-instans, som registrerer alle efterfølgende afsendelser.

```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()` opretter en ny `QueueFake` og kobler den til `Queuety`-facaden. `Queuety::dispatch()` og `Dispatchable::dispatch()` registrerer jobs, der lægges i køen. `Queuety::chain()` registrerer hvert kædet job som en almindelig køtilføjelse i afsendelsesrækkefølgen. `Queuety::create_batch()` registrerer både de jobs, der lægges i køen, og batchmetadataene, som bruges af `assert_batched()`. `Queuety::batch()` registrerer jobs, der lægges i køen, men opretter ikke falske batchmetadata.

Kald `Queuety::reset()` i `tearDown()` for at rydde den falske kø mellem tests. Den rydder al facadetilstand, så kald `Queuety::init()` igen, hvis en senere test har brug for den rigtige kø.

## Kontrollér, at jobs blev lagt i køen

### `assert_pushed()`

Kontrollér, at en bestemt jobklasse blev afsendt mindst én gang.

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

Angiv en valgfri callback for at filtrere efter nyttelast eller andre attributter. Callbacken modtager det registrerede jobdata-array med nøglerne `handler`, `payload`, `queue` og `instance`. `instance` er `null` for jobs, der er afsendt via facaden eller traitet `Dispatchable`, så filtrér efter `handler` og `payload`.

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

### `assert_pushed_times()`

Kontrollér, at et job blev lagt i køen et bestemt antal gange.

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

### `assert_not_pushed()`

Kontrollér, at et job aldrig blev afsendt.

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

### `assert_nothing_pushed()`

Kontrollér, at der slet ikke blev afsendt nogen jobs.

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

## Kontrollér batches

### `assert_batched()`

Kontrollér, at en batch blev afsendt. Angiv eventuelt en callback for at filtrere efter batchens indhold.

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

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

Callbacken modtager et array med nøglerne `jobs` og `options`.

## Undersøg jobs, der er lagt i køen

Brug `pushed()` til at hente alle registrerede afsendelser for en given klasse, og `batches()` til at hente alle registrerede batches.

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

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

## Nulstil mellem tests

Kald `reset()` på den falske kø for at rydde alle registrerede jobs og batches uden at oprette en ny instans.

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

Eller kald `Queuety::reset()` for at nedlægge den falske kø fuldstændigt og rydde al intern tilstand.

## Fuldt eksempel

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