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.