# Test Etme

Queuety, gerçek kuyruğun yerine bellekte tutulan bir `QueueFake` sınıfı sağlar. Dağıtılan işler veritabanına yazılmak yerine kaydedilir; `create_batch()` de toplu işlem meta verilerini bellekte tutar. Böylece çalışanları başlatmadan veya veritabanına yazmadan iş dağıtım davranışını doğrulayabilirsiniz. İşleyici adına göre dağıtımda işleyici kayıt defterinden çözümlenmeye devam eder; bu nedenle dize işleyiciyle dağıtım yaparken önce `Queuety::init()` çağrısını yapın. `Contracts\Job` örnekleri, `chain()`, `create_batch()` ve `batch()` için buna gerek yoktur.

## Taklidi kurma

Testinizin başında `Queuety::fake()` çağrısını yapın. Sonraki tüm dağıtımları kaydeden bir `QueueFake` örneği döndürür.

```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()` yeni bir `QueueFake` oluşturur ve bunu `Queuety` arayüzüne bağlar. `Queuety::dispatch()` ve `Dispatchable::dispatch()` gönderilen işleri kaydeder. `Queuety::chain()`, zincirlenen her işi dağıtım sırasıyla normal bir gönderim olarak kaydeder. `Queuety::create_batch()` hem gönderilen işleri hem de `assert_batched()` tarafından kullanılan toplu işlem meta verilerini kaydeder. `Queuety::batch()` gönderilen işleri kaydeder, ancak taklit toplu işlem meta verileri oluşturmaz.

Testler arasında taklidi temizlemek için `tearDown()` içinde `Queuety::reset()` çağrısını yapın. Tüm arayüz durumunu temizler; sonraki bir test gerçek kuyruğu kullanacaksa `Queuety::init()` çağrısını yeniden yapın.

## İşlerin kuyruğa eklendiğini doğrulama

### `assert_pushed()`

Belirli bir iş sınıfının en az bir kez dağıtıldığını doğrulayın.

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

Yüke veya diğer özniteliklere göre filtrelemek için isteğe bağlı bir geri çağırım aktarın. Geri çağırım, `handler`, `payload`, `queue` ve `instance` anahtarlarını içeren kaydedilmiş iş verisi dizisini alır. Arayüz veya `Dispatchable` özelliği üzerinden dağıtılan işler için `instance` değeri `null` olduğundan `handler` ve `payload` üzerinden eşleştirme yapın.

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

### `assert_pushed_times()`

Bir işin tam olarak belirtilen sayıda kuyruğa eklendiğini doğrulayın.

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

### `assert_not_pushed()`

Bir işin hiç dağıtılmadığını doğrulayın.

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

### `assert_nothing_pushed()`

Hiçbir işin dağıtılmadığını doğrulayın.

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

## Toplu işlemleri doğrulama

### `assert_batched()`

Bir toplu işlemin dağıtıldığını doğrulayın. Toplu işlem içeriğine göre filtrelemek için isteğe bağlı olarak bir geri çağırım aktarın.

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

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

Geri çağırım, `jobs` ve `options` anahtarlarını içeren bir dizi alır.

## Kuyruğa eklenen işleri inceleme

Belirli bir sınıf için kaydedilen tüm dağıtımları almak üzere `pushed()`, kaydedilen tüm toplu işlemleri almak üzere `batches()` kullanın.

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

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

## Testler arasında sıfırlama

Yeni bir örnek oluşturmadan kaydedilen tüm işleri ve toplu işlemleri temizlemek için taklit üzerinde `reset()` çağrısını yapın.

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

Taklidi ve tüm dahili durumunu tamamen kaldırmak için `Queuety::reset()` çağrısını yapın.

## Tam örnek

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