Фабрики

public function __construct()

$factory = new UserFactory();
// $factory-> Faker уже создан

abstract public function definition(): array

public function definition(): array
{
    return [
        'login'         => $this->faker->unique()->userName,
        'name'          => $this->faker->name,
        'email'         => $this->faker->unique()->safeEmail,
        'password_hash' => password_hash('password', PASSWORD_DEFAULT),
        'role'          => $this->faker->randomElement(['user', 'moderator']),
        'active'        => true,
    ];
}

public static function new(): self

$factory = UserFactory::new();
$user = $factory->makeOne();

// Или цепочкой
$user = UserFactory::new()->makeOne();

public function count(int $count): self

$users = UserFactory::new()->count(10)->make();
// Генерирует 10 записей

$users = UserFactory::new()->count(50)->make();
// Генерирует 50 записей

public function state(callable $callback): self

// Через callback
$admin = UserFactory::new()->state(function (array $attrs): array {
    return ['role' => 'admin'];
})->makeOne();

// Через arrow-функцию
$inactive = UserFactory::new()->state(fn(): array => ['active' => false])->makeOne();

// Цепочка состояний
$users = UserFactory::new()
    ->count(10)
    ->state(fn(array $attrs): array => ['role' => 'moderator'])
    ->make();

public function makeOne(): array

$user = UserFactory::new()->makeOne();
// ['login' => 'ivan_ivanov', 'name' => 'Иван Иванов', ...]

echo $user['name'];

public function make(int $count = null): array

// Используя count()
$users = UserFactory::new()->count(10)->make();
// [[...], [...], ...] — 10 записей

// С явным параметром
$users = UserFactory::new()->make(5);
// 5 записей

// По умолчанию (1 запись)
$users = UserFactory::new()->make();

public function createOne(): array

$user = UserFactory::new()->createOne();
// Запись сохранена в БД

// С состоянием
$admin = UserFactory::new()->admin()->createOne();

public function create(int $count = null): array

// Используя count()
$users = UserFactory::new()->count(10)->create();
// 10 записей сохранены в БД

// С состоянием
$admins = UserFactory::new()->count(5)->admin()->create();

// Русский
$faker = \Faker\Factory::create('ru_RU');

// Английский
$faker = \Faker\Factory::create('en_US');

// Немецкий
$faker = \Faker\Factory::create('de_DE');

public static function factory(string $factoryClass, int $count = 1): array

use IO\Database\DatabaseManager;

// Генерация 10 записей
$users = DatabaseManager::factory(UserFactory::class, 10);

// Генерация 1 записи
$user = DatabaseManager::factory(UserFactory::class);

// С фабрикой с состояниями
$admins = DatabaseManager::factory(UserFactory::class, 5);

<?php
use IO\Database\Factory;

class UserFactory extends Factory
{
    public function definition(): array
    {
        return [
            'login'         => $this->faker->unique()->userName,
            'name'          => $this->faker->name,
            'email'         => $this->faker->unique()->safeEmail,
            'password_hash' => password_hash('password', PASSWORD_DEFAULT),
            'role'          => $this->faker->randomElement(['user', 'moderator']),
            'active'        => true,
        ];
    }
}

<?php
use IO\Database\Factory;

class UserFactory extends Factory
{
    public function definition(): array
    {
        return [
            'login'         => $this->faker->unique()->userName,
            'name'          => $this->faker->name,
            'email'         => $this->faker->unique()->safeEmail,
            'password_hash' => password_hash('password', PASSWORD_DEFAULT),
            'role'          => 'user',
            'active'        => true,
        ];
    }

    public function admin(): self
    {
        return $this->state(function (array $attributes): array {
            return [
                'role'  => 'admin',
                'login' => 'admin_' . $attributes['login'],
            ];
        });
    }

    public function inactive(): self
    {
        return $this->state(fn(array $attributes): array => ['active' => false]);
    }

    public function banned(): self
    {
        return $this->state(fn(array $attributes): array => [
            'active' => false,
            'role'   => 'banned',
        ]);
    }
}

<?php
use IO\Database\Factory;

class ProductFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name'        => $this->faker->words(3, true),
            'description' => $this->faker->paragraph,
            'price'       => $this->faker->randomFloat(2, 10, 10000),
            'sku'         => $this->faker->unique()->bothify('???-####'),
            'in_stock'    => $this->faker->boolean(80),
            'weight'      => $this->faker->randomFloat(2, 0.1, 50),
        ];
    }

    public function expensive(): self
    {
        return $this->state(fn(array $attributes): array => ['price' => $this->faker->randomFloat(2, 5000, 50000)]);
    }

    public function outOfStock(): self
    {
        return $this->state(fn(array $attributes): array => ['in_stock' => false]);
    }
}

