pytest Fixtures Part 2 — Scope & Cleanup

• Use yield in a fixture for setup + teardown in one place.
• Control how often a fixture runs with scope.
• Use built-in fixtures: tmp_path, monkeypatch, capsys.
• Choose the right scope for speed vs isolation.

import pytest

@pytest.fixture
def db():
    con = sqlite3.connect(":memory:")    # SETUP (before the test)
    init_schema(con)
    yield con                            # ← the test runs here, gets 'con'
    con.close()                          # TEARDOWN (after the test)

yield = setup + teardown

@pytest.fixture
def temp_file():
    f = open("scratch.txt", "w")
    yield f                  # test uses f
    f.close()
    os.remove("scratch.txt") # always cleans up

scope — how often does it run?

scope="function"  (default) fresh for EVERY test       → max isolation
scope="class"     once per test class
scope="module"    once per .py file
scope="session"   once for the whole test run            → max speed

@pytest.fixture(scope="session")
def big_dataset():
    return load_expensive_data()   # loaded ONCE for the whole run

Wider scope = faster (built once) but riskier (shared). Use session/module only for read-only or expensive things; keep mutable state at function scope.

Built-in fixture: tmp_path

def test_write_log(tmp_path):
    # tmp_path is a fresh temp directory, auto-deleted after the test
    log = tmp_path / "app.log"
    write_log(log, "hello")
    assert log.read_text() == "hello\n"

No manual temp-file management — pytest creates a unique dir per test and cleans it up.

Built-in fixture: monkeypatch

def test_uses_env(monkeypatch):
    monkeypatch.setenv("API_KEY", "test-key")    # set an env var
    monkeypatch.setattr("mymod.time.time", lambda: 1000)  # patch a function
    assert get_config()["key"] == "test-key"
    # everything is automatically restored after the test

Built-in fixture: capsys

def test_prints_greeting(capsys):
    greet("Aisyah")
    captured = capsys.readouterr()
    assert "Hi Aisyah" in captured.out    # check what was printed

# tests/conftest.py
import pytest, sqlite3

# expensive, read-only reference data → build once per session
@pytest.fixture(scope="session")
def country_codes():
    return load_country_codes()      # pretend this is slow

# the DB must be fresh per test → function scope (default), with teardown
@pytest.fixture
def db():
    con = sqlite3.connect(":memory:")
    init_schema(con)
    yield con
    con.close()

# tests/test_export.py
def test_export_creates_file(db, tmp_path):
    add_sample_rows(db)
    out = tmp_path / "export.csv"
    export_to_csv(db, out)
    assert out.exists()
    assert "Aisyah" in out.read_text()

def test_country_lookup(country_codes):
    assert country_codes["MY"] == "Malaysia"   # uses the session fixture

$ pytest tests/ -v
test_export_creates_file PASSED      # fresh db + temp dir, both cleaned up
test_country_lookup PASSED           # reuses the session-scoped data
2 passed

Read the diff

Two scopes working together: country_codes loads once (session) because it's read-only and slow; db is fresh per test (function) because tests mutate it. tmp_path gives a throwaway directory with zero cleanup code. This is the real-world fixture toolkit — fast where safe, isolated where it matters.

yield splits a fixture into setup (before) and teardown (after, even on failure). scope controls frequency: function (fresh, isolated) up to session (once, fast). Built-ins save work: tmp_path for temp dirs, monkeypatch for env/attrs, capsys for captured output. Keep mutable state function-scoped. Next: parametrize for table-driven tests.