Factory definitions in Laravel - Step-by-Step Execution

Concept Flow - Factory definitions

Create Factory Class

↓

Define Model & Fields

↓

Set Default Values

↓

Use Factory to Generate Data

↓

Create Model Instances

↓

Done

This flow shows how Laravel factory definitions are created and used to generate model instances with default or customized data.

Execution Sample

Laravel

use Illuminate\Database\Eloquent\Factories\Factory;

class UserFactory extends Factory {
  protected $model = User::class;
  public function definition() {
    return ['name' => fake()->name(), 'email' => fake()->unique()->safeEmail()];
  }
}

Defines a User factory that sets default name and email values for new User instances.

Execution Table

Step	Action	Code Evaluated	Result
1	Create UserFactory class	class UserFactory extends Factory	Factory class ready for User model
2	Set model property	protected $model = User::class;	Factory linked to User model
3	Define default data	definition() returns ['name' => fake()->name(), 'email' => fake()->unique()->safeEmail()]	Default attributes set for User
4	Call UserFactory::new()->create()	Creates a User instance with default data	User instance saved with generated name and email
5	Call UserFactory::new()->make()	Creates a User instance without saving	User instance created but not saved to DB
6	Exit	No more factory calls	Factory usage complete

💡 Factory calls complete, model instances created or made as requested

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
UserFactory	undefined	Class defined with model and definition	Instance created and saved	Instance created but not saved	Factory usage done
User instance	none	none	User with name and email saved	User with name and email unsaved	User instances exist as created

Key Moments - 2 Insights

Why does the factory use 'definition()' method to set data?

The 'definition()' method returns default attribute values for the model. Execution table step 3 shows it returns an array of fake data used when creating instances.

What is the difference between 'create()' and 'make()' in factory usage?

'create()' saves the model instance to the database, while 'make()' only creates it in memory without saving. Steps 4 and 5 in the execution table show this difference.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 3?

A The factory class is linked to the User model

B Default attribute values are defined for the User model

C A User instance is created and saved

D The factory class is created

💡 Hint

Refer to the 'Action' and 'Result' columns at step 3 in the execution table

At which step is a User instance created but not saved to the database?

A Step 5

B Step 4

C Step 2

D Step 6

💡 Hint

Check the 'Action' column for 'make()' usage in the execution table

If you want to customize the email when creating a User, which part of the factory would you modify or override?

A The $model property

B The create() method call

C The definition() method

D The factory class name

💡 Hint

Look at how default data is set in the definition() method in the execution sample

Concept Snapshot

Laravel Factory Definitions:
- Create a factory class extending Factory
- Set protected $model to link model
- Define default attributes in definition() method
- Use create() to save instances, make() to create without saving
- Factories help generate test or seed data easily

Full Transcript

This visual execution trace shows how Laravel factory definitions work. First, a factory class is created and linked to a model using the protected $model property. Then, the definition() method returns default attribute values using faker data. When the factory is used, calling create() generates and saves a model instance with these defaults, while make() creates an instance without saving. Variables track the factory class and model instances through these steps. Key points include understanding the role of definition() for default data and the difference between create() and make(). This helps beginners see how factories automate model instance creation for testing or seeding.