<?php
use IO\Database\Factory;

class OrderFactory extends Factory
{
    public function definition(): array
    {
        return [
            'user_id' => $this->faker->numberBetween(1, 100),
            'total'   => $this->faker->randomFloat(2, 10, 5000),
            'status'  => $this->faker->randomElement([
                'pending', 'processing', 'shipped', 'delivered', 'cancelled'
            ]),
        ];
    }

    public function pending(): self
    {
        return $this->state(fn(): array => ['status' => 'pending']);
    }

    public function shipped(): self
    {
        return $this->state(fn(): array => ['status' => 'shipped']);
    }
}

<?php
use IO\Database\Factory;

class ArticleFactory extends Factory
{
    public function definition(): array
    {
        return [
            'title'        => $this->faker->sentence(6),
            'slug'         => $this->faker->unique()->slug,
            'body'         => $this->faker->paragraphs(3, true),
            'author_id'    => $this->faker->numberBetween(1, 10),
            'status'       => $this->faker->randomElement(['draft', 'published']),
            'published_at' => $this->faker->optional(70)->dateTimeThisYear,
        ];
    }

    public function published(): self
    {
        return $this->state(fn(): array => [
            'status'       => 'published',
            'published_at' => $this->faker->dateTimeThisYear,
        ]);
    }
}

use IO\Database\Factory;
use IO\Database\DatabaseManager;

// Через фабрику напрямую
$user = UserFactory::new()->makeOne();
$users = UserFactory::new()->count(10)->make();

// С состоянием
$admin = UserFactory::new()->admin()->makeOne();
$inactive = UserFactory::new()->inactive()->count(5)->make();

// Через DatabaseManager
$users = DatabaseManager::factory(UserFactory::class, 20);

// Цепочка
$users = UserFactory::new()
    ->count(10)
    ->state(fn(array $attrs): array => ['role' => 'moderator'])
    ->make();

<?php
use IO\Database\Seeder;

class ProductSeeder extends Seeder
{
    public function run(): void
    {
        $categories = ['Электроника', 'Одежда', 'Книги'];

        foreach ($categories as $category) {
            $this->insert('categories', ['name' => $category]);
            $categoryId = \IO\Database\SqlConnection::connection()
                ->getPdo()->lastInsertId();

            $products = ProductFactory::new()
                ->count(20)
    ->state(fn(): array => ['category_id' => $categoryId])
                ->make();

            foreach ($products as $product) {
                $this->insert('products', $product);
            }
        }
    }
}

class UserTest extends TestCase
{
    public function test_create_user()
    {
        $userData = UserFactory::new()->makeOne();

        $response = $this->post('/api/users', $userData);
        $response->assertStatus(201);
    }

    public function test_admin_access()
    {
        $admin = UserFactory::new()->admin()->createOne();

        $response = $this->actingAs($admin)->get('/api/admin/dashboard');
        $response->assertStatus(200);
    }

    public function test_list_users()
    {
        UserFactory::new()->count(25)->create();

        $response = $this->get('/api/users');
        $response->assertStatus(200);
        $this->assertCount(25, $response->json('data'));
    }
}

$faker = \Faker\Factory::create();
$faker->unique(true);  // Сбросить ограничение

$faker = \Faker\Factory::create('ru_RU');
$this->faker = $faker;

class ArticleFactory extends Factory
{
    public function definition(): array
    {
        return [
            'title'        => $this->faker->sentence(6),
            'slug'         => $this->faker->unique()->slug,
            'body'         => $this->faker->paragraphs(3, true),
            'author_id'    => $this->faker->numberBetween(1, 10),
            'status'       => $this->faker->randomElement(['draft', 'published']),
            'published_at' => $this->faker->optional(70)->dateTimeThisYear,
        ];
    }

    public function published(): self
    {
        return $this->state(fn(): array => [
            'status'       => 'published',
            'published_at' => $this->faker->dateTimeThisYear,
        ]);
    }
}

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $users = UserFactory::new()->count(50)->make();
        foreach ($users as $user) {
            $this->insert('users', $user);
        }
    }
}

            $products = ProductFactory::new()
                ->count(20)
                ->state(fn(): array => ['category_id' => $categoryId])
                ->make();

$users = UserFactory::new()
    ->count(10)
    ->admin()
    ->state(fn(array $attrs): array => ['active' => true])
    ->make();