Eloquent Factories

Tempo de leitura: 4 minutos

Eloquent Factories: O desenvolvimento e teste de aplicações Laravel exigem dados de teste consistentes e realistas. As Laravel Eloquent Factories são classes poderosas que definem blueprints (modelos) para seus Models Eloquent, permitindo a geração de instâncias de Models com dados fictícios de forma rápida e controlada, graças à integração com a biblioteca Faker PHP.

Este artigo explora como definir, personalizar e utilizar as Factories para gerar dados complexos, incluindo relacionamentos.

1. ⚙️ Definição Básica de uma Factory

A. Geração

Para criar uma Factory (ex: para o Model User), use o Artisan:

Bash

php artisan make:factory UserFactory --model=User
# O --model=User é opcional, mas define a propriedade $model na factory

B. O Método `definition()`

A lógica central da Factory está no método definition(), onde você retorna um array de atributos. Use o helper fake() para acessar os métodos da biblioteca Faker.

PHP

// database/factories/UserFactory.php
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Hash;

class UserFactory extends Factory
{
    // Define o estado padrão (default state) do Model
    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'email' => fake()->unique()->safeEmail(),
            'email_verified_at' => now(),
            // Hash::make('password') garante uma senha segura e consistente
            'password' => Hash::make('password'), 
            'remember_token' => Str::random(10),
        ];
    }
}

2. 🚀 Criando Instâncias de Models

As Factories são acessadas através do método estático factory() do Model.

Método	Ação	Descrição
`make()`	Cria Models em memória	Retorna instâncias do Model (`App\Models\User`), mas não persiste no banco de dados.
`create()`	Cria Models e salva no DB	Cria instâncias do Model e as persiste no banco de dados.
`factory(N)`	Cria N instâncias	Pode ser usado com `make()` ou `create()`. Ex: `User::factory(5)->create();`

Sobrescrevendo Atributos:

Você pode passar um array para make() ou create() para sobrescrever os atributos definidos no definition().

PHP

// Cria um usuário com dados fictícios, mas com email e nome específicos
$user = User::factory()->create([
    'name' => 'João Silva',
    'email' => '[email protected]',
]);

3. 🚦 Definindo e Usando Estados

Os Estados (States) permitem definir variações na saída da sua Factory, tornando-a reutilizável.

A. Definição de um Estado

Os métodos de estado devem retornar o resultado do método state().

PHP

class UserFactory extends Factory
{
    // ... definition() ...

    /**
     * Indica que o usuário é um administrador.
     */
    public function admin(): static
    {
        return $this->state(fn (array $attributes) => [
            'is_admin' => true,
        ]);
    }
}

B. Uso de Estados

PHP

// Cria 1 usuário administrador e 10 usuários normais
$admin = User::factory()->admin()->create();
$users = User::factory(10)->create();

4. 🔗 Factories e Relacionamentos

As Factories brilham ao lidar com relacionamentos, permitindo a criação de gráficos de dados complexos com facilidade.

A. Criando o Relacionamento `BelongsTo` (Chave Estrangeira)

No Model filho (Post), defina a chave estrangeira (user_id) para que a Factory do Model pai (User) seja executada.

PHP

// database/factories/PostFactory.php
use App\Models\User;

class PostFactory extends Factory
{
    public function definition(): array
    {
        return [
            // Isso garante que um User será criado e seu ID será usado aqui.
            'user_id' => User::factory(), 
            'title' => fake()->sentence(),
            'body' => fake()->paragraph(),
        ];
    }
}

// Ao executar:
$post = Post::factory()->create(); // Cria 1 Post E 1 User.

B. Criando Relacionamentos Aninhados com `has()`

Para criar um Model e seus relacionamentos HasMany ou HasOne, use o método has().

PHP

// Cria 1 usuário e 5 posts relacionados a ele.
$user = User::factory()
            ->has(Post::factory(5)) 
            ->create();

// Cria 1 post, 3 comentários e 1 tag relacionada a este post.
$post = Post::factory()
            ->has(Comment::factory(3))
            ->has(Tag::factory())
            ->create();

C. Relacionamentos Aninhados Complexos (Seeding)

O Seeder é o local ideal para gerar grandes volumes de dados aninhados para o ambiente de desenvolvimento.

PHP

// database/seeders/DatabaseSeeder.php
use App\Models\User;
use App\Models\Post;
use App\Models\Comment;
use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        // Cria 10 usuários. Para cada usuário, cria de 1 a 3 posts.
        // Para cada post, cria de 2 a 5 comentários.
        User::factory(10)->create()->each(function (User $user) {
            Post::factory(rand(1, 3))
                ->has(Comment::factory(rand(2, 5)))
                ->create(['user_id' => $user->id]);
        });
    }
}

✅ Conclusão Eloquent Factories

Eloquent Factories: As Eloquent Factories são indispensáveis para o desenvolvimento e teste no Laravel. Elas garantem que você possa gerar dados fictícios realistas e consistentes de forma programática. Ao dominar a definição de Estados e a criação de Relacionamentos Aninhados (has()), você melhora drasticamente a eficiência do seu workflow, especialmente na escrita de testes de integração e no seeding do seu banco de dados de desenvolvimento.

Mas antes de dominar o Laravel, se for o seu caso, toda jornada tem um início. Vamos entender quais são os conhecimentos básicos necessários para aproveitar ao máximo este poderoso framework. Para iniciar seus estudos no Laravel, você precisará dominar as seguintes tecnologias: