Quality

What we're doing: Run coverage against a module with an untested branch and see exactly which line it flags as missing.

# calc.py
def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ValueError("cannot divide by zero")
    return a / b

# test_calc.py
from calc import add, divide
import pytest

def test_add():
    assert add(2, 3) == 5

def test_divide_by_zero_raises():
    with pytest.raises(ValueError, match="cannot divide by zero"):
        divide(1, 0)

7

This return line is never reached — every test either adds, or divides by zero and hits the raise on the line above.

Name      Stmts   Miss  Cover   Missing
---------------------------------------
calc.py       6      1    83%   8
---------------------------------------
TOTAL         6      1    83%

Why this works: Coverage counts calc.py at 6 executable statements; 5 ran, 1 (the successful division's return a / b) never did, because no test calls divide with a nonzero denominator. --cov-report=term-missing names the exact line so it is easy to find and fix.

What we're doing: Show a test suite where module-level shared state makes one test's result depend on whether another test ran first — a real isolation failure.

shared_cart = []   # module-level state -- BAD: shared across tests

def test_add_item_to_cart():
    shared_cart.append("widget")
    assert len(shared_cart) == 1

def test_cart_starts_empty():
    # depends entirely on whether test_add_item_to_cart already ran
    assert len(shared_cart) == 0

1

A module-level list is shared by every test in the file — nothing resets it between tests.

9

This assertion's outcome depends on test order, not on anything test_cart_starts_empty itself does — that is the isolation failure.

test_add_item_to_cart PASSED
test_cart_starts_empty FAILED
E       assert 1 == 0

Why this works: shared_cart is created once when the module loads and never reset — test_add_item_to_cart's side effect leaks into test_cart_starts_empty. Running test_cart_starts_empty ALONE would pass; running the full file fails, which is the exact symptom of a real isolation bug.

What we're doing: Show a fixture pattern that isolates database writes with a rollback, keeping every test's changes invisible to every other test.

import pytest

class FakeSession:
    """Stands in for a real DB session -- rollback just clears in-memory state."""
    def __init__(self):
        self._rows = []

    def add(self, row):
        self._rows.append(row)

    def rollback(self):
        self._rows.clear()   # simulates the real transaction rollback


@pytest.fixture
def db_session():
    session = FakeSession()
    yield session
    session.rollback()   # runs after the test -- every write disappears


def test_insert_visible_within_test(db_session):
    db_session.add({"id": 1, "name": "widget"})
    assert len(db_session._rows) == 1

3

This fake stands in for a real ORM session so the pattern can be demonstrated without a real database connection.

15

The fixture itself calls rollback() AFTER the test finishes (after yield) — this is where isolation actually happens, not inside the test.

22

The test only sees the write it made — the next test gets a brand new FakeSession, with the previous rollback already applied.

1 passed

Why this works: The pattern matters more than this specific fake: a real db_session fixture wraps each test in a transaction that never commits, so no test's writes are ever visible to the next one — the same guarantee this simplified example demonstrates directly.

What we're doing: Test both that an error is correctly raised, and that a mocked dependency failing does not crash the calling code.

import pytest
from unittest.mock import Mock

def validate_amount(amount):
    if amount <= 0:
        raise ValueError("amount must be positive")
    return amount


def test_validate_amount_raises_on_negative():
    with pytest.raises(ValueError, match="must be positive"):
        validate_amount(-10)


def fetch_with_fallback(client, url):
    try:
        return client.get(url)
    except ConnectionError:
        return None   # fails gracefully instead of crashing the caller


def test_fetch_with_fallback_handles_connection_error():
    mock_client = Mock()
    mock_client.get.side_effect = ConnectionError("timeout")
    result = fetch_with_fallback(mock_client, "https://api.example.com")
    assert result is None

10

pytest.raises confirms the ValueError actually happens, with the expected message — not just that SOME error occurs.

23

side_effect makes the mock raise ConnectionError when called, simulating a real network failure without a real network.

2 passed

Why this works: pytest.raises turns "this should fail" into a real, checked assertion instead of an untested assumption. side_effect lets a test simulate exactly the kind of failure — a timeout, a malformed response — that a happy-path test would never trigger on its own.