Shared expensive resource patterns in PyTest - Framework Patterns

Framework Mode - Shared expensive resource patterns

Folder Structure

tests/
├── test_feature_a.py
├── test_feature_b.py
├── conftest.py          # Shared fixtures and resource setup
utilities/
├── db_helper.py         # Database connection helpers
├── api_client.py        # API client utilities
configs/
├── config.yaml          # Environment and credentials
reports/
├── latest_report.html
pytest.ini               # Pytest configuration file

Test Framework Layers

• Fixtures Layer: Defined in conftest.py to manage shared expensive resources like database connections or web servers.
• Test Layer: Test files in tests/ use fixtures to access shared resources without recreating them.
• Utilities Layer: Helper modules in utilities/ provide reusable functions for resource management.
• Configuration Layer: configs/config.yaml holds environment-specific settings and credentials.

Configuration Patterns

• Use pytest.ini to set default options and markers.
• Store environment variables and credentials securely in configs/config.yaml or environment variables.
• Use pytest command line options or environment variables to select environments (e.g., dev, staging, prod).
• Define fixtures with appropriate scopes (session, module, function) to control resource lifetime and sharing.

Test Reporting and CI/CD Integration

• Use pytest-html plugin to generate HTML reports saved in reports/.
• Integrate with CI/CD pipelines (GitHub Actions, Jenkins, GitLab CI) to run tests on each commit or pull request.
• Configure CI to cache expensive resources or reuse containers to speed up tests.
• Fail fast on critical resource setup failures to save time.

Best Practices for Shared Expensive Resource Patterns

1. Use session scoped fixtures for resources that are costly to create and can be shared across all tests in a run.
2. Clean up resources properly using finalizers or yield fixtures to avoid side effects between tests.
3. Isolate tests logically by using module or function scoped fixtures when resource sharing is not safe.
4. Parameterize fixtures to support different configurations without duplicating resource setup code.
5. Keep fixtures simple and reusable to improve maintainability and readability.

Self Check

Where in this framework structure would you add a new fixture to share a web server instance across all tests?

Key Result

Use pytest session-scoped fixtures in conftest.py to share expensive resources efficiently across tests.

Practice

1. What is the main benefit of using a pytest fixture with a scope='module' when dealing with expensive resources?

easy

A. The fixture runs only once per test session, regardless of module.

B. The fixture setup runs once per module, reducing repeated expensive setup.

C. The fixture runs before every test function, ensuring fresh resources.

D. The fixture runs after each test to clean up resources immediately.

Solution

1. Step 1: Understand fixture scopes in pytest

   Fixtures with scope='module' run once per module, not per test function.

2. Step 2: Relate scope to expensive resource usage

   Running setup once per module saves time by avoiding repeated expensive setups for each test.

3. Final Answer:

   The fixture setup runs once per module, reducing repeated expensive setup. -> Option B

4. Quick Check:

   Module scope = setup once per module [OK]

Hint: Module scope runs setup once per module, saving time [OK]

Common Mistakes:

• Confusing module scope with function scope
• Thinking setup runs before every test
• Assuming cleanup runs immediately after each test

2. Which of the following is the correct syntax to define a pytest fixture that sets up a database connection once per test session?

easy

A. @pytest.fixture(scope='session')\ndef db_conn():\n pass

B. @pytest.fixture(scope='class')\ndef db_conn():\n pass

C. @pytest.fixture(scope='module')\ndef db_conn():\n pass

D. @pytest.fixture(scope='function')\ndef db_conn():\n pass

Solution

1. Step 1: Identify scope for once per test session

   The session scope runs the fixture setup once for the entire test session.

2. Step 2: Match syntax with correct scope

   @pytest.fixture(scope='session')\ndef db_conn():\n pass uses @pytest.fixture(scope='session'), which is correct for this purpose.

3. Final Answer:

   @pytest.fixture(scope='session')\ndef db_conn():\n pass -> Option A

4. Quick Check:

   Session scope = setup once per session [OK]

Hint: Session scope means setup runs once per entire test run [OK]

Common Mistakes:

• Using function scope for expensive shared resources
• Confusing module and session scopes
• Forgetting to specify scope in fixture decorator

3. Given the following pytest fixture and test code, what will be the output when running the tests?

@pytest.fixture(scope='module')
def resource():
    print('Setup resource')
    yield
    print('Cleanup resource')

def test_one(resource):
    print('Test one running')

def test_two(resource):
    print('Test two running')

medium

A. Setup resource\nTest one running\nTest two running\nCleanup resource

B. Setup resource\nTest one running\nCleanup resource\nSetup resource\nTest two running\nCleanup resource

C. Test one running\nTest two running

D. Setup resource\nCleanup resource\nTest one running\nTest two running

Solution

1. Step 1: Understand module scope fixture behavior

   With scope='module', setup runs once before any tests in the module, and cleanup runs after all tests finish.

2. Step 2: Trace the print statements during test execution

   First, 'Setup resource' prints. Then 'Test one running' and 'Test two running' print during tests. Finally, 'Cleanup resource' prints after all tests.

3. Final Answer:

   Setup resource\nTest one running\nTest two running\nCleanup resource -> Option A

4. Quick Check:

   Module scope = setup once before all tests, cleanup after all [OK]

Hint: Module scope runs setup once before all tests, cleanup after all [OK]

Common Mistakes:

• Expecting cleanup after each test
• Thinking setup runs before each test
• Ignoring yield behavior in fixture

4. Identify the error in this pytest fixture code that aims to share a resource across tests in a class:

@pytest.fixture(scope='class')
def setup_resource():
    resource = open('file.txt')
    yield resource
    resource.close()

def test_example(setup_resource):
    assert setup_resource.readable()

medium

A. The fixture should use scope='module' instead of 'class'.

B. The fixture function name does not match the test parameter name.

C. The fixture does not handle exceptions during resource setup.

D. The fixture is missing the @pytest.mark.usefixtures decorator.

Solution

1. Step 1: Review fixture resource setup and cleanup

   The fixture opens a file and yields it, then closes it after tests.

2. Step 2: Check for error handling in setup

   If opening the file fails, no exception handling is present, which can cause test failures or resource leaks.

3. Final Answer:

   The fixture does not handle exceptions during resource setup. -> Option C

4. Quick Check:

   Missing exception handling in fixture setup = problem [OK]

Hint: Always handle exceptions in fixture setup to avoid leaks [OK]

Common Mistakes:

• Confusing fixture scope requirements
• Thinking @pytest.mark.usefixtures is mandatory
• Assuming fixture name mismatch causes error

5. You want to share a database connection across multiple test classes but ensure it resets after all tests finish. Which pytest fixture pattern correctly achieves this?

hard

A. @pytest.fixture(scope='function')\ndef db_conn():\n conn = connect_db()\n yield conn\n conn.reset()\n conn.close()

B. @pytest.fixture(scope='class')\ndef db_conn():\n conn = connect_db()\n yield conn\n conn.close()

C. @pytest.fixture(scope='module')\ndef db_conn():\n conn = connect_db()\n yield conn\n conn.reset()

D. @pytest.fixture(scope='session')\ndef db_conn():\n conn = connect_db()\n yield conn\n conn.reset()\n conn.close()

Solution

1. Step 1: Determine scope for sharing across multiple test classes

   Sharing across classes requires at least session scope to cover all tests.

2. Step 2: Ensure resource resets after all tests finish

   Using yield allows cleanup code after tests; calling conn.reset() before conn.close() resets the connection properly.

3. Final Answer:

   @pytest.fixture(scope='session')\ndef db_conn():\n conn = connect_db()\n yield conn\n conn.reset()\n conn.close() -> Option D

4. Quick Check:

   Session scope + yield cleanup with reset = correct pattern [OK]

Hint: Use session scope and yield cleanup to reset shared resource [OK]

Common Mistakes:

• Using too narrow scope like function or class
• Forgetting to reset resource before closing
• Not using yield to separate setup and cleanup