pytest — Smart Assert Introspection

• Read pytest's assertion failure output for ints, lists, dicts, strings.
• Use pytest.approx for float comparisons.
• Use pytest.raises with match for exception messages.
• Write assertions that produce the clearest failures.

def test_lists():
    assert [1, 2, 3] == [1, 2, 4]

>       assert [1, 2, 3] == [1, 2, 4]
E       assert [1, 2, 3] == [1, 2, 4]
E         At index 2 diff: 3 != 4
E         Full diff:
E         - [1, 2, 4]
E         + [1, 2, 3]

Dicts — shows which key differs

assert got == {"name": "Aisyah", "age": 13}
E   AssertionError: assert {'name': 'Aisyah', 'age': 14} == {'name': 'Aisyah', 'age': 13}
E     Differing items:
E     {'age': 14} != {'age': 13}

Strings — shows the first differing character

assert slug == "hello-world"
E   AssertionError: assert 'hello_world' == 'hello-world'
E     - hello-world
E     + hello_world
E     ?      ^

Floats — use pytest.approx

from pytest import approx

def test_total():
    assert cart_total([(9.99, 3)]) == approx(29.97)
    # or with a list:
    assert [0.1 + 0.2, 1.0] == approx([0.3, 1.0])

approx is pytest's float-safe equality — cleaner than math.isclose and it works inside lists and dicts too.

Exceptions — message matching

import pytest

def test_withdraw_message():
    with pytest.raises(ValueError, match="insufficient"):
        BankAccount(50).withdraw(100)

    # capture the exception to inspect it further:
    with pytest.raises(ValueError) as exc_info:
        BankAccount(50).withdraw(100)
    assert "100" in str(exc_info.value)

Write asserts that fail clearly

# ✗ vague — "False is not True"
assert is_valid(data)

# ✓ specific — shows the actual value
assert is_valid(data) is True
assert error_count == 0           # shows the actual count
assert "error" not in response    # shows the response on failure

One assert per logical fact. A test with ten asserts that fails on the third leaves the rest unchecked — split them or assert the whole structure at once.

# test_parse.py
from parse import parse_order

def test_parse_order():
    result = parse_order("2x roti @1.50")
    assert result == {"qty": 2, "item": "roti", "price": 1.50}

Run it and the bug reveals itself without you adding a single print:

>       assert result == {"qty": 2, "item": "roti", "price": 1.50}
E       AssertionError: assert {'qty': '2', 'item': 'roti', 'price': 1.5} == {'qty': 2, 'item': 'roti', 'price': 1.5}
E         Differing items:
E         {'qty': '2'} != {'qty': 2}

The diff pinpoints it: qty is the string '2', not the int 2 — parse_order forgot to int() the quantity. You found the bug from the failure message alone.

# the fix in parse.py:
def parse_order(text):
    qty_str, rest = text.split("x ", 1)
    item, price_str = rest.split(" @")
    return {"qty": int(qty_str), "item": item.strip(),
            "price": float(price_str)}      # int() and float() added

Read the diff

This is the daily reality of working with pytest: a failing test's output usually tells you exactly what's wrong, so you rarely need print debugging. Reading the diff well — "string vs int", "index 2", "missing key" — is a skill that makes you fast.

pytest rewrites failing asserts into detailed diffs: which list index, which dict key, which character. Use pytest.approx for floats (works in lists/dicts too) and pytest.raises(Exc, match=...) for exceptions. Write specific asserts and prefer one structural assert over many tiny ones. Reading failure output well makes you a fast debugger. Next: fixtures.