Test fixtures with pytest in Flask - Step-by-Step Execution

Concept Flow - Test fixtures with pytest

Define fixture function

↓

Mark with @pytest.fixture

↓

Test function requests fixture

↓

pytest runs fixture setup

↓

Fixture returns resource

↓

Test uses resource

↓

Test finishes

↓

Fixture teardown (optional)

↓

Test suite continues or ends

This flow shows how pytest fixtures are defined, provided to tests, and optionally cleaned up after tests run.

Execution Sample

Flask

import pytest
from flask import Flask

@pytest.fixture
def app():
    app = Flask(__name__)
    yield app

    # teardown code here

Defines a pytest fixture named 'app' that creates a Flask app instance for tests.

Execution Table

Step	Action	Evaluation	Result
1	pytest finds @pytest.fixture 'app'	Registers fixture	Fixture 'app' ready
2	Test function requests 'app' fixture	pytest calls fixture function	Flask app instance created
3	Fixture yields app instance	Test receives app instance	Test can use Flask app
4	Test runs using app	Test code executes	Test passes or fails
5	Test finishes	Fixture teardown runs after yield	Resources cleaned up
6	Next test or end	Repeat or stop	Test suite continues or ends

💡 All tests using fixture completed; fixture teardown done after each test.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
app	undefined	Flask app instance created	Yielded to test	Teardown executed	None or cleaned

Key Moments - 3 Insights

Why does the fixture function use 'yield' instead of 'return'?

Using 'yield' allows pytest to run teardown code after the test finishes, as shown in step 5 of the execution_table.

How does pytest know to run the fixture before the test?

pytest detects the @pytest.fixture decorator and sees the test requests the fixture by name, triggering the fixture call at step 2.

Can multiple tests share the same fixture instance?

By default, each test gets a fresh fixture instance, ensuring isolation, as the fixture runs setup and teardown around each test (steps 2 to 5).

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3?

A The fixture yields the Flask app instance to the test

B The test finishes and fixture teardown runs

C pytest registers the fixture

D The test requests the fixture

💡 Hint

Check the 'Action' and 'Result' columns at step 3 in the execution_table

At which step does pytest run the fixture teardown code?

A Step 3

B Step 5

C Step 2

D Step 6

💡 Hint

Look for 'Fixture teardown runs after yield' in the execution_table

If a test does not request the fixture, what happens?

A The fixture is still run before the test

B pytest throws an error

C The fixture is not run at all

D The fixture runs after the test

💡 Hint

pytest only runs fixtures that tests explicitly request, as shown in step 2

Concept Snapshot

pytest fixtures provide reusable setup and teardown for tests.
Define with @pytest.fixture decorator.
Use 'yield' to separate setup and teardown.
Tests request fixtures by naming them as parameters.
Fixtures run before each test that requests them.
Teardown runs after test finishes.

Full Transcript

This visual execution trace shows how pytest fixtures work in Flask testing. First, a fixture function is defined and marked with @pytest.fixture. When a test function requests this fixture by name, pytest runs the fixture function, creating the Flask app instance. The fixture yields this instance to the test, allowing the test to use it. After the test finishes, pytest runs any teardown code after the yield. This process repeats for each test that requests the fixture, ensuring clean setup and cleanup. Key points include using yield for teardown, pytest detecting fixture usage, and fixture isolation per test.

Practice

1. What is the main purpose of a fixture in pytest when testing a Flask app?

easy

A. To write the main application logic

B. To handle user input in the Flask app

C. To set up and tear down resources needed for tests automatically

D. To deploy the Flask app to a server

Solution

1. Step 1: Understand what fixtures do in pytest

   Fixtures prepare the environment for tests by setting up resources before tests run and cleaning them after.

2. Step 2: Identify the role of fixtures in Flask testing

   Fixtures help create test clients, databases, or other resources needed for Flask tests automatically.

3. Final Answer:

   To set up and tear down resources needed for tests automatically -> Option C

4. Quick Check:

   Fixtures = setup and cleanup [OK]

Hint: Fixtures prepare test resources automatically [OK]

Common Mistakes:

• Confusing fixtures with application code
• Thinking fixtures handle user input
• Assuming fixtures deploy the app

2. Which of the following is the correct way to define a pytest fixture for a Flask test client?

