Fixture composition in PyTest - Framework Patterns

Framework Mode - Fixture composition

Folder Structure

tests/
├── test_login.py
├── test_shopping_cart.py
├── conftest.py
utilities/
├── helpers.py
├── data_providers.py
configs/
├── config.yaml
├── env_vars.yaml
reports/
├── latest_report.html
logs/
├── test_run.log

Test Framework Layers

• Fixtures Layer: Defined in conftest.py, fixtures provide reusable setup and teardown logic. They can depend on each other to compose complex test states.
• Test Layer: Test files in tests/ use fixtures by declaring them as function parameters. This keeps tests clean and focused on assertions.
• Utilities Layer: Helper functions and data providers support fixtures and tests with reusable code.
• Configuration Layer: YAML or other config files hold environment-specific data like URLs, credentials, and settings.
• Reporting Layer: Test results and logs are saved in reports/ and logs/ folders for review.

Configuration Patterns

• Environment Config: Use YAML files (e.g., config.yaml) to store URLs, timeouts, and environment-specific settings.
• Fixture Parameters: Pass config values into fixtures using pytest_addoption or pytestconfig fixture for flexibility.
• Credentials: Store sensitive data securely outside the repo or use environment variables accessed in fixtures.
• Browser or Service Setup: Compose fixtures to build complex setups, e.g., a db_connection fixture used by a user_setup fixture.

Test Reporting and CI/CD Integration

• Use pytest --junitxml=reports/results.xml to generate XML reports for CI tools.
• Integrate with CI pipelines (GitHub Actions, Jenkins) to run tests on each commit and upload reports.
• Use plugins like pytest-html to create readable HTML reports saved in reports/.
• Log fixture setup and teardown steps to logs/test_run.log for debugging.

Best Practices for Fixture Composition

1. Keep fixtures small and focused: Each fixture should do one thing well, then compose them for complex setups.
2. Use scope wisely: Define fixture scope (function, module, session) to optimize test speed and resource use.
3. Leverage fixture dependencies: Compose fixtures by calling other fixtures as parameters to reuse setup logic.
4. Use autouse sparingly: Only when you want fixtures to run automatically without explicit declaration.
5. Clean up resources: Use yield in fixtures to ensure proper teardown after tests.

Self Check

Where in this framework structure would you add a new fixture that sets up a test user with database access?

Key Result

Compose small, reusable pytest fixtures by declaring dependencies to build complex test setups cleanly.

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