# Tesztelés

A Queuety egy `QueueFake` osztályt biztosít, amely memóriabeli tárolóval helyettesíti a valódi sort. A kiosztott feladatokat adatbázisba írás helyett rögzíti, a `create_batch()` pedig a kötegek metaadatait is memóriában tárolja. Így ellenőrizheted a kiosztás viselkedését workerek futtatása vagy adatbázisba írás nélkül. A kezelő neve alapján történő kiosztás továbbra is a regisztrációs adatbázisból oldja fel a kezelőt, ezért karakterláncos kezelőkiosztás esetén először hívd meg a `Queuety::init()` metódust; a `Contracts\Job` példányai, a `chain()`, a `create_batch()` és a `batch()` enélkül is működnek.

## A hamis sor beállítása

Hívd meg a `Queuety::fake()` metódust a teszt elején. Egy `QueueFake` példányt ad vissza, amely rögzíti az összes ezt követő kiosztást.

```php
use Queuety\Queuety;

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

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

A `Queuety::fake()` létrehoz egy új `QueueFake` példányt, és beköti a `Queuety` homlokzatába. A `Queuety::dispatch()` és a `Dispatchable::dispatch()` rögzíti a sorba állított feladatokat. A `Queuety::chain()` a lánc minden feladatát normál sorba állításként rögzíti, a kiosztási sorrendben. A `Queuety::create_batch()` a sorba állított feladatokat és a `assert_batched()` által használt kötegmetaadatokat is rögzíti. A `Queuety::batch()` rögzíti a sorba állított feladatokat, de nem hoz létre hamis kötegmetaadatokat.

Hívd meg a `Queuety::reset()` metódust a `tearDown()` helyen, hogy a tesztek között töröld a hamis sort. Az összes homlokzati állapotot törli, ezért ha egy későbbi tesztnek a valódi sorra van szüksége, hívd meg ismét a `Queuety::init()` metódust.

## Sorba állított feladatok ellenőrzése

### `assert_pushed()`

Ellenőrizd, hogy egy adott feladatosztályt legalább egyszer kiosztottak-e.

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

Opcionálisan adj át egy visszahívást, amellyel a payload vagy más attribútumok alapján szűrhetsz. A visszahívás a rögzített feladatadatok tömbjét kapja, amelynek kulcsai: `handler`, `payload`, `queue` és `instance`. A `instance` értéke `null` a homlokzaton vagy a `Dispatchable` traiten keresztül kiosztott feladatoknál, ezért a `handler` és a `payload` alapján szűrj.

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

### `assert_pushed_times()`

Ellenőrizd, hogy egy feladat pontosan meghatározott számú alkalommal került-e sorba.

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

### `assert_not_pushed()`

Ellenőrizd, hogy egy feladatot soha nem osztottak-e ki.

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

### `assert_nothing_pushed()`

Ellenőrizd, hogy egyáltalán nem osztottak-e ki feladatot.

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

## Kötegek ellenőrzése

### `assert_batched()`

Ellenőrizd, hogy kiosztottak-e egy köteget. Opcionálisan visszahívást is átadhatsz a kötegtartalom szerinti szűréshez.

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

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

A visszahívás egy tömböt kap, amelynek kulcsai: `jobs` és `options`.

## Sorba állított feladatok vizsgálata

A `pushed()` metódussal lekérheted egy adott osztály összes rögzített kiosztását, a `batches()` metódussal pedig az összes rögzített köteget.

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

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

## Visszaállítás a tesztek között

Hívd meg a `reset()` metódust a hamis soron az összes rögzített feladat és köteg törléséhez, új példány létrehozása nélkül.

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

Vagy hívd meg a `Queuety::reset()` metódust a hamis sor és minden belső állapot teljes lebontásához.

## Teljes példa

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