Fixture dependencies (fixture using fixture) in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pytest fixture dependency execution order

Given the following pytest code with fixtures depending on each other, what will be the output when running the test?

PyTest

import pytest

@pytest.fixture
def fixture_a():
    print('Setup A')
    yield 'A'
    print('Teardown A')

@pytest.fixture
def fixture_b(fixture_a):
    print('Setup B')
    yield f'B uses {fixture_a}'
    print('Teardown B')

@pytest.fixture
def fixture_c(fixture_b):
    print('Setup C')
    yield f'C uses {fixture_b}'
    print('Teardown C')

def test_example(fixture_c):
    print(f'Running test with {fixture_c}')

A

Setup B
Setup A
Setup C
Running test with C uses B uses A
Teardown A
Teardown C
Teardown B

B

Setup C
Setup B
Setup A
Running test with C uses B uses A
Teardown A
Teardown B
Teardown C

C

Setup A
Setup C
Setup B
Running test with C uses B uses A
Teardown B
Teardown C
Teardown A

D

Setup A
Setup B
Setup C
Running test with C uses B uses A
Teardown C
Teardown B
Teardown A

💡 Hint

Remember that pytest runs fixtures in dependency order: the deepest dependency first, then upwards.

Fixture 'fixture_c' depends on 'fixture_b', which depends on 'fixture_a'. So pytest runs setup in order: fixture_a, fixture_b, fixture_c. Then the test runs. Then teardown happens in reverse order: fixture_c, fixture_b, fixture_a.

❓ assertion

intermediate

Correct assertion for fixture dependency value

Given these fixtures, which assertion correctly verifies that the test receives the expected combined fixture value?

PyTest

import pytest

@pytest.fixture
def base():
    return 5

@pytest.fixture
def dependent(base):
    return base * 2

def test_value(dependent):
    # Which assertion is correct here?

A assert dependent == 7

B assert dependent == 5

C assert dependent == 10

D assert dependent == 0

💡 Hint

The dependent fixture doubles the base fixture value.

The base fixture returns 5. The dependent fixture returns base * 2, which is 10. So the assertion must check for 10.

🔧 Debug

advanced

Identify the error in fixture dependency usage

What error will occur when running this pytest code?

PyTest

import pytest

@pytest.fixture
def fix1():
    return 1

@pytest.fixture
def fix2():
    return 2

def test_error(fix1, fix3):
    assert fix1 + fix3 == 3

A TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

B pytest fixture lookup error: fixture 'fix3' not found

C NameError: name 'fix3' is not defined

D Test passes with no error

💡 Hint

Check if all fixtures used in the test are defined.

The test requests a fixture named 'fix3' which is not defined anywhere. Pytest raises a fixture lookup error indicating 'fix3' is missing.

❓ framework

advanced

Best practice for fixture dependency scope

If fixture B depends on fixture A, and fixture A has scope='module', what is the best scope to assign to fixture B to avoid scope mismatch errors?

A scope='module'

B scope='function'

C scope='session'

D scope='class'

💡 Hint

Fixture scope must be the same or broader than its dependencies.

A fixture cannot have a narrower scope than a fixture it depends on. Since fixture A is 'module' scope, fixture B must be 'module' or broader (like 'session'). 'function' or 'class' are narrower and cause errors.

🧠 Conceptual

expert

Why use fixture dependencies in pytest?

Which of the following is the main advantage of using fixture dependencies (fixtures using other fixtures) in pytest?

A To reduce code duplication by reusing setup logic across multiple fixtures

B To make tests run faster by skipping setup steps

C To avoid writing any teardown code

D To force tests to run in a specific order

💡 Hint

Think about how fixtures can share common setup steps.

Fixture dependencies allow you to build complex setups by reusing simpler fixtures. This reduces code duplication and improves maintainability.

Practice

1. What happens when a pytest fixture uses another fixture as a parameter?

easy

A. pytest runs both fixtures in parallel without passing results

B. pytest ignores the dependent fixture and runs only the main fixture

C. pytest runs the dependent fixture first and passes its result automatically

D. pytest throws a syntax error because fixtures cannot use other fixtures

Solution

1. Step 1: Understand fixture dependency in pytest

   When a fixture uses another fixture as a parameter, pytest recognizes this dependency and runs the dependent fixture first.

2. Step 2: How pytest passes results between fixtures

   pytest automatically passes the result of the dependent fixture to the main fixture as an argument.

3. Final Answer:

   pytest runs the dependent fixture first and passes its result automatically -> Option C

4. Quick Check:

   Fixture dependency means automatic result passing [OK]

Hint: Dependent fixtures run first and pass results automatically [OK]

Common Mistakes:

• Thinking fixtures run independently without passing results
• Believing fixture dependencies cause errors
• Assuming fixtures run in parallel without order

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

easy

A. @pytest.fixture
def fixture_a():
return 5

@pytest.fixture
def fixture_b(fixture_a):
return fixture_a + 3

B. @pytest.fixture
def fixture_a():
return 5

@pytest.fixture
def fixture_b():
fixture_a + 3

C. @pytest.fixture
def fixture_a():
return 5

