Factory fixtures in PyTest - Build an Automation Script

Automate user creation using factory fixture

Preconditions (2)

Step 1: Create a factory fixture that generates User instances with default values

Step 2: Use the factory fixture to create a user in the test

Step 3: Verify the created user has the expected default username and email

Step 4: Verify the user is active by default

✅ Expected Result: The test should create a User instance using the factory fixture and assert that the username, email, and is_active fields have the expected default values.

Automation Requirements - pytest

Assertions Needed:

Assert the username equals the default username from the factory

Assert the email equals the default email from the factory

Assert is_active is True

Best Practices:

Use pytest fixtures to define the factory

Use factory_boy for factory implementation

Keep test isolated and independent

Use clear and descriptive assertion messages

Automated Solution

PyTest

import pytest
import factory

# Simulated User model for testing
class User:
    def __init__(self, username, email, is_active=True):
        self.username = username
        self.email = email
        self.is_active = is_active

# Factory class for User
class UserFactory(factory.Factory):
    class Meta:
        model = User

    username = "testuser"
    email = "[e-mail]"
    is_active = True

@pytest.fixture
def user_factory():
    return UserFactory

def test_create_user_with_factory(user_factory):
    user = user_factory()
    assert user.username == "testuser", f"Expected username 'testuser', got {user.username}"
    assert user.email == "[e-mail]", f"Expected email '[e-mail]', got {user.email}"
    assert user.is_active is True, f"Expected is_active True, got {user.is_active}"

This test uses factory_boy to create a UserFactory that generates User instances with default values.

The user_factory pytest fixture returns the factory class, so the test can call it to create a user.

The test test_create_user_with_factory calls the factory to create a user and then asserts the username, email, and is_active fields match the expected defaults.

Assertions include messages to help understand failures.

This approach keeps test data creation clean and reusable.

Common Mistakes - 4 Pitfalls

Not using a fixture for the factory and creating factory instances directly in the test

{'mistake': 'Hardcoding user data in the test instead of using factory defaults', 'why_bad': 'Leads to duplication and brittle tests if defaults change.', 'correct_approach': "Use the factory's default attributes and assert against them."}

Not asserting all important fields like is_active

Using print statements instead of assertions

Bonus Challenge

Now add data-driven testing with 3 different user inputs using the factory fixture

Show Hint

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