# Testēšana

Queuety nodrošina `QueueFake` klasi, kas aizstāj īsto rindu ar atmiņā glabātu datu krātuvi. Palaistie uzdevumi tiek reģistrēti, nevis ierakstīti datubāzē, un `create_batch()` arī saglabā pakešu metadatus atmiņā. Tādējādi varat pārbaudīt palaišanas darbību, nedarbinot darbiniekus un nerakstot datubāzē. Palaižot pēc apdarinātāja nosaukuma, reģistrā joprojām tiek meklēts apdarinātājs, tāpēc virknes apdarinātāja palaišanai vispirms izsauciet `Queuety::init()`; `Contracts\Job` instances, `chain()`, `create_batch()` un `batch()` darbojas arī bez tās.

## Fiktīvās rindas iestatīšana

Izsauciet `Queuety::fake()` testa sākumā. Tas atgriež `QueueFake` instanci, kas reģistrē visus turpmākos uzdevumus.

```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()` izveido jaunu `QueueFake` un pievieno to `Queuety` fasādei. `Queuety::dispatch()` un `Dispatchable::dispatch()` reģistrē ievietotos uzdevumus. `Queuety::chain()` reģistrē katru ķēdes uzdevumu kā parastu ievietošanu palaišanas secībā. `Queuety::create_batch()` reģistrē gan ievietotos uzdevumus, gan pakešu metadatus, ko izmanto `assert_batched()`. `Queuety::batch()` reģistrē ievietotos uzdevumus, bet neveido fiktīvus pakešu metadatus.

Izsauciet `Queuety::reset()` `tearDown()`, lai notīrītu fiktīvo rindu starp testiem. Tiek notīrīts viss fasādes stāvoklis, tāpēc, ja vēlākā testā vajadzīga īstā rinda, vēlreiz izsauciet `Queuety::init()`.

## Pārbaudīt ievietotos uzdevumus

### `assert_pushed()`

Pārbaudiet, vai konkrētas uzdevumu klases uzdevums ir palaists vismaz vienu reizi.

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

Padodiet neobligātu atzvanīšanas funkciju, lai filtrētu pēc datiem vai citiem atribūtiem. Funkcija saņem reģistrēto uzdevuma datu masīvu ar atslēgām `handler`, `payload`, `queue` un `instance`. `instance` ir `null` uzdevumiem, kas palaisti caur fasādi vai pazīmi `Dispatchable`, tāpēc salīdziniet pēc `handler` un `payload`.

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

### `assert_pushed_times()`

Pārbaudiet, vai uzdevums tika ievietots precīzi norādīto reižu skaitu.

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

### `assert_not_pushed()`

Pārbaudiet, vai uzdevums netika palaists nevienu reizi.

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

### `assert_nothing_pushed()`

Pārbaudiet, vai netika palaists neviens uzdevums.

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

## Pakešu pārbaude

### `assert_batched()`

Pārbaudiet, vai pakete tika palaista. Pēc izvēles padodiet atzvanīšanas funkciju, lai filtrētu pēc paketes satura.

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

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

Atzvanīšanas funkcija saņem masīvu ar atslēgām `jobs` un `options`.

## Ievietoto uzdevumu apskate

Izmantojiet `pushed()`, lai izgūtu visas reģistrētās attiecīgās klases palaišanas un `batches()`, lai izgūtu visas reģistrētās paketes.

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

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

## Atiestatīšana starp testiem

Izsauciet `reset()` fiktīvajai rindai, lai notīrītu visus reģistrētos uzdevumus un paketes, neveidojot jaunu instanci.

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

Vai arī izsauciet `Queuety::reset()`, lai pilnībā likvidētu fiktīvo rindu un visu iekšējo stāvokli.

## Pilns piemērs

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