Python Mocking and Test Fixtures

A fixture is a function decorated with @pytest.fixture. A test requests it by naming it as a parameter, and pytest calls the fixture and passes in the result:

@pytest.fixture
def timetable():
    return {"East Pier": ["09:00", "11:00"], "West Quay": ["10:30"]}

def test_east_pier_has_two_sailings(timetable):
    assert len(timetable["East Pier"]) == 2

By default a fixture runs once per test, so each test gets a fresh dictionary and can modify it without affecting others. Fixtures can use other fixtures, and code after a yield runs as clean-up:

@pytest.fixture
def log_file(tmp_path):
    path = tmp_path / "sailings.log"
    yield path
    # clean-up would go here; tmp_path is removed by pytest anyway

Shared fixtures go in a file called conftest.py, where pytest finds them automatically for every test in that folder and below.

scope= controls how often a fixture is created:

Wider scopes save time for expensive set-up, such as starting a test database or loading a large reference file. But a shared object is shared state: if one test changes a module-scoped dictionary, the next test sees the change, and tests start passing or failing depending on their order. Use wide scopes only for things that are read-only or expensive and safely reset between tests.

pytest provides useful built-in fixtures: tmp_path (a fresh temporary folder as a Path), monkeypatch (temporarily set attributes, environment variables and dictionary items, undone after the test), capsys (capture printed output) and caplog (capture log records).

unittest.mock.patch replaces a name with a mock for the duration of a test. The crucial rule: patch the name where the code under test looks it up, which is not necessarily where it was defined.

# timetable.py
from weather import get_wind          # timetable now has its own name get_wind

def can_sail(pier):
    return get_wind(pier) < 30

# test_timetable.py
from unittest.mock import patch
import timetable

def test_calm_day():
    with patch("timetable.get_wind", return_value=12):   # where it's used
        assert timetable.can_sail("East Pier")

Patching "weather.get_wind" here would have no effect, because from weather import get_wind copied the reference into timetable when it was imported; the code under test would still call the real function and make a real network request. If timetable.py instead did import weather and called weather.get_wind(...), you'd patch "weather.get_wind". monkeypatch.setattr(timetable, "get_wind", fake) follows the same rule.

A test double only needs to reproduce the part of the dependency's contract the code relies on. Mock objects are configured with:

• return_value: what calling the mock returns.
• side_effect: an exception to raise, or a list of values to return on successive calls, or a function to call.
• assertions such as assert_called_once_with(...) and call_count to check how the code used the dependency.

from unittest.mock import Mock
get_wind = Mock(side_effect=TimeoutError("weather service timed out"))

Make doubles fail as well as succeed. A mock that always returns calm weather never exercises your timeout handling, which is exactly the code most likely to be broken. autospec=True (or create_autospec) makes a mock reject calls that don't match the real function's signature, so a test can't keep passing after the real API changes.

Don't over-mock: if a test mocks everything, it only proves the code calls its mocks in a particular order. Mock the slow and unpredictable boundaries, such as network, time, randomness and third-party services, and test real logic for real.

Task: use fixtures for fresh timetable state and test successful and failed weather lookups with controlled doubles.

import pytest
from unittest.mock import Mock

def next_sailing(timetable, pier, get_wind):
    if get_wind(pier) >= 30:
        return None
    return timetable[pier][0]

@pytest.fixture
def timetable():
    return {"East Pier": ["09:00", "11:00"]}

def test_calm_returns_first_sailing(timetable):
    assert next_sailing(timetable, "East Pier", Mock(return_value=10)) == "09:00"

def test_storm_cancels(timetable):
    assert next_sailing(timetable, "East Pier", Mock(return_value=35)) is None

def test_timeout_propagates(timetable):
    with pytest.raises(TimeoutError):
        next_sailing(timetable, "East Pier", Mock(side_effect=TimeoutError))

All three tests pass, and each receives its own timetable. For the worked check, a dependency should usually be patched where the tested code looks it up, the module namespace that holds the name the code calls.

The documentation covers unittest.mock, including the section where to patch, and pytest's fixtures guide. Continue with PEP 8 style and revisit web APIs. Practise with the Python exercises and Python quiz.