Unit Testing with pytest

def add(a, b):
    return a + b

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

from calculator import add, divide

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

def test_add_negative_numbers():
    assert add(-1, -1) == -2

def test_divide():
    assert divide(10, 2) == 5.0

$ pytest
====== test session starts ======
collected 3 items

test_calculator.py ...                                    [100%]

====== 3 passed in 0.02s ======

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

# ====== FAILURES ======
# ____ test_add ____
#
#     def test_add():
# >       assert add(2, 3) == 6
# E       assert 5 == 6
# E        +  where 5 = add(2, 3)

import pytest
from calculator import divide

def test_divide_by_zero_raises():
    with pytest.raises(ValueError):
        divide(10, 0)

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

import pytest

@pytest.fixture
def sample_cart():
    return {"items": ["book", "pen"], "total": 25.50}

def test_cart_has_two_items(sample_cart):
    assert len(sample_cart["items"]) == 2

def test_cart_total(sample_cart):
    assert sample_cart["total"] == 25.50

@pytest.fixture
def database_connection():
    conn = connect_to_test_database()
    yield conn                        # the test runs here, receiving "conn"
    conn.close()                      # runs after the test finishes, pass or fail

def test_insert_record(database_connection):
    database_connection.execute("INSERT INTO users VALUES (1, 'Asha')")
    assert database_connection.query("SELECT COUNT(*) FROM users") == 1

@pytest.fixture(scope="function")   # default — a fresh instance for EVERY test
def sample_cart():
    ...

@pytest.fixture(scope="module")     # created ONCE, shared across every test in this file
def expensive_database_connection():
    ...

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

def test_add_negative():
    assert add(-2, -3) == -5

def test_add_zero():
    assert add(0, 5) == 5

import pytest

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (-2, -3, -5),
    (0, 5, 5),
])
def test_add(a, b, expected):
    assert add(a, b) == expected

# pytest reports each case individually:
# test_add[2-3-5] PASSED
# test_add[-2--3--5] PASSED
# test_add[0-5-5] PASSED

from unittest.mock import patch

def get_weather(city):
    response = requests.get(f"https://api.example.com/weather/{city}")
    return response.json()["temperature"]

@patch("requests.get")
def test_get_weather(mock_get):
    mock_get.return_value.json.return_value = {"temperature": 72}

    result = get_weather("Boston")

    assert result == 72
    mock_get.assert_called_once_with("https://api.example.com/weather/Boston")

def test_get_weather(monkeypatch):
    class FakeResponse:
        def json(self):
            return {"temperature": 72}

    monkeypatch.setattr("requests.get", lambda url: FakeResponse())

    assert get_weather("Boston") == 72
# monkeypatch automatically undoes the patch after the test — no manual cleanup needed

myproject/
    calculator.py
    tests/
        conftest.py        # fixtures shared across MULTIPLE test files
        test_calculator.py
        test_api.py

pip install pytest-cov
pytest --cov=myproject

A team needs to rewrite the internals of a function that calculates a patient's medication dosage schedule — genuinely high-stakes code, where a bug has real consequences, not just an inconvenience. The function has 40 existing tests covering edge cases accumulated over two years: zero-weight patients, medications with no active ingredient overlap, dosages that round to exactly a boundary value.

@pytest.mark.parametrize("weight_kg, drug, expected_mg", [
    (70, "drug_a", 350),
    (0.1, "drug_a", 0.5),      # a genuinely tiny edge case, added after a real past bug
    (150, "drug_b", 600),      # the drug_b maximum-dose cap, added after ANOTHER real past bug
])
def test_dosage_calculation(weight_kg, drug, expected_mg):
    assert calculate_dosage(weight_kg, drug) == expected_mg

Why the tests, not just careful code review, were what made the refactor safe

The engineer doing the rewrite ran the existing 40 tests continuously while restructuring the internals — every time a change broke one of the historical edge cases (several times during the rewrite), it failed immediately and locally, long before a pull request or a reviewer was even involved. Two of those historical edge-case tests existed specifically because of past real incidents; without them encoded as executable tests, there would have been no way to know the refactor had silently reintroduced either bug until it happened again in production.