Eloquent-factories

Wat zijn factories?

Bij tests en databaseseeding moet je records in de database invoegen. In plaats van handmatig de waarde van elke kolom op te geven, kun je met de modelfactories van Laravel een set standaardattributen definiëren voor elk Eloquent-model. Elke nieuwe Laravel-applicatie wordt geleverd met database/factories/UserFactory.php.

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;

class UserFactory extends Factory
{
    // Cache hetzelfde wachtwoord zodat het niet elke keer opnieuw wordt gehasht
    protected static ?string $password;

    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'email' => fake()->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => static::$password ??= Hash::make('password'),
            'remember_token' => Str::random(10),
        ];
    }
}

Via de fake()-helper heb je toegang tot de Faker-library, waarmee je allerlei willekeurige data kunt genereren.

De locale van Faker kun je wijzigen met de optie faker_locale in config/app.php.

Factories genereren

Maak een factory aan met het Artisan-commando make:factory.

php artisan make:factory PostFactory

De nieuwe factoryklasse wordt geplaatst in de map database/factories.

Automatische detectie van modellen en factories

Als je model de HasFactory-trait gebruikt, vindt Laravel automatisch de bijbehorende factory. Er wordt in de namespace Database\Factories gezocht naar een klassennaam die bestaat uit de modelnaam met Factory erachter. Als de naamgevingsconventie niet past, kun je de factory expliciet opgeven met het UseFactory-attribuut.

use Illuminate\Database\Eloquent\Attributes\UseFactory;
use Database\Factories\Administration\FlightFactory;

#[UseFactory(FlightFactory::class)]
class Flight extends Model
{
    // ...
}

Factories definiëren

De `definition()`-methode

In de centrale definition()-methode van de factory definieer je de standaardattributen.

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

class PostFactory extends Factory
{
    public function definition(): array
    {
        return [
            'user_id' => \App\Models\User::factory(),
            'title' => fake()->sentence(),
            'content' => fake()->paragraphs(3, true),
            'published_at' => fake()->optional()->dateTimeBetween('-1 year', 'now'),
        ];
    }
}

Een overzicht van veelgebruikte Faker-methoden:

Methode	Voorbeeld van gegenereerde data
`fake()->name()`	`John Doe`
`fake()->email()`	`[email protected]`
`fake()->sentence()`	Willekeurige zin
`fake()->paragraph()`	Willekeurige alinea
`fake()->numberBetween(1, 100)`	Geheel getal van `1` t/m `100`
`fake()->dateTime()`	Willekeurige datum en tijd
`fake()->boolean()`	`true` / `false`

Factory-states

Met state-methoden kun je afzonderlijke wijzigingen op een factory definiëren.

use Illuminate\Database\Eloquent\Factories\Factory;

class UserFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'email' => fake()->unique()->safeEmail(),
            'account_status' => 'active',
        ];
    }

    // State voor geschorste gebruikers
    public function suspended(): static
    {
        return $this->state(fn (array $attributes) => [
            'account_status' => 'suspended',
        ]);
    }

    // State voor beheerders
    public function admin(): static
    {
        return $this->state(fn (array $attributes) => [
            'is_admin' => true,
        ]);
    }
}

States kun je combineren.

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

De soft-delete-state

Voor modellen die soft deletes ondersteunen, is de ingebouwde trashed()-state beschikbaar.

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

Factory-callbacks

Met afterMaking en afterCreating definieer je extra logica na het genereren van een model.

namespace Database\Factories;

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;

class UserFactory extends Factory
{
    public function configure(): static
    {
        return $this->afterMaking(function (User $user) {
            // Uitgevoerd na make() (nog niet opgeslagen in de DB)
        })->afterCreating(function (User $user) {
            // Uitgevoerd na create() (al opgeslagen in de DB)
        });
    }

    // ...
}

Je kunt ook binnen state-methoden callbacks registreren.

public function withProfile(): static
{
    return $this->state(fn (array $attributes) => [])
        ->afterCreating(function (User $user) {
            $user->profile()->create([
                'bio' => fake()->paragraph(),
            ]);
        });
}

Modellen genereren

make() — niet opslaan in de DB

use App\Models\User;

// 1 exemplaar genereren
$user = User::factory()->make();

// 3 exemplaren genereren (teruggegeven als collectie)
$users = User::factory()->count(3)->make();

create() — opslaan in de DB

// 1 exemplaar genereren en opslaan in de DB
$user = User::factory()->create();

// 3 exemplaren genereren en opslaan in de DB
$users = User::factory()->count(3)->create();

Attributen overschrijven

Als je een array doorgeeft aan make() of create(), kun je alleen specifieke attributen overschrijven.

$user = User::factory()->make([
    'name' => 'Yamada Taro',
]);

$user = User::factory()->create([
    'name' => 'Suzuki Hanako',
    'email' => '[email protected]',
]);

Inline overschrijven met een state is ook mogelijk.

$user = User::factory()->state([
    'name' => 'Tanaka Ichiro',
])->make();

Bij het genereren van modellen met een factory wordt de mass-assignment-bescherming automatisch uitgeschakeld.

Sequence

Wil je bij het genereren van meerdere modellen attributen afwisselen, gebruik dan Sequence.

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Sequence;

$users = User::factory()
    ->count(10)
    ->state(new Sequence(
        ['admin' => 'Y'],
        ['admin' => 'N'],
    ))
    ->create();
// 5 exemplaren worden gegenereerd met admin='Y', 5 met admin='N'

Met de sequence()-methode kun je dit beknopter schrijven.

$users = User::factory()
    ->count(2)
    ->sequence(
        ['name' => 'Eerste gebruiker'],
        ['name' => 'Tweede gebruiker'],
    )
    ->create();

Je kunt ook met een closure dynamisch willekeurige waarden genereren.

use Illuminate\Database\Eloquent\Factories\Sequence;

$users = User::factory()
    ->count(10)
    ->state(new Sequence(
        fn (Sequence $sequence) => ['name' => 'Gebruiker ' . $sequence->index],
    ))
    ->create();

Factories voor relaties

Has many (één-op-veel)

Met de has()-methode genereer je een model met een “één-op-veel”-relatie.

use App\Models\Post;
use App\Models\User;

// Genereer een User met 3 Posts
$user = User::factory()
    ->has(Post::factory()->count(3))
    ->create();

Met magic methods kun je dit beknopter schrijven (has + de meervoudsvorm van de relatienaam).

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

// Attributen overschrijven
$user = User::factory()
    ->hasPosts(3, ['published' => false])
    ->create();

Belongs to (omgekeerde relatie)

Met de for()-methode geef je het bovenliggende model op waartoe het model “behoort”.

use App\Models\Post;
use App\Models\User;

// Genereer 3 Posts die bij een specifieke gebruiker horen
$posts = Post::factory()
    ->count(3)
    ->for(User::factory()->state(['name' => 'Tanaka Hanako']))
    ->create();

// Een bestaand model als parent gebruiken
$user = User::factory()->create();
$posts = Post::factory()->count(3)->for($user)->create();

De variant met magic methods:

$posts = Post::factory()
    ->count(3)
    ->forUser(['name' => 'Tanaka Hanako'])
    ->create();

Many to many (veel-op-veel)

Met de hasAttached()-methode werk je met veel-op-veel-relaties. Je kunt ook attributen voor de tussentabel opgeven.

use App\Models\Role;
use App\Models\User;

$user = User::factory()
    ->hasAttached(
        Role::factory()->count(3),
        ['active' => true]  // Attributen van de tussentabel
    )
    ->create();

De variant met magic methods:

$user = User::factory()
    ->hasRoles(1, ['name' => 'Editor'])
    ->create();

Polymorfe relaties

Net als bij gewone “één-op-veel”-relaties kun je has() of magic methods gebruiken.

use App\Models\Post;

$post = Post::factory()->hasComments(3)->create();

Voor morphTo-relaties kun je geen magic methods gebruiken. Geef de relatienaam expliciet op aan for().

$comments = Comment::factory()->count(3)->for(
    Post::factory(), 'commentable'
)->create();

Relaties binnen de factory definiëren

Als je in definition() een andere factory toewijst aan een foreign key, wordt bij het genereren van het model automatisch ook het bovenliggende model gegenereerd.

class PostFactory extends Factory
{
    public function definition(): array
    {
        return [
            'user_id' => \App\Models\User::factory(),
            'title' => fake()->sentence(),
            'content' => fake()->paragraph(),
        ];
    }
}