easy

A. @pytest.fixture
def client():
app = Flask(__name__)
yield app.test_client()

B. @pytest.fixture
def client():
app = Flask(__name__)
app.test_client()

C. def client():
app = Flask(__name__)
yield app.test_client()

D. @pytest.fixture
def client():
app = Flask(__name__)
return app

Solution

1. Step 1: Check the use of @pytest.fixture decorator

   The @pytest.fixture decorator is required to mark a fixture. One option lacks it.

2. Step 2: Identify correct use of yield for setup and teardown

   @pytest.fixture def client(): app = Flask(__name__) yield app.test_client() uses yield to provide the test client and allows cleanup after tests, which is best practice.

3. Final Answer:

   @pytest.fixture\ndef client():\n app = Flask(__name__)\n yield app.test_client() -> Option A

4. Quick Check:

   Use @pytest.fixture and yield for fixtures [OK]

Hint: Use @pytest.fixture and yield to define fixtures [OK]

Common Mistakes:

• Omitting @pytest.fixture decorator
• Returning instead of yielding
• Not yielding or returning the test client

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

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

def test_example(sample):
    print(f'Test received: {sample}')

medium

A. Setup\nTest received: data\nTeardown

B. Test received: data\nSetup\nTeardown

C. Setup\nTeardown\nTest received: data

D. Test received: data

Solution

1. Step 1: Understand fixture execution order

   Before the test runs, the fixture prints 'Setup', then yields 'data' to the test.

2. Step 2: Analyze test function output and fixture teardown

   The test prints 'Test received: data'. After test finishes, fixture resumes and prints 'Teardown'.

3. Final Answer:

   Setup\nTest received: data\nTeardown -> Option A

4. Quick Check:

   Fixture setup -> test -> fixture teardown [OK]

Hint: Fixture prints before yield, teardown prints after [OK]

Common Mistakes:

• Assuming teardown runs before test
• Ignoring yield pauses fixture
• Thinking test runs before setup

4. Identify the error in this pytest fixture code for a Flask app:

@pytest.fixture
def client():
    app = Flask(__name__)
    client = app.test_client()
    return client
    print('Cleanup done')

medium

A. Fixture must use 'yield' instead of 'return' always

B. Missing '@pytest.fixture' decorator

C. 'app.test_client()' is not a valid method

D. The 'print' statement after 'return' will never execute

Solution

1. Step 1: Check code after return statement

   Code after 'return' is unreachable, so 'print' will never run.

2. Step 2: Confirm other parts are correct

   The decorator is present, 'app.test_client()' is valid, and 'return' is allowed but limits cleanup.

3. Final Answer:

   The 'print' statement after 'return' will never execute -> Option D

4. Quick Check:

   Code after return is unreachable [OK]

Hint: Code after return is ignored; use yield for cleanup [OK]

Common Mistakes:

• Thinking print runs after return
• Assuming return disallows fixture
• Confusing method names

5. You want to create a fixture that sets up a temporary database for Flask tests and ensures it is cleaned up after all tests in the module run. Which fixture scope and structure is best?

hard

A. @pytest.fixture(scope='function')
def temp_db():
db = setup_temp_db()
yield db
teardown_temp_db(db)

B. @pytest.fixture(scope='module')
def temp_db():
db = setup_temp_db()
yield db
teardown_temp_db(db)

C. @pytest.fixture(scope='session')
def temp_db():
db = setup_temp_db()
return db

D. @pytest.fixture(scope='module')
def temp_db():
db = setup_temp_db()
return db
teardown_temp_db(db)

Solution

1. Step 1: Choose fixture scope for module-wide setup

   Scope 'module' runs once per module, ideal for shared DB setup across tests.

2. Step 2: Use yield to allow teardown after all tests

   Yield pauses fixture to run tests, then runs teardown after all tests complete.

3. Final Answer:

   @pytest.fixture(scope='module')\ndef temp_db():\n db = setup_temp_db()\n yield db\n teardown_temp_db(db) -> Option B

4. Quick Check:

   Module scope + yield for setup and cleanup [OK]

Hint: Use scope='module' and yield for setup/cleanup [OK]

Common Mistakes:

• Using function scope causes repeated setup
• Returning without yield skips cleanup
• Placing cleanup code after return