Why Factory fixtures in PyTest? - Purpose & Use Cases

The Big Idea

What if you could create all your test data with one simple function and never repeat setup code again?

The Scenario

Imagine you have to test many parts of your app that need user data. You create a user manually each time by writing long setup code. You repeat this for every test.

The Problem

This manual setup is slow and boring. You might forget to add some details or make mistakes. Changing user data means updating many tests, which wastes time and causes errors.

The Solution

Factory fixtures let you write one simple function to create users with default data. You can reuse it in many tests and customize only what you need. This saves time and avoids mistakes.

Before vs After

✗ Before

def test_user():
    user = User(name='Alice', age=30, email='[e-mail]')
    assert user.is_active

✓ After

import pytest

@pytest.fixture
def user_factory():
    def create_user(**kwargs):
        data = {'name': 'Alice', 'age': 30, 'email': '[e-mail]'}
        data.update(kwargs)
        return User(**data)
    return create_user

def test_user(user_factory):
    user = user_factory()
    assert user.is_active

What It Enables

Factory fixtures make your tests faster, cleaner, and easier to change, so you can focus on testing logic, not setup.

Real Life Example

When testing an online store, you can quickly create many products with different prices and categories using a factory fixture, instead of writing setup code for each product.

Key Takeaways

Manual setup is slow and error-prone.

Factory fixtures create reusable, customizable test data.

This leads to faster, clearer, and more reliable tests.

Practice

1. What is the main purpose of a factory fixture in pytest?

easy

A. To run tests in parallel automatically

B. To create reusable test data with flexible parameters

C. To generate test reports in HTML format

D. To mock external API calls during tests

Solution

1. Step 1: Understand what factory fixtures do

   Factory fixtures return a function that can create test data with different parameters as needed.

2. Step 2: Compare with other options

   Running tests in parallel, generating reports, or mocking APIs are different pytest features, not factory fixtures.

3. Final Answer:

   To create reusable test data with flexible parameters -> Option B

4. Quick Check:

   Factory fixture = reusable flexible test data creator [OK]

Hint: Factory fixtures build test data functions fast [OK]

Common Mistakes:

• Confusing factory fixtures with mocking
• Thinking factory fixtures run tests
• Assuming factory fixtures generate reports

2. Which of the following is the correct way to define a simple factory fixture in pytest?

easy

A. @pytest.fixture
def user_factory(name):
return {'name': name}

B. def user_factory():
return {'name': 'default'}

C. @pytest.fixture
def user_factory():
def create_user(name):
return {'name': name}
return create_user

D. @pytest.fixture
def user_factory():
return {'name': 'default'}

Solution

1. Step 1: Identify factory fixture structure

   A factory fixture returns a function that accepts parameters to create test data dynamically.

2. Step 2: Check each option

   @pytest.fixture def user_factory(): def create_user(name): return {'name': name} return create_user defines a fixture returning a function that takes a name and returns a dict, which is correct. Options A, C, and D do not return a function, so they are not factory fixtures.

3. Final Answer:

   @pytest.fixture def user_factory(): def create_user(name): return {'name': name} return create_user -> Option C

4. Quick Check:

   Factory fixture = fixture returning a function [OK]

Hint: Factory fixtures return a function inside the fixture [OK]

Common Mistakes:

• Returning data directly instead of a function
• Missing @pytest.fixture decorator
• Defining fixture with parameters directly

3. Given the following pytest code, what will be the output of the test?

@pytest.fixture
def number_factory():
    def create_number(x):
        return x * 2
    return create_number

def test_double(number_factory):
    result = number_factory(5)
    assert result == 10
    print(result)

medium

A. Test passes and prints 10

B. Test fails with AssertionError

C. SyntaxError due to fixture usage

D. Test passes but prints 5

Solution

1. Step 1: Understand the factory fixture behavior

   The fixture returns a function that doubles the input number.

2. Step 2: Analyze the test function

   The test calls number_factory(5), which returns 5 * 2 = 10, then asserts result == 10, which is true, so test passes and prints 10.

3. Final Answer:

   Test passes and prints 10 -> Option A

4. Quick Check:

   5 * 2 = 10, assertion true [OK]

Hint: Factory fixture returns function; call it with argument [OK]

Common Mistakes:

• Thinking fixture itself is called with argument
• Expecting print output to fail test
• Confusing assertion logic

4. Identify the error in this factory fixture code and how to fix it:

@pytest.fixture
def item_factory():
    def create_item(name, price):
        return {'name': name, 'price': price}
    return create_item

def test_item(item_factory):
    item = item_factory('Book')
    assert item['price'] == 10

medium

A. The fixture is missing @pytest.mark.parametrize decorator; add it.

B. The fixture should not return a function; fix by returning a dict directly.

C. The test should not use the fixture as a function; fix by removing parentheses.

D. The factory function is missing the 'price' argument; fix by passing price when calling.

Solution

1. Step 1: Check the factory function parameters

   The factory function create_item expects two arguments: name and price.

2. Step 2: Analyze the test call

   The test calls item_factory('Book') with only one argument, missing price, causing an error or wrong data.

3. Final Answer:

   The factory function is missing the 'price' argument; fix by passing price when calling. -> Option D

4. Quick Check:

   Factory args must match call args [OK]

Hint: Match factory function parameters with call arguments [OK]

Common Mistakes:

• Calling factory with fewer arguments than defined
• Returning dict directly instead of function
• Misusing fixture as a simple variable

5. You want to create a factory fixture that builds user dictionaries with optional age and default country='USA'. Which of the following implementations correctly achieves this?

hard

A. @pytest.fixture
def user_factory():
def create_user(name, age=None, country='USA'):
return {'name': name, 'age': age, 'country': country}
return create_user

B. @pytest.fixture
def user_factory(name, age=None, country='USA'):
return {'name': name, 'age': age, 'country': country}

C. @pytest.fixture
def user_factory():
return {'name': 'default', 'age': None, 'country': 'USA'}

D. @pytest.fixture
def user_factory():
def create_user(name, age, country):
return {'name': name, 'age': age, 'country': country}
return create_user

Solution

1. Step 1: Understand factory fixture with optional/default parameters

   The factory fixture should return a function that accepts parameters with defaults for optional values.

2. Step 2: Evaluate each option

   @pytest.fixture def user_factory(): def create_user(name, age=None, country='USA'): return {'name': name, 'age': age, 'country': country} return create_user correctly defines a fixture returning a function with default age=None and country='USA'. @pytest.fixture def user_factory(name, age=None, country='USA'): return {'name': name, 'age': age, 'country': country} is not a factory fixture because it takes parameters directly. @pytest.fixture def user_factory(): return {'name': 'default', 'age': None, 'country': 'USA'} returns a fixed dict, not a factory. @pytest.fixture def user_factory(): def create_user(name, age, country): return {'name': name, 'age': age, 'country': country} return create_user requires all parameters without defaults, so age and country are not optional.

3. Final Answer:

   @pytest.fixture def user_factory(): def create_user(name, age=None, country='USA'): return {'name': name, 'age': age, 'country': country} return create_user -> Option A

4. Quick Check:

   Factory fixture returns function with defaults [OK]

Hint: Factory fixture returns function with default parameters [OK]

Common Mistakes:

• Defining fixture with parameters directly
• Not providing default values for optional args
• Returning fixed data instead of a function