pytest Unit Testing in Python — Fixtures, Mocks and Real Patterns

# test_price_calculator.py
# Run with: pytest test_price_calculator.py -v

def apply_discount(original_price: float, discount_percent: float) -> float:
    """
    Returns the discounted price.
    Raises ValueError if discount is not between 0 and 100.
    """
    if not (0 <= discount_percent <= 100):
        raise ValueError(f"Discount must be between 0 and 100, got {discount_percent}")
    discount_amount = original_price * (discount_percent / 100)
    return round(original_price - discount_amount, 2)


# --- Happy path: normal expected usage ---
def test_apply_discount_returns_correct_price():
    discounted = apply_discount(original_price=200.00, discount_percent=10)
    assert discounted == 180.00  # 10% off £200 should be £180


# --- Edge case: zero discount means price is unchanged ---
def test_apply_discount_with_zero_percent_returns_original():
    discounted = apply_discount(original_price=99.99, discount_percent=0)
    assert discounted == 99.99  # 0% off should change nothing


# --- Edge case: 100% discount means free ---
def test_apply_discount_with_full_discount_returns_zero():
    discounted = apply_discount(original_price=50.00, discount_percent=100)
    assert discounted == 0.00


# --- Failure mode: invalid discount raises the right exception ---
def test_apply_discount_raises_for_negative_discount():
    import pytest
    with pytest.raises(ValueError, match="Discount must be between 0 and 100"):
        apply_discount(original_price=100.00, discount_percent=-5)
        # The match= argument verifies the error message content —
        # this prevents a different ValueError from silently passing

# test_user_service.py
# Run with: pytest test_user_service.py -v

import pytest


class UserService:
    """Simulates a real service that manages user accounts."""

    def __init__(self, storage: dict):
        self._storage = storage  # In production this would be a DB session

    def create_user(self, username: str, email: str) -> dict:
        if username in self._storage:
            raise ValueError(f"Username '{username}' is already taken")
        user = {"username": username, "email": email, "active": True}
        self._storage[username] = user
        return user

    def deactivate_user(self, username: str) -> None:
        if username not in self._storage:
            raise KeyError(f"User '{username}' does not exist")
        self._storage[username]["active"] = False

    def get_user(self, username: str) -> dict:
        return self._storage.get(username)


# --- Fixture: creates a FRESH UserService for every test ---
# Scope defaults to 'function' — each test gets its own clean slate
@pytest.fixture
def user_service():
    fresh_storage = {}  # Empty dict = no leftover data from other tests
    return UserService(storage=fresh_storage)


# --- Fixture with setup AND teardown using yield ---
@pytest.fixture
def user_service_with_existing_user(user_service):
    # Setup: add a pre-existing user before the test runs
    user_service.create_user(username="alice", email="alice@example.com")
    yield user_service  # Hand control to the test
    # Teardown: anything after yield runs after the test completes
    # (Here the dict goes out of scope anyway, but in a real DB you'd rollback here)


def test_create_user_succeeds(user_service):
    # 'user_service' parameter name matches the fixture — pytest injects it
    new_user = user_service.create_user(username="bob", email="bob@example.com")
    assert new_user["username"] == "bob"
    assert new_user["active"] is True


def test_create_duplicate_user_raises_error(user_service_with_existing_user):
    with pytest.raises(ValueError, match="already taken"):
        # alice already exists — this should fail at the service level
        user_service_with_existing_user.create_user(
            username="alice", email="alice2@example.com"
        )


def test_deactivate_user_sets_active_to_false(user_service_with_existing_user):
    user_service_with_existing_user.deactivate_user(username="alice")
    alice = user_service_with_existing_user.get_user(username="alice")
    assert alice["active"] is False  # Deactivation should flip the flag


def test_deactivate_nonexistent_user_raises_key_error(user_service):
    with pytest.raises(KeyError):
        user_service.deactivate_user(username="ghost_user")

# test_email_notifier.py
# Run with: pytest test_email_notifier.py -v

import pytest
from unittest.mock import patch, MagicMock


# ── Module under test (inline for demonstration) ──────────────────────────────

def validate_email_format(email: str) -> bool:
    """Basic check: must contain @ and at least one dot after @"""
    if "@" not in email:
        return False
    local, _, domain = email.partition("@")
    return bool(local) and "." in domain


def calculate_order_total(unit_price: float, quantity: int, tax_rate: float) -> float:
    """Total = (unit_price * quantity) + tax"""
    subtotal = unit_price * quantity
    return round(subtotal + (subtotal * tax_rate), 2)


# Simulates a service that calls an external SMTP API
class EmailNotifier:
    def __init__(self, smtp_client):
        self._smtp = smtp_client  # This is the external dependency we'll mock

    def send_welcome_email(self, recipient_email: str, username: str) -> bool:
        if not validate_email_format(recipient_email):
            raise ValueError(f"Invalid email address: {recipient_email}")
        self._smtp.send(
            to=recipient_email,
            subject="Welcome!",
            body=f"Hi {username}, welcome aboard!",
        )
        return True


# ── PARAMETRIZE: test one function with many inputs ───────────────────────────

@pytest.mark.parametrize(
    "unit_price, quantity, tax_rate, expected_total",
    [
        (10.00,  1,  0.00,  10.00),   # No tax
        (10.00,  3,  0.10,  33.00),   # 10% tax on 3 items
        (99.99,  2,  0.20, 239.98),   # 20% VAT on 2 items
        ( 0.00,  5,  0.25,   0.00),   # Free item, any quantity
    ],
    ids=["no_tax", "10pct_tax", "20pct_vat", "free_item"],  # Readable test IDs
)
def test_calculate_order_total(unit_price, quantity, tax_rate, expected_total):
    # Same assertion logic, but pytest runs this four times with different data
    result = calculate_order_total(unit_price, quantity, tax_rate)
    assert result == expected_total


# ── MOCKING: replace external SMTP client with a controlled fake ──────────────

def test_send_welcome_email_calls_smtp_with_correct_args():
    mock_smtp = MagicMock()  # A fake object that records every call made to it

    notifier = EmailNotifier(smtp_client=mock_smtp)
    result = notifier.send_welcome_email(
        recipient_email="charlie@example.com", username="charlie"
    )

    assert result is True
    # Verify the smtp client was called exactly once with the right arguments
    mock_smtp.send.assert_called_once_with(
        to="charlie@example.com",
        subject="Welcome!",
        body="Hi charlie, welcome aboard!",
    )


def test_send_welcome_email_raises_for_invalid_email():
    mock_smtp = MagicMock()
    notifier = EmailNotifier(smtp_client=mock_smtp)

    with pytest.raises(ValueError, match="Invalid email address"):
        notifier.send_welcome_email(
            recipient_email="not-an-email", username="dave"
        )

    # Crucially: the smtp client should NEVER have been called for a bad address
    mock_smtp.send.assert_not_called()


@pytest.mark.parametrize(
    "email, expected_valid",
    [
        ("user@example.com",    True),
        ("bad-email",           False),
        ("missing@dot",         False),
        ("@nodomain.com",       False),
        ("two@dots.are.fine",   True),
    ],
)
def test_validate_email_format(email, expected_valid):
    assert validate_email_format(email) == expected_valid