Context manager fixtures in PyTest - Test Execution Trace

Test Overview

This test uses a pytest fixture implemented as a context manager to set up and tear down a resource. It verifies that the resource is correctly initialized and cleaned up after the test.

Test Code - pytest

PyTest

import pytest

class Resource:
    def __init__(self):
        self.active = False
    def start(self):
        self.active = True
    def stop(self):
        self.active = False

@pytest.fixture
def resource():
    res = Resource()
    res.start()
    yield res
    res.stop()

def test_resource_active(resource):
    assert resource.active is True

Execution Trace - 8 Steps

Step	Action	System State	Assertion	Result
1	pytest starts test execution	pytest test runner initialized	—	PASS
2	pytest calls the 'resource' fixture before the test	Resource instance created with active = False	—	PASS
3	Resource.start() is called inside fixture, setting active = True	Resource active state is True	—	PASS
4	Fixture yields the resource instance to the test	Test receives resource with active = True	—	PASS
5	Test asserts resource.active is True	resource.active is True	assert resource.active is True	PASS
6	Test completes, pytest resumes fixture teardown	Resource active state still True	—	PASS
7	Resource.stop() is called in fixture teardown, setting active = False	Resource active state is False	—	PASS
8	pytest finishes test execution	All resources cleaned up	—	PASS

Failure Scenario

Failing Condition: Resource.start() is not called, so resource.active remains False

Execution Trace Quiz - 3 Questions

What does the fixture do before yielding the resource to the test?

A Calls res.stop() to deactivate the resource

B Does nothing before yielding

C Calls res.start() to activate the resource

D Raises an exception

Key Result

Using context manager style fixtures with yield in pytest helps ensure setup and cleanup happen reliably around tests.

Practice

1. What is the main purpose of using a context manager fixture in pytest?

easy

A. To speed up test execution by skipping setup

B. To automatically handle setup and cleanup around a test

C. To replace assertions with print statements

D. To run tests in parallel automatically

Solution

1. Step 1: Understand context manager role

   Context managers in pytest use yield to run setup code before the test and cleanup code after the test finishes.

2. Step 2: Identify purpose in testing

   This automatic setup and cleanup makes tests safer and cleaner by managing resources like files or connections.

3. Final Answer:

   To automatically handle setup and cleanup around a test -> Option B

4. Quick Check:

   Context manager fixture = automatic setup and cleanup [OK]

Hint: Context managers wrap setup and cleanup automatically [OK]

Common Mistakes:

• Thinking context managers speed up tests by skipping setup
• Confusing context managers with parallel test execution
• Using print statements instead of assertions

2. Which of the following is the correct way to define a context manager fixture in pytest?

easy

A. @pytest.fixture
def resource():
setup()
yield
cleanup()

B. @pytest.fixture
def resource():
yield
setup()
cleanup()

C. @pytest.fixture
def resource():
setup()
cleanup()
yield

D. @pytest.fixture
def resource():
cleanup()
yield
setup()

Solution

1. Step 1: Recall context manager fixture syntax

   In pytest, the code before yield runs as setup, and the code after yield runs as cleanup.

2. Step 2: Check each option

   @pytest.fixture def resource(): setup() yield cleanup() correctly places setup() before yield and cleanup() after. Others have wrong order.

3. Final Answer:

   @pytest.fixture def resource(): setup() yield cleanup() -> Option A

4. Quick Check:

   Setup before yield, cleanup after yield [OK]

Hint: Setup code goes before yield, cleanup after yield [OK]

Common Mistakes:

• Placing cleanup before yield
• Calling setup after yield
• Putting yield at the end after cleanup

3. Given this fixture and test, what will be printed when running pytest?

@pytest.fixture
def file_resource():
    print('Setup file')
    yield
    print('Cleanup file')

def test_example(file_resource):
    print('Running test')

medium

A. Running test\nSetup file\nCleanup file

B. Cleanup file\nSetup file\nRunning test

C. Setup file\nCleanup file\nRunning test

D. Setup file\nRunning test\nCleanup file

Solution

1. Step 1: Understand fixture execution order

   Before the test runs, the fixture prints 'Setup file'. Then the test prints 'Running test'. After the test finishes, the fixture prints 'Cleanup file'.

2. Step 2: Match output sequence

   The output order is: 'Setup file', 'Running test', 'Cleanup file'.

3. Final Answer:

   Setup file\nRunning test\nCleanup file -> Option D

4. Quick Check:

   Setup -> Test -> Cleanup order [OK]

Hint: Fixture setup prints before test, cleanup prints after [OK]

Common Mistakes:

• Assuming cleanup runs before test
• Thinking test runs before setup
• Mixing order of prints

4. What is wrong with this context manager fixture?

@pytest.fixture
def db_connection():
    conn = connect_db()
    yield conn
    conn.close()

medium

A. Nothing is wrong; it is correct

B. The fixture should not yield a value

C. The cleanup code after yield will never run

D. The connection should be closed before yield

Solution

1. Step 1: Analyze fixture structure

   The fixture creates a connection, yields it for the test, then closes it after the test finishes.

2. Step 2: Confirm cleanup runs after yield

   Code after yield runs as cleanup, so conn.close() will run properly after the test.

3. Final Answer:

   Nothing is wrong; it is correct -> Option A

4. Quick Check:

   Yield passes resource, cleanup runs after yield [OK]

Hint: Cleanup code after yield always runs after test [OK]

Common Mistakes:

• Thinking cleanup code never runs
• Closing connection before yield
• Not yielding the resource

5. You want to write a context manager fixture that creates a temporary file, yields its path, and deletes the file after the test. Which code correctly implements this?

hard

A. @pytest.fixture
def temp_file():
path = '/tmp/testfile.txt'
os.remove(path)
yield path

B. @pytest.fixture
def temp_file():
path = '/tmp/testfile.txt'
yield path
open(path, 'w').close()
os.remove(path)

C. @pytest.fixture
def temp_file():
path = '/tmp/testfile.txt'
open(path, 'w').close()
yield path
os.remove(path)

D. @pytest.fixture
def temp_file():
path = '/tmp/testfile.txt'
os.remove(path)
yield
open(path, 'w').close()

Solution

1. Step 1: Setup temporary file before yield

   The file must be created before yielding its path so the test can use it.

2. Step 2: Cleanup file after yield

   After the test, the file should be deleted to clean up resources.

3. Final Answer:

   @pytest.fixture def temp_file(): path = '/tmp/testfile.txt' open(path, 'w').close() yield path os.remove(path) -> Option C

4. Quick Check:

   Create file before yield, delete after yield [OK]

Hint: Create resource before yield, clean up after yield [OK]

Common Mistakes:

• Deleting file before test runs
• Creating file after yield
• Not yielding the file path