Factory Boy for test data in Django - Step-by-Step Execution

Concept Flow - Factory Boy for test data

Define Factory Class

↓

Set Attributes & Defaults

↓

Call Factory to Create Instance

↓

Factory Builds Model Instance

↓

Instance Ready for Test Use

Factory Boy creates test data by defining factory classes with default attributes, then builds model instances when called.

Execution Sample

Django

import factory
from myapp.models import User

class UserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = User
    username = factory.Faker('user_name')

user = UserFactory()

Defines a UserFactory to create User model instances with fake usernames for tests.

Execution Table

Step	Action	Evaluation	Result
1	Define UserFactory class	Class created with Meta model User	Factory ready to build User instances
2	Set username attribute	Uses Faker to generate username	username attribute set to fake value
3	Call UserFactory()	Triggers factory build	New User instance created with fake username
4	User instance returned	Instance has username attribute	Instance ready for test use
5	End	No more actions	Factory usage complete

💡 Factory call completes after creating and returning the model instance

Variable Tracker

Variable	Start	After Step 3	Final
UserFactory	Class defined	Callable factory	Callable factory
user	Undefined	User instance with fake username	User instance with fake username

Key Moments - 2 Insights

Why does calling UserFactory() create a User instance instead of just returning the factory?

Calling UserFactory() triggers the factory's build process, which creates and returns a new User model instance as shown in execution_table step 3.

How does the username get a fake value automatically?

The username attribute uses factory.Faker('user_name'), so when the factory builds the instance, Faker generates a realistic fake username (see execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution table, what is the result after step 3?

A A new User instance with a fake username is created

B The factory class is deleted

C No instance is created yet

D The username attribute is empty

💡 Hint

Check the 'Result' column in step 3 of the execution_table

At which step does the factory set the username attribute using Faker?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Evaluation' columns in step 2 of the execution_table

If you call UserFactory() twice, what changes in variable_tracker for 'user'?

A It remains the same instance

B It becomes undefined

C It holds a new User instance each time

D It throws an error

💡 Hint

Factory creates a new instance on each call, so variable 'user' changes to a new instance

Concept Snapshot

Factory Boy creates test data by defining factory classes linked to models.
Set default or fake attributes inside the factory.
Calling the factory builds and returns a model instance.
Use Faker for realistic fake data.
Great for clean, reusable test data setup.

Full Transcript

Factory Boy helps create test data in Django by defining factory classes for models. You write a factory class with a Meta inner class pointing to your model. Inside, you set attributes, often using Faker to generate fake data. When you call the factory, it builds and returns a new model instance with those attributes. This lets you quickly create realistic test data without manually writing it each time. The execution flow starts with defining the factory, setting attributes, calling the factory to build, and finally getting the instance ready for tests.

Practice

1. What is the main purpose of using Factory Boy in Django testing?

easy

A. To create reusable fake data for tests easily

B. To speed up the Django server

C. To replace Django's ORM

D. To deploy Django applications automatically

Solution

1. Step 1: Understand Factory Boy's role

   Factory Boy is designed to generate fake data for tests, making test setup easier and less repetitive.

2. Step 2: Eliminate unrelated options

   Speeding up the server, replacing ORM, or deployment are unrelated to test data creation.

3. Final Answer:

   To create reusable fake data for tests easily -> Option A

4. Quick Check:

   Factory Boy = reusable fake test data [OK]

Hint: Factory Boy = fake test data creator [OK]

Common Mistakes:

• Thinking Factory Boy speeds up the server
• Confusing Factory Boy with deployment tools
• Assuming Factory Boy replaces Django ORM

2. Which of the following is the correct way to define a basic factory for a Django model Book using Factory Boy?

easy

A. class BookFactory(factory.DjangoModelFactory): class Meta: model = Book

B. class BookFactory(factory.Factory): model = Book

C. class BookFactory(factory.ModelFactory): model = Book

D. class BookFactory(factory.DjangoFactory): class Meta: model = Book

Solution

1. Step 1: Identify correct base class

   Factory Boy uses DjangoModelFactory as the base class for Django models.

2. Step 2: Check Meta class usage

   The model must be specified inside a nested Meta class with attribute model.

3. Final Answer:

   class BookFactory(factory.DjangoModelFactory): class Meta: model = Book -> Option A

4. Quick Check:

   DjangoModelFactory + Meta.model = correct syntax [OK]

Hint: Use DjangoModelFactory with Meta.model for Django models [OK]

Common Mistakes:

• Using factory.Factory instead of DjangoModelFactory
• Not using a Meta class for model assignment
• Using incorrect base class names

3. Given this factory definition:

class UserFactory(factory.DjangoModelFactory):
    class Meta:
        model = User
    username = factory.Faker('user_name')
    email = factory.Faker('email')

What will UserFactory().username return?

medium

A. None, because username is not set

B. The literal string 'user_name'

C. An error because Faker is not imported

D. A random username string generated by Faker

Solution

1. Step 1: Understand Faker usage in Factory Boy

   Using factory.Faker('user_name') generates a random username string each time the factory is called.

2. Step 2: Evaluate the expression UserFactory().username

   Calling UserFactory() creates a User instance with a random username, so .username returns that random string.

3. Final Answer:

   A random username string generated by Faker -> Option D

4. Quick Check:

   Faker('user_name') = random username string [OK]

Hint: Faker fields produce random data, not literals [OK]

Common Mistakes:

• Thinking Faker returns the field name as string
• Assuming missing imports cause runtime error here
• Expecting None if not explicitly set

4. What is wrong with this factory code?

class ProductFactory(factory.DjangoModelFactory):
    class Meta:
        model = Product
    name = factory.Faker('product_name')
    price = factory.Faker('float')

medium

A. Faker does not have a 'product_name' provider

B. The 'float' provider requires arguments to specify range

C. Missing import of factory module

D. Meta class should be outside the factory class

Solution

1. Step 1: Check Faker providers used

   Faker has no built-in 'product_name' provider, but this is a common custom name; however, 'float' requires arguments like min and max.

2. Step 2: Identify the error cause

   Using factory.Faker('float') without arguments causes an error because Faker's float provider needs parameters.

3. Final Answer:

   The 'float' provider requires arguments to specify range -> Option B

4. Quick Check:

   Faker float needs min/max args [OK]

Hint: Faker float needs range arguments to work [OK]

Common Mistakes:

• Assuming 'product_name' is always valid
• Ignoring required arguments for Faker float
• Thinking Meta class placement is wrong

5. You want to create a factory for a Django model Order that has a foreign key to User. How do you correctly define the user field in OrderFactory to use UserFactory?

hard

A. user = UserFactory()

B. user = factory.RelatedFactory(UserFactory)

C. user = factory.SubFactory(UserFactory)

D. user = factory.Faker('user')

Solution

1. Step 1: Understand foreign key factory usage

   To link a foreign key to another factory, use factory.SubFactory with the related factory class.

2. Step 2: Evaluate options

   Directly calling UserFactory() assigns an instance at class load time, not per object. RelatedFactory is for reverse relations. Faker does not create model instances.

3. Final Answer:

   user = factory.SubFactory(UserFactory) -> Option C

4. Quick Check:

   Foreign key uses SubFactory [OK]

Hint: Use SubFactory for foreign key relations [OK]

Common Mistakes:

• Calling UserFactory() directly in factory field
• Using RelatedFactory for foreign keys
• Using Faker for model relations