> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Datenbanktests

> So schreiben Sie mit RefreshDatabase, Seedern, Factories und speziellen Assertions effiziente Datenbanktests in Laravel.

## Einführung

Laravel bringt Werkzeuge mit, um Funktionen, die eine Datenbank nutzen, sicher und schnell zu prüfen. Traits zum Zurücksetzen der Datenbank, Model-Factories, Seeder und spezielle Assertions ergeben zusammen widerstandsfähige Tests.

Als Ausgangspunkt empfiehlt sich `RefreshDatabase`. In vielen Fällen wahrt es die Isolation zwischen Tests schneller als ein kompletter Reset.

## Datenbank nach jedem Test zurücksetzen

Damit Testdaten aus einem Test nicht in den nächsten hineinwirken, verwenden Sie die Traits von Laravel zum Zurücksetzen der Datenbank.

<CodeGroup>
  ```php Pest theme={null}
  <?php

  use Illuminate\Foundation\Testing\RefreshDatabase;

  uses(RefreshDatabase::class);

  test('einfaches Beispiel', function () {
      $response = $this->get('/');

      $response->assertOk();
  });
  ```

  ```php PHPUnit theme={null}
  <?php

  namespace Tests\Feature;

  use Illuminate\Foundation\Testing\RefreshDatabase;
  use Tests\TestCase;

  class ExampleTest extends TestCase
  {
      use RefreshDatabase;

      public function test_basic_example(): void
      {
          $response = $this->get('/');

          $response->assertOk();
      }
  }
  ```
</CodeGroup>

`RefreshDatabase` erkennt, ob das Schema aktuell ist. Ist es aktuell, führt es die Tests in einer Transaktion aus; ist es nicht aktuell, werden zuvor die Migrationen ausgeführt.

```mermaid theme={null}
flowchart TD
    A[Test mit RefreshDatabase startet] --> B{Ist das Schema aktuell?}
    B -- Ja --> C[Ausführung in einer DB-Transaktion]
    B -- Nein --> D[Migrationen ausführen]
    D --> E[Test ausführen]
    C --> E[Test ausführen]
    E --> F[Rollback / Zustand zurücksetzen]
```

Wenn Sie keine Transaktion nutzen, sondern bei jedem Test wirklich alles zurücksetzen möchten, stehen weitere Traits zur Verfügung.

| Trait                | Verhalten                                                    | Wann verwenden                                                        |
| -------------------- | ------------------------------------------------------------ | --------------------------------------------------------------------- |
| `RefreshDatabase`    | Transaktion bei aktuellem Schema; Migrationen nur bei Bedarf | Der übliche Standard                                                  |
| `DatabaseMigrations` | Führt bei jedem Test Migrationen aus                         | Wenn Sie den Migrationslebenszyklus jedes Mal durchlaufen möchten     |
| `DatabaseTruncation` | Initialisiert Tabellen per TRUNCATE                          | Wenn Transaktionen nicht in Frage kommen und Sie alles leeren möchten |

## Model-Factories

Zum Anlegen von Testdaten sind Model-Factories die kompakteste Möglichkeit, Eloquent-Modelle zu erzeugen.

Details zu Factory-Definitionen, States und Relations finden Sie unter [Eloquent-Factories](/de/eloquent-factories).

<CodeGroup>
  ```php Pest theme={null}
  <?php

  use App\Models\User;

  test('Modell lässt sich anlegen', function () {
      $user = User::factory()->create();

      expect($user->exists)->toBeTrue();
  });
  ```

  ```php PHPUnit theme={null}
  <?php

  namespace Tests\Feature;

  use App\Models\User;
  use Tests\TestCase;

  class UserFactoryTest extends TestCase
  {
      public function test_models_can_be_instantiated(): void
      {
          $user = User::factory()->create();

          $this->assertTrue($user->exists);
      }
  }
  ```
</CodeGroup>

## Seeder ausführen

Möchten Sie während eines Tests Daten einspielen, verwenden Sie `seed()`. Ohne Argument wird der `DatabaseSeeder` ausgeführt; mit Argument ein bestimmter Seeder (oder ein Array von Seedern).

<CodeGroup>
  ```php Pest theme={null}
  <?php

  use Database\Seeders\OrderStatusSeeder;
  use Database\Seeders\TransactionStatusSeeder;
  use Illuminate\Foundation\Testing\RefreshDatabase;

  uses(RefreshDatabase::class);

  test('Bestellungen können angelegt werden', function () {
      $this->seed();

      $this->seed(OrderStatusSeeder::class);

      $this->seed([
          OrderStatusSeeder::class,
          TransactionStatusSeeder::class,
      ]);

      // ...
  });
  ```

  ```php PHPUnit theme={null}
  <?php

  namespace Tests\Feature;

  use Database\Seeders\OrderStatusSeeder;
  use Database\Seeders\TransactionStatusSeeder;
  use Illuminate\Foundation\Testing\RefreshDatabase;
  use Tests\TestCase;

  class OrderTest extends TestCase
  {
      use RefreshDatabase;

      public function test_orders_can_be_created(): void
      {
          $this->seed();

          $this->seed(OrderStatusSeeder::class);

          $this->seed([
              OrderStatusSeeder::class,
              TransactionStatusSeeder::class,
          ]);

          // ...
      }
  }
  ```
</CodeGroup>

Um bei jedem Test, der `RefreshDatabase` verwendet, automatisch zu seeden, versehen Sie die Basis-Testklasse mit dem Attribut `#[Seed]`.

```php theme={null}
<?php

namespace Tests;

use Illuminate\Foundation\Testing\Attributes\Seed;
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

#[Seed]
abstract class TestCase extends BaseTestCase
{
}
```

Um automatisch nur bestimmte Seeder auszuführen, verwenden Sie `#[Seeder(...)]`.

```php theme={null}
<?php

namespace Tests\Feature;

use Database\Seeders\OrderStatusSeeder;
use Illuminate\Foundation\Testing\Attributes\Seeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

#[Seeder(OrderStatusSeeder::class)]
class OrderStatusTest extends TestCase
{
    use RefreshDatabase;
}
```

## Verfügbare Assertions

Laravel bringt spezielle Datenbank-Assertions mit, die sowohl mit Pest als auch mit PHPUnit funktionieren.

### `assertDatabaseCount`

Prüft, dass die Anzahl der Datensätze in einer Tabelle dem erwarteten Wert entspricht.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertDatabaseCount('users', 5);
  ```

  ```php PHPUnit theme={null}
  $this->assertDatabaseCount('users', 5);
  ```
</CodeGroup>

### `assertDatabaseEmpty`

Prüft, dass eine Tabelle leer ist.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertDatabaseEmpty('users');
  ```

  ```php PHPUnit theme={null}
  $this->assertDatabaseEmpty('users');
  ```
</CodeGroup>

### `assertDatabaseHas`

Prüft, dass ein Datensatz existiert, der den angegebenen Kriterien entspricht.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertDatabaseHas('users', [
      'email' => 'sally@example.com',
  ]);
  ```

  ```php PHPUnit theme={null}
  $this->assertDatabaseHas('users', [
      'email' => 'sally@example.com',
  ]);
  ```
</CodeGroup>

### `assertDatabaseMissing`

Prüft, dass kein Datensatz existiert, der den angegebenen Kriterien entspricht.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertDatabaseMissing('users', [
      'email' => 'sally@example.com',
  ]);
  ```

  ```php PHPUnit theme={null}
  $this->assertDatabaseMissing('users', [
      'email' => 'sally@example.com',
  ]);
  ```
</CodeGroup>

### `assertSoftDeleted`

Prüft, dass das angegebene Eloquent-Modell soft-deleted ist.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertSoftDeleted($user);
  ```

  ```php PHPUnit theme={null}
  $this->assertSoftDeleted($user);
  ```
</CodeGroup>

### `assertNotSoftDeleted`

Prüft, dass das angegebene Eloquent-Modell nicht soft-deleted ist.

<CodeGroup>
  ```php Pest theme={null}
  $this->assertNotSoftDeleted($user);
  ```

  ```php PHPUnit theme={null}
  $this->assertNotSoftDeleted($user);
  ```
</CodeGroup>

### `assertModelExists`

Prüft, dass das angegebene Modell (oder eine Model-Collection) in der Datenbank vorhanden ist.

<CodeGroup>
  ```php Pest theme={null}
  <?php

  use App\Models\User;

  $user = User::factory()->create();

  $this->assertModelExists($user);
  ```

  ```php PHPUnit theme={null}
  <?php

  use App\Models\User;

  $user = User::factory()->create();

  $this->assertModelExists($user);
  ```
</CodeGroup>

### `assertModelMissing`

Prüft, dass das angegebene Modell (oder eine Model-Collection) in der Datenbank nicht vorhanden ist.

<CodeGroup>
  ```php Pest theme={null}
  <?php

  use App\Models\User;

  $user = User::factory()->create();
  $user->delete();

  $this->assertModelMissing($user);
  ```

  ```php PHPUnit theme={null}
  <?php

  use App\Models\User;

  $user = User::factory()->create();
  $user->delete();

  $this->assertModelMissing($user);
  ```
</CodeGroup>

### `expectsDatabaseQueryCount`

Legen Sie zu Beginn eines Tests die exakte Anzahl der zu erwartenden Datenbankabfragen fest. Weicht die tatsächliche Zahl ab, schlägt der Test fehl.

<CodeGroup>
  ```php Pest theme={null}
  $this->expectsDatabaseQueryCount(5);

  // Test...
  ```

  ```php PHPUnit theme={null}
  $this->expectsDatabaseQueryCount(5);

  // Test...
  ```
</CodeGroup>