recycle() — bestaande modellen hergebruiken

Wil je dezelfde modelinstantie hergebruiken in meerdere relaties, gebruik dan recycle().

// Gebruik dezelfde Airline voor zowel Ticket als Flight
Ticket::factory()
    ->recycle(Airline::factory()->create())
    ->create();

// Willekeurig kiezen uit een collectie
$airlines = Airline::factory()->count(3)->create();
Ticket::factory()->count(10)->recycle($airlines)->create();

Gebruik bij seeding

Roep factories aan vanuit de DatabaseSeeder of een seederklasse.

namespace Database\Seeders;

use App\Models\User;
use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        // Genereer 10 gebruikers en geef elke gebruiker 3 posts
        User::factory()
            ->count(10)
            ->hasPosts(3)
            ->create();
    }
}

De seeder uitvoeren:

php artisan db:seed

Gebruik in tests

In tests gebruik je factories in combinatie met de RefreshDatabase-trait.

namespace Tests\Feature;

use App\Models\User;
use App\Models\Post;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PostTest extends TestCase
{
    use RefreshDatabase;

    public function test_user_can_view_their_posts(): void
    {
        $user = User::factory()->create();
        $posts = Post::factory()->count(3)->for($user)->create();

        $response = $this->actingAs($user)
            ->get('/dashboard');

        $response->assertOk();
        $response->assertSee($posts->first()->title);
    }

    public function test_suspended_user_cannot_post(): void
    {
        $user = User::factory()->suspended()->create();

        $response = $this->actingAs($user)
            ->post('/posts', ['title' => 'Test']);

        $response->assertForbidden();
    }
}

Omdat RefreshDatabase de database bij elke test reset, interfereert data niet tussen tests.

Ook bij het testen met Pest is de factory-API hetzelfde. Gebruik uses(RefreshDatabase::class) om de database te resetten.

Volgende stappen

Databaseseeding

Bekijk hoe je seeders en factories combineert om initiële data in te laden.

Introductie tot testen

Bekijk de testfunctionaliteit van Laravel en het gebruik van de RefreshDatabase-trait.

Aan de slag

Basis

Request-verwerking

Database

Authenticatie

Helpers en externe communicatie

Testen en deployment

AI-ontwikkelondersteuning

Wat zijn factories?

Factories genereren

Automatische detectie van modellen en factories

Factories definiëren

De `definition()`-methode

Factory-states

De soft-delete-state

Factory-callbacks

Modellen genereren

make() — niet opslaan in de DB

create() — opslaan in de DB

Attributen overschrijven

Sequence

Factories voor relaties

Has many (één-op-veel)

Belongs to (omgekeerde relatie)

Many to many (veel-op-veel)

Polymorfe relaties

Relaties binnen de factory definiëren

recycle() — bestaande modellen hergebruiken

Gebruik bij seeding

Gebruik in tests

Volgende stappen

Databaseseeding

Introductie tot testen

​Wat zijn factories?

​Factories genereren

​Automatische detectie van modellen en factories

​Factories definiëren

​De definition()-methode

​Factory-states

​De soft-delete-state

​Factory-callbacks

​Modellen genereren

​make() — niet opslaan in de DB

​create() — opslaan in de DB

​Attributen overschrijven

​Sequence

​Factories voor relaties

​Has many (één-op-veel)

​Belongs to (omgekeerde relatie)

​Many to many (veel-op-veel)

​Polymorfe relaties

​Relaties binnen de factory definiëren

​recycle() — bestaande modellen hergebruiken

​Gebruik bij seeding

​Gebruik in tests

​Volgende stappen

Databaseseeding

Introductie tot testen

Wat zijn factories?

Factories genereren

Automatische detectie van modellen en factories

Factories definiëren

De `definition()`-methode

Factory-states

De soft-delete-state

Factory-callbacks

Modellen genereren

make() — niet opslaan in de DB

create() — opslaan in de DB

Attributen overschrijven

Sequence

Factories voor relaties

Has many (één-op-veel)

Belongs to (omgekeerde relatie)

Many to many (veel-op-veel)

Polymorfe relaties

Relaties binnen de factory definiëren

recycle() — bestaande modellen hergebruiken

Gebruik bij seeding

Gebruik in tests

Volgende stappen