Fixture composition in PyTest - Build an Automation Script

Test fixture composition with pytest fixtures

Preconditions (2)

Step 1: Create a fixture named 'db_connection' that returns a string 'db_connected'

Step 2: Create another fixture named 'user' that depends on 'db_connection' fixture and returns 'user_from_' concatenated with the db_connection value

Step 3: Write a test function that uses the 'user' fixture

Step 4: Inside the test, assert that the 'user' fixture value equals 'user_from_db_connected'

✅ Expected Result: The test passes confirming that fixture composition works correctly

Automation Requirements - pytest

Assertions Needed:

Assert that the composed fixture returns the expected combined string

Best Practices:

Use pytest fixtures with proper scope

Use fixture dependency injection by passing fixtures as function arguments

Keep fixtures simple and composable

Automated Solution

PyTest

import pytest

@pytest.fixture
def db_connection():
    return 'db_connected'

@pytest.fixture
def user(db_connection):
    return f'user_from_{db_connection}'

def test_user_fixture(user):
    assert user == 'user_from_db_connected'

The db_connection fixture returns a simple string representing a database connection.

The user fixture depends on db_connection by accepting it as a parameter. It composes a new string using the value from db_connection.

The test function test_user_fixture uses the user fixture and asserts that the returned value matches the expected composed string.

This shows how pytest fixtures can be composed by passing one fixture into another, making tests modular and reusable.

Common Mistakes - 3 Pitfalls

Not passing dependent fixture as a parameter to the fixture function

Using print statements instead of assertions in tests

Defining fixtures inside test functions

Bonus Challenge

Now add data-driven testing with 3 different db_connection values and verify the composed user fixture for each.

Show Hint

Practice

1. What is the main benefit of using fixture composition in pytest?

easy

A. It speeds up test execution by running tests in parallel.

B. It automatically generates test data without coding.

C. It replaces the need for assertions in tests.

D. It allows reusing simple fixtures to build complex test setups.

Solution

1. Step 1: Understand fixture composition purpose

   Fixture composition means using simple fixtures inside other fixtures to build complex setups.

2. Step 2: Identify the main benefit

   This avoids repeating code and makes tests easier to maintain by reusing fixtures.

3. Final Answer:

   It allows reusing simple fixtures to build complex test setups. -> Option D

4. Quick Check:

   Fixture composition = reuse fixtures [OK]

Hint: Fixture composition means combining fixtures to reuse setup code [OK]

Common Mistakes:

• Thinking fixture composition auto-generates data
• Confusing fixture composition with test parallelization
• Believing it removes the need for assertions

2. Which of the following is the correct way to use a fixture inside another fixture in pytest?

easy

A. def fixture_a(fixture_b): pass

B. def fixture_a(): fixture_b()

C. @pytest.fixture
class fixture_a(fixture_b): pass

D. def fixture_a(): yield fixture_b

Solution

1. Step 1: Recall fixture dependency syntax

   In pytest, to use one fixture inside another, list the dependent fixture as a parameter.

2. Step 2: Check options for correct syntax

   def fixture_a(fixture_b): pass shows a fixture function with another fixture as a parameter, which is correct.

3. Final Answer:

   def fixture_a(fixture_b): pass -> Option A

4. Quick Check:

   Fixture dependency = parameter in fixture function [OK]

Hint: Use fixture names as parameters to compose fixtures [OK]

Common Mistakes:

• Calling fixture functions directly inside another fixture
• Using class syntax for fixtures incorrectly
• Yielding fixture names instead of using parameters

3. Given the code below, what will be the output when running test_combined?

import pytest

@pytest.fixture
def data():
    return 5

@pytest.fixture
def multiplier(data):
    return data * 2

def test_combined(multiplier):
    assert multiplier == 10
    print(f"Result: {multiplier}")

medium

A. Test fails with assertion error

B. Test passes and prints 'Result: 10'

C. RuntimeError due to missing fixture

D. SyntaxError in fixture definition

Solution

1. Step 1: Trace fixture values

   The fixture data returns 5. The fixture multiplier uses data and returns 5 * 2 = 10.

2. Step 2: Analyze test behavior

   The test receives multiplier as 10, asserts it equals 10 (true), then prints 'Result: 10'.

3. Final Answer:

   Test passes and prints 'Result: 10' -> Option B

4. Quick Check:

   Fixture value = 10, assertion true [OK]

Hint: Follow fixture return values step-by-step to predict output [OK]

Common Mistakes:

• Assuming fixture returns original data, not multiplied
• Expecting runtime errors without missing fixtures
• Confusing syntax errors with correct fixture code

4. Identify the error in the following fixture composition code:

import pytest

@pytest.fixture
def base_value():
    return 3

@pytest.fixture
def composed_fixture():
    value = base_value
    return value + 2

def test_value(composed_fixture):
    assert composed_fixture == 5

medium

A. test_value should not take composed_fixture as parameter

B. composed_fixture should not return a value

C. Missing parentheses when calling base_value fixture inside composed_fixture

D. base_value fixture should be a class, not a function

Solution

1. Step 1: Check how base_value is used inside composed_fixture

   Inside composed_fixture, value = base_value assigns the function, not its result.

2. Step 2: Correct usage of fixture call

   Fixtures are injected by pytest, but inside another fixture you must accept them as parameters or call them properly. Here, base_value should be a parameter or called with parentheses if used directly.

3. Final Answer:

   Missing parentheses when calling base_value fixture inside composed_fixture -> Option C

4. Quick Check:

   Fixture call needs parentheses or parameter injection [OK]

Hint: Use fixture names as parameters, not direct calls without parentheses [OK]

Common Mistakes:

• Assigning fixture function instead of calling it
• Returning values incorrectly from fixtures
• Misunderstanding fixture injection in tests

5. You want to create a fixture full_setup that uses two fixtures db_connection and user_data. The full_setup should return a dictionary combining both. Which code correctly composes these fixtures?

hard

A. import pytest

@pytest.fixture
def full_setup(db_connection, user_data):
return {**db_connection, **user_data}

B. import pytest

@pytest.fixture
def full_setup():
db = db_connection()
user = user_data()
return {**db, **user}

C. import pytest

@pytest.fixture
def full_setup():
return {**db_connection, **user_data}

D. import pytest

@pytest.fixture
def full_setup(db_connection, user_data):
return db_connection + user_data

Solution

1. Step 1: Understand fixture composition with parameters

   Fixtures can be composed by listing dependent fixtures as parameters in the fixture function.

2. Step 2: Check correct dictionary merging

   import pytest @pytest.fixture def full_setup(db_connection, user_data): return {**db_connection, **user_data} correctly accepts both fixtures as parameters and merges their dictionaries using unpacking syntax.

3. Final Answer:

   import pytest @pytest.fixture def full_setup(db_connection, user_data): return {**db_connection, **user_data} -> Option A

4. Quick Check:

   Fixture composition with parameters and dict merge [OK]

Hint: List fixtures as parameters and merge results properly [OK]

Common Mistakes:

• Calling fixtures like functions inside another fixture
• Trying to merge fixtures without parameters
• Using unsupported operations like + on dicts