Context manager fixtures in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a pytest fixture using context manager

What will be the output when running this pytest test with the given fixture?

PyTest

import pytest

class Resource:
    def __init__(self):
        self.active = False
    def __enter__(self):
        self.active = True
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.active = False

@pytest.fixture
def resource():
    with Resource() as r:
        yield r

def test_resource_active(resource):
    assert resource.active

A Test passes because resource.active is True inside the test

B Test fails because resource.active is False inside the test

C Test fails due to fixture not yielding any value

D Test raises an exception because Resource does not support context manager

💡 Hint

Remember that the fixture yields the resource while it is active inside the context manager.

The fixture uses a context manager to create and yield a Resource instance. Inside the with block, resource.active is set to True. The test runs while the resource is active, so the assertion passes.

❓ assertion

intermediate

Correct assertion to check resource active state in context manager fixture

Given this fixture and test, which assertion correctly verifies the state of the resource during the test?

PyTest

import pytest

class Resource:
    def __init__(self):
        self.active = False
    def __enter__(self):
        self.active = True
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.active = False

@pytest.fixture
def resource():
    with Resource() as r:
        yield r

def test_resource_cleanup(resource):
    pass  # Which assertion goes here?

A assert hasattr(resource, 'active')

B assert resource.active is False

C assert resource.active is True

D assert resource is None

💡 Hint

The test runs while the resource is active inside the fixture yield.

The test runs while the resource is inside the with block, so resource.active is True. Cleanup happens after the test finishes.

🔧 Debug

advanced

Common misconception: Why does this context manager fixture seem to cause a test to hang?

Consider this fixture and test. Some developers think the test never finishes. What is the most likely reason for this misconception?

PyTest

import pytest

class Resource:
    def __enter__(self):
        print('Entering')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('Exiting')

@pytest.fixture
def resource():
    with Resource() as r:
        yield r
        print('After yield')

def test_hang(resource):
    assert True

A The fixture never exits the with block because __exit__ is missing a return statement

B The fixture hangs because the yield is inside the with block and the with block never ends

C The fixture hangs because __exit__ does not return True to suppress exceptions

D The fixture hangs because the test does not consume the fixture properly

💡 Hint

Think about when the with block ends relative to the yield.

The misconception (option B) comes from thinking that yield inside with prevents the with block from exiting. In reality, yield suspends the fixture generator, runs the test, then resumes after yield (prints 'After yield'), and finally exits the with calling __exit__. No hang occurs.

❓ locator

advanced

Best locator strategy for a pytest fixture using context manager

You want to locate the line in this fixture where the resource is yielded to the test. Which line number is the best locator?

PyTest

1| import pytest
2| 
3| class Resource:
4|     def __enter__(self):
5|         print('Enter')
6|         return self
7|     def __exit__(self, exc_type, exc_val, exc_tb):
8|         print('Exit')
9| 
10| @pytest.fixture
11| def resource():
12|     with Resource() as r:
13|         yield r
14|         print('Cleanup')

A Line 13: yield r

B Line 14: print('Cleanup')

C Line 11: def resource():

D Line 12: with Resource() as r:

💡 Hint

The yield statement is where the fixture hands control to the test.

The yield statement on line 13 is where the fixture pauses and provides the resource to the test function. This is the best locator to identify the point where the test receives the fixture.

❓ framework

expert

How does pytest handle teardown in context manager fixtures?

In pytest, when a fixture uses a context manager with yield, when exactly does pytest execute the code after the yield?

A Pytest runs the code after yield only if the test fails

B Before the test function starts, pytest runs the code after yield to prepare the environment

C Pytest never runs the code after yield in context manager fixtures

D Immediately after the test function finishes, pytest resumes the fixture and runs the code after yield for teardown

💡 Hint

Think about how yield pauses and resumes execution.

Pytest runs the fixture code up to the yield to set up the resource. It then runs the test. After the test finishes (pass or fail), pytest resumes the fixture and runs the code after the yield to clean up.

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