@pytest.fixture
def fixture_b():
return fixture_a() + 3

D. @pytest.fixture
def fixture_a():
return 5

@pytest.fixture
def fixture_b():
return 3 + 5

Solution

1. Step 1: Check how fixtures receive other fixtures

   Fixtures use other fixtures by naming them as parameters in the function definition.

2. Step 2: Validate the syntax of fixture_b

   @pytest.fixture def fixture_a(): return 5 @pytest.fixture def fixture_b(fixture_a): return fixture_a + 3 correctly defines fixture_b with fixture_a as a parameter, allowing pytest to inject fixture_a's return value.

3. Final Answer:

   @pytest.fixture def fixture_b(fixture_a): return fixture_a + 3 -> Option A

4. Quick Check:

   Fixture as parameter = correct syntax [OK]

Hint: Use fixture names as parameters to depend on them [OK]

Common Mistakes:

• Calling fixture functions directly inside another fixture
• Not passing dependent fixture as parameter
• Trying to use fixture variables without parameters

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

import pytest

@pytest.fixture
def base():
    return 10

@pytest.fixture
def add_five(base):
    return base + 5

def test_sum(add_five):
    assert add_five == 15
    print(add_five)

medium

A. 5

B. 10

C. AssertionError

D. 15

Solution

1. Step 1: Understand fixture dependency and values

   The fixture 'base' returns 10. The fixture 'add_five' uses 'base' and returns 10 + 5 = 15.

2. Step 2: Analyze the test function output

   The test asserts that 'add_five' equals 15, which is true, then prints 15.

3. Final Answer:

   15 -> Option D

4. Quick Check:

   Dependent fixture value = 15 [OK]

Hint: Dependent fixture returns combined value, test prints it [OK]

Common Mistakes:

• Confusing fixture return values
• Expecting base value instead of combined
• Assuming print outputs test result

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

import pytest

@pytest.fixture
def data():
    return [1, 2, 3]

@pytest.fixture
def processed_data():
    data.append(4)
    return data

medium

A. 'data' fixture returns a tuple, but 'processed_data' expects a list

B. 'data' fixture is not passed as a parameter to 'processed_data' fixture

C. 'processed_data' fixture is missing the @pytest.mark decorator

D. 'data' fixture is called inside 'processed_data' without parentheses

Solution

1. Step 1: Check how 'processed_data' accesses 'data'

   'processed_data' tries to use 'data' but does not receive it as a parameter, so 'data' is undefined in its scope.

2. Step 2: Correct way to use fixture dependencies

   To use one fixture inside another, the dependent fixture must be listed as a parameter in the function definition.

3. Final Answer:

   'data' fixture is not passed as a parameter to 'processed_data' fixture -> Option B

4. Quick Check:

   Fixture dependency requires parameter passing [OK]

Hint: Always pass dependent fixtures as parameters [OK]

Common Mistakes:

• Using fixture names without parameters
• Calling fixture functions directly inside another fixture
• Missing @pytest.fixture decorator

5. You want to create a pytest fixture full_config that depends on two other fixtures: base_config returning a dict {'host': 'localhost'} and auth_config returning {'user': 'admin'}. Which code correctly combines these fixtures so full_config returns {'host': 'localhost', 'user': 'admin'}?

hard

A. @pytest.fixture
def base_config():
return {'host': 'localhost'}

@pytest.fixture
def auth_config():
return {'user': 'admin'}

@pytest.fixture
def full_config(base_config, auth_config):
return {**base_config, **auth_config}

B. @pytest.fixture
def base_config():
return {'host': 'localhost'}

@pytest.fixture
def auth_config():
return {'user': 'admin'}

@pytest.fixture
def full_config():
return {**base_config(), **auth_config()}

C. @pytest.fixture
def base_config():
return {'host': 'localhost'}

@pytest.fixture
def auth_config():
return {'user': 'admin'}

@pytest.fixture
def full_config():
return base_config + auth_config

D. @pytest.fixture
def base_config():
return {'host': 'localhost'}

@pytest.fixture
def auth_config():
return {'user': 'admin'}

@pytest.fixture
def full_config(base_config):
return base_config.update(auth_config())

Solution

1. Step 1: Understand fixture dependencies and parameter passing

   To combine two fixtures, the dependent fixture must list both as parameters to receive their return values.

2. Step 2: Combine dictionaries correctly

   Using {**dict1, **dict2} merges two dictionaries into one. @pytest.fixture def base_config(): return {'host': 'localhost'} @pytest.fixture def auth_config(): return {'user': 'admin'} @pytest.fixture def full_config(base_config, auth_config): return {**base_config, **auth_config} correctly does this with both fixtures as parameters.

3. Final Answer:

   @pytest.fixture def full_config(base_config, auth_config): return {**base_config, **auth_config} -> Option A

4. Quick Check:

   Pass fixtures as parameters and merge dicts [OK]

Hint: Pass all fixtures as parameters and merge dicts with ** [OK]

Common Mistakes:

• Calling fixture functions directly instead of passing as parameters
• Trying to add dictionaries with + operator
• Using dict.update() which returns null