Eloquent Factories

Tempo de leitura: 5 minutos

Eloquent Factories: Em desenvolvimento web, a necessidade de dados de teste realistas é constante. Seja para testar a interface do usuário, verificar o funcionamento de funcionalidades ou popular o banco de dados para desenvolvimento local, gerar dados fictícios de forma eficiente é crucial. O Laravel oferece uma solução elegante para esse problema: as laravel eloquent factories.

As factories permitem definir um “modelo” para seus models Eloquent e gerar instâncias desse modelo com dados aleatórios, mas consistentes.

Este artigo explora em detalhes o uso de laravel eloquent factories, desde a definição básica até a criação de relacionamentos complexos.

O que são Laravel Eloquent Factories?

Eloquent Factories: As factories são classes que definem um conjunto de atributos padrão para seus models Eloquent. Elas usam a biblioteca Faker PHP para gerar dados aleatórios, como nomes, emails, endereços, textos, etc. A grande vantagem é que você pode personalizar esses dados e definir relacionamentos entre factories, tornando a geração de dados muito mais flexível e realista.

Definindo Model Factories

Para criar uma factory, utilize o comando Artisan make:factory:

Bash

php artisan make:factory UserFactory

Este comando criará um arquivo UserFactory.php no diretório database/factories. O arquivo contém um método definition() onde você define os atributos padrão do model:

PHP

<?php

namespace Database\Factories;

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

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\User>
 */
class UserFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'email' => fake()->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => Hash::make('password'), // password
            'remember_token' => Str::random(10),
        ];
    }

    /**
     * Indicate that the model's email address should be unverified.
     */
    public function unverified(): static
    {
        return $this->state(fn (array $attributes) => [
            'email_verified_at' => null,
        ]);
    }
}

Dentro do método definition(), você usa o helper fake() para gerar dados aleatórios. A biblioteca Faker oferece uma variedade de métodos para gerar diferentes tipos de dados. Consulte a documentação do Faker para obter uma lista completa de métodos disponíveis.

Personalizando Factories:

Você pode personalizar os valores gerados pela factory usando closures ou definindo estados.

Usando Closures:

PHP

'email' => function (array $attributes) {
    return strtolower(str_replace(' ', '.', $attributes['name'])) . '@example.com';
},

Definindo Estados:

Estados permitem definir variações da sua factory.

PHP

/**
 * Indicate that the user is an administrator.
 */
public function admin(): static
{
    return $this->state(function (array $attributes) {
        return [
            'is_admin' => true,
        ];
    });
}

Criando Models usando Factories

Para criar instâncias do seu model usando a factory, você pode usar o método estático factory() no seu model:

PHP

use App\Models\User;

$user = User::factory()->make(); // Cria uma instância do model, mas não persiste no banco de dados
$user = User::factory()->create(); // Cria uma instância e persiste no banco de dados
$users = User::factory(5)->create(); // Cria 5 instâncias e persiste no banco de dados

// Usando estados:
$adminUser = User::factory()->admin()->create(); // Cria um usuário administrador
$unverifiedUser = User::factory()->unverified()->create(); // Cria um usuario com email não verificado

O método make() retorna uma instância do model, mas não a salva no banco de dados. O método create() cria e salva a instância no banco de dados. Você pode passar um número como argumento para factory() para criar múltiplas instâncias.

Você também pode sobrescrever atributos específicos ao criar instâncias:

PHP

$user = User::factory()->create([
    'name' => 'João Silva',
    'email' => '[email protected]',
]);

Relacionamento Factories

Um dos recursos mais poderosos das factories é a capacidade de definir relacionamentos entre models. Isso permite gerar dados mais complexos e realistas, simulando as relações entre as tabelas do seu banco de dados.

Relacionamento One-to-Many

Suponha que você tenha os models User e Post. Um usuário pode ter vários posts.

PHP

// app/Models/User.php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;


class User extends Model
{
    use HasFactory;
    public function posts(): HasMany
    {
        return $this->hasMany(Post::class);
    }
}

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Post extends Model
{
    use HasFactory;
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

// database/factories/PostFactory.php
<?php

namespace Database\Factories;

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

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Post>
 */
class PostFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    protected $model = Post::class;
    public function definition(): array
    {
        return [
            'user_id' => User::factory(), // Cria um usuário relacionado
            'title' => fake()->sentence(),
            'body' => fake()->paragraph(),
        ];
    }
}

Agora, ao criar um post usando a factory, um usuário relacionado também será criado automaticamente:

PHP

$post = Post::factory()->create();
echo $post->user->name; // Acessa o nome do usuário criado automaticamente

Você também pode criar vários posts para um único usuário:

PHP

$user = User::factory()->create();
$posts = Post::factory(3)->create(['user_id' => $user->id]);

Ou, ainda mais concisamente, usando o método has():

PHP

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

Este último exemplo cria um usuário e 3 posts relacionados a ele.

Exemplo Completo: Criando usuários com posts e comentários

PHP

// database/factories/CommentFactory.php
<?php

namespace Database\Factories;

use App\Models\Comment;
use App\Models\Post;
use Illuminate\Database\Eloquent\Factories\Factory;

class CommentFactory extends Factory
{
    protected $model = Comment::class;
    public function definition(): array
    {
        return [
            'post_id' => Post::factory(),
            'content' => fake()->text(),
        ];
    }
}

// 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
    {
        User::factory(10)->create()->each(function ($user) {
           Post::factory(rand(1,3))->create(['user_id' => $user->id])->each(function($post){
                Comment::factory(rand(2,5))->create(['post_id'=>$post->id]);
           });
        });
    }
}

Este exemplo cria 10 usuários, entre 1 e 3 posts para cada usuário e entre 2 e 5 comentários para cada post.

PHP

// database/factories/CommentFactory.php
<?php

namespace Database\Factories;

use App\Models\Comment;
use App\Models\Post;
use Illuminate\Database\Eloquent\Factories\Factory;

class CommentFactory extends Factory
{
    protected $model = Comment::class;
    public function definition(): array
    {
        return [
            'post_id' => Post::factory(),
            'content' => fake()->text(),
        ];
    }
}

// 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
    {
        User::factory(10)->create()->each(function ($user) {
           Post::factory(rand(1,3))->create(['user_id' => $user->id])->each(function($post){
                Comment::factory(rand(2,5))->create(['post_id'=>$post->id]);
           });
        });
    }
}

Este exemplo cria 10 usuários, entre 1 e 3 posts para cada usuário e entre 2 e 5 comentários para cada post.

Conclusão

Eloquent Factories: As laravel eloquent factories são uma ferramenta essencial para simplificar a geração de dados de teste no Laravel. Elas permitem definir modelos de dados reutilizáveis, gerar dados aleatórios realistas e criar relacionamentos complexos entre models. O uso de factories melhora significativamente a eficiência do desenvolvimento e dos testes, garantindo um ambiente de teste consistente e dados fictícios úteis para o desenvolvimento local.

Dominar as factories é fundamental para qualquer desenvolvedor Laravel que busca escrever testes robustos e manter um fluxo de trabalho eficiente. Com os exemplos e explicações apresentados neste artigo, você está pronto para começar a usar factories em seus projetos e aprimorar a qualidade do seu código.

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: