Fixture teardown (yield) in PyTest - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of using yield in a pytest fixture?

Using yield in a pytest fixture allows you to separate setup and teardown code. The code before yield runs before the test, and the code after yield runs after the test to clean up.

beginner

How does pytest know when to run the teardown code in a fixture using yield?

Pytest runs the code after yield automatically after the test that uses the fixture finishes, even if the test fails or raises an error.

beginner

Write a simple pytest fixture using yield that prints 'Setup' before the test and 'Teardown' after the test.

import pytest

@pytest.fixture
def my_fixture():
    print('Setup')
    yield
    print('Teardown')

intermediate

Why is using yield in fixtures better than using request.addfinalizer() for teardown?

Using yield keeps setup and teardown code together in one place, making the fixture easier to read and maintain. It also works naturally with Python's generator syntax.

intermediate

Can the teardown code after yield in a pytest fixture modify the value returned to the test?

No. The value yielded is sent to the test function before the teardown code runs. The teardown code runs after the test and cannot change the yielded value.

What happens to the code after yield in a pytest fixture?

A It runs only if the test passes

B It runs before the test starts

C It runs after the test finishes

D It never runs

The code after yield runs after the test finishes, regardless of test outcome.

Which keyword is used in pytest fixtures to separate setup and teardown code?

A return

B break

C continue

D yield

yield separates setup (before) and teardown (after) code in pytest fixtures.

If a pytest fixture uses yield, when is the setup code executed?

A Before the test

B Never

C Only if the test fails

D After the test

Setup code runs before the test, before the yield statement.

What is a benefit of using yield in pytest fixtures?

A It allows multiple tests to run in parallel

B It combines setup and teardown in one function

C It skips the test automatically

D It disables fixture caching

yield lets you write setup and teardown code together in one fixture function.

Can teardown code after yield modify the fixture value used by the test?

A No, teardown runs after test uses the value

B Yes, anytime

C Only if the test passes

D Only if the test fails

Teardown code runs after the test uses the yielded value, so it cannot change it.

Explain how to use yield in a pytest fixture to handle setup and teardown.

Think of yield as a pause between setup and cleanup.

Describe why using yield in fixtures is preferred over request.addfinalizer().

Focus on code clarity and maintenance.

Practice

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

easy

A. To separate setup and teardown code in the fixture

B. To skip the test execution

C. To run the test multiple times

D. To mark the test as expected to fail

Solution

1. Step 1: Understand fixture setup and teardown

   In pytest, setup code prepares resources before a test, and teardown code cleans up after the test.

2. Step 2: Role of yield in fixture

   The yield statement splits the fixture into two parts: code before yield runs before the test (setup), and code after yield runs after the test (teardown).

3. Final Answer:

   To separate setup and teardown code in the fixture -> Option A

4. Quick Check:

   Yield separates setup and teardown [OK]

Hint: Remember: yield splits setup and cleanup in fixtures [OK]

Common Mistakes:

• Thinking yield skips tests
• Confusing yield with test repetition
• Using yield to mark test outcomes

2. Which of the following is the correct syntax for a pytest fixture using yield for teardown?

easy

A. def my_fixture():
setup()
yield
teardown()

B. def my_fixture():
yield
setup()
teardown()

C. def my_fixture():
setup()
teardown()
yield

D. def my_fixture():
teardown()
yield
setup()

Solution

1. Step 1: Identify setup and teardown order

   Setup code must run before yield, teardown code after yield.

2. Step 2: Check each option's order

   def my_fixture(): setup() yield teardown() correctly places setup before yield and teardown after. Others have incorrect order.

3. Final Answer:

   def my_fixture(): setup() yield teardown() -> Option A

4. Quick Check:

   Setup before yield, teardown after [OK]

Hint: Setup before yield, teardown after yield in fixture [OK]

Common Mistakes:

• Placing teardown before yield
• Calling setup after yield
• Yield placed at the end after teardown

3. What will be the output when running this pytest fixture and test?

import pytest

@pytest.fixture
def resource():
    print('Setup')
    yield
    print('Teardown')

def test_example(resource):
    print('Test running')

medium

A. Test running\nSetup\nTeardown

B. Setup\nTeardown\nTest running

C. Setup\nTest running\nTeardown

D. Teardown\nSetup\nTest running

Solution

1. Step 1: Trace fixture execution order

   Fixture prints 'Setup' before yield, then test runs printing 'Test running', then fixture prints 'Teardown' after yield.

2. Step 2: Combine output sequence

   Output order is 'Setup', 'Test running', then 'Teardown'.

3. Final Answer:

   Setup\nTest running\nTeardown -> Option C

4. Quick Check:

   Setup -> Test -> Teardown order [OK]

Hint: Yield splits setup (before) and teardown (after) print order [OK]

Common Mistakes:

• Assuming teardown runs before test
• Mixing print order
• Ignoring yield effect on execution flow

4. Identify the error in this pytest fixture using yield:

@pytest.fixture
def faulty_fixture():
    yield
    setup()
    teardown()

medium

A. Teardown code must be before yield

B. Yield cannot be used in fixtures

C. Fixture must return a value instead of yield

D. Setup code is after yield, so it runs after the test instead of before

Solution

1. Step 1: Analyze code order around yield

   Setup code should run before yield to prepare resources; here it is after yield, so it runs after the test.

2. Step 2: Understand consequences

   This means setup runs too late, breaking test assumptions. Teardown after setup is also misplaced.

3. Final Answer:

   Setup code is after yield, so it runs after the test instead of before -> Option D

4. Quick Check:

   Setup must be before yield [OK]

Hint: Setup must be before yield, teardown after [OK]

Common Mistakes:

• Placing setup after yield
• Thinking yield is not allowed
• Confusing teardown position

5. You want to create a pytest fixture that opens a file before a test and closes it after. Which fixture code correctly uses yield for this purpose?

hard

A. def file_fixture():
yield open('data.txt')
f.close()

B. def file_fixture():
f = open('data.txt')
yield f
f.close()

C. def file_fixture():
f = open('data.txt')
f.close()
yield f

D. def file_fixture():
f = open('data.txt')
yield
f.close()

Solution

1. Step 1: Open file before yield and yield file object

   def file_fixture(): f = open('data.txt') yield f f.close() opens the file, yields the file object to the test, allowing test to use it.

2. Step 2: Close file after yield

   After test finishes, code after yield closes the file, ensuring cleanup.

3. Final Answer:

   def file_fixture(): f = open('data.txt') yield f f.close() -> Option B

4. Quick Check:

   Open before yield, yield resource, close after yield [OK]

Hint: Yield resource to test, cleanup after yield [OK]

Common Mistakes:

• Closing file before yield
• Yielding without resource variable
• Not closing file after test