Article 6: Testing Fundamentals

Introduction

Testing is not optional—it's a core part of professional software development. Through maintaining production systems, I've learned that comprehensive tests are what let you sleep at night, refactor with confidence, and catch bugs before users do.

This article covers unit testing with pytest, the standard testing framework for Python. We'll explore test structure, assertions, and how to write tests that actually catch bugs.

Why Test?

Benefits of testing:

• Catch bugs early - Before they reach production

• Enable refactoring - Change code safely

• Document behavior - Tests show how code should work

• Design better code - Testable code is usually better code

• Save time long-term - Debugging in production is expensive

Getting Started with pytest

Installation

pip install pytest pytest-cov

First Test

# tests/test_example.py

def test_addition():
    """Test that addition works correctly."""
    result = 1 + 1
    assert result == 2


def test_string_concatenation():
    """Test string concatenation."""
    result = "Hello, " + "World!"
    assert result == "Hello, World!"

Run tests:

# Run all tests
pytest

# Verbose output
pytest -v

# Run specific file
pytest tests/test_example.py

# Run specific test
pytest tests/test_example.py::test_addition

# Stop on first failure
pytest -x

# Show print statements
pytest -s

Test Structure: Arrange-Act-Assert

The AAA pattern keeps tests clear and consistent:

def test_user_full_name():
    """Test that full name combines first and last name."""
    # Arrange: Set up the test data
    user = User(first_name="Alice", last_name="Smith")
    
    # Act: Perform the action being tested
    result = user.full_name
    
    # Assert: Verify the result
    assert result == "Alice Smith"


def test_calculate_discount():
    """Test discount calculation for bulk orders."""
    # Arrange
    order = Order(
        items=[
            OrderItem(name="Widget", price=Decimal("10.00"), quantity=15)
        ]
    )
    calculator = DiscountCalculator(bulk_threshold=10, discount_rate=0.10)
    
    # Act
    discount = calculator.calculate(order)
    
    # Assert
    assert discount == Decimal("15.00")  # 10% of 150

Project Structure

task-manager/
├── src/
│   └── task_manager/
│       ├── __init__.py
│       ├── models.py
│       └── services.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py           # Shared fixtures
│   ├── test_models.py
│   └── test_services.py
└── pyproject.toml

pytest Configuration

# pyproject.toml
[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_functions = ["test_*"]
addopts = [
    "-v",
    "--strict-markers",
    "--tb=short",
]
markers = [
    "slow: marks tests as slow",
    "integration: marks tests as integration tests",
]

Assertions

Basic Assertions

# Equality
assert result == expected
assert result != unexpected

# Truthiness
assert is_valid
assert not is_invalid

# Comparison
assert count > 0
assert value >= minimum
assert score <= 100

# Membership
assert item in collection
assert key in dictionary
assert "error" not in message

# Type checking
assert isinstance(result, User)
assert isinstance(items, list)

# None checking
assert result is None
assert result is not None

Detailed Assertion Messages

# pytest shows detailed diffs on failure
def test_user_data():
    user = get_user(123)
    
    # Bad: No context on failure
    assert user.name == "Alice"
    
    # Better: pytest shows the diff automatically
    expected = {"name": "Alice", "email": "[email protected]"}
    assert user.to_dict() == expected
    # On failure:
    # AssertionError: assert {'name': 'Bob', ...} == {'name': 'Alice', ...}
    #   - {'name': 'Bob', 'email': '[email protected]'}
    #   + {'name': 'Alice', 'email': '[email protected]'}

Testing Exceptions

import pytest


def test_division_by_zero_raises():
    """Test that dividing by zero raises an exception."""
    with pytest.raises(ZeroDivisionError):
        result = 1 / 0


def test_invalid_email_raises_value_error():
    """Test that invalid email raises ValueError with message."""
    with pytest.raises(ValueError) as exc_info:
        validate_email("not-an-email")
    
    assert "Invalid email format" in str(exc_info.value)


def test_user_not_found():
    """Test that missing user raises specific exception."""
    repository = UserRepository()
    
    with pytest.raises(UserNotFoundError) as exc_info:
        repository.get_by_id(999)
    
    assert exc_info.value.user_id == 999

Approximate Comparisons

import pytest
from decimal import Decimal


def test_floating_point():
    """Test floating point with tolerance."""
    result = 0.1 + 0.2
    
    # This might fail due to floating point precision
    # assert result == 0.3
    
    # Use pytest.approx for floating point
    assert result == pytest.approx(0.3)
    
    # With custom tolerance
    assert result == pytest.approx(0.3, rel=1e-9)


def test_decimal_calculations():
    """Test decimal calculations."""
    # For money, use Decimal for precision
    price = Decimal("19.99")
    tax = Decimal("0.08")
    
    total = price * (1 + tax)
    
    assert total == Decimal("21.5892")

Test Organization

Grouping with Classes

class TestUser:
    """Tests for the User model."""
    
    def test_create_user(self):
        """Test user creation."""
        user = User(name="Alice", email="[email protected]")
        
        assert user.name == "Alice"
        assert user.email == "[email protected]"
    
    def test_user_full_name(self):
        """Test full name property."""
        user = User(first_name="Alice", last_name="Smith")
        
        assert user.full_name == "Alice Smith"
    
    def test_user_email_validation(self):
        """Test email validation on creation."""
        with pytest.raises(ValueError):
            User(name="Alice", email="invalid")


class TestUserRepository:
    """Tests for UserRepository."""
    
    def test_save_user(self):
        """Test saving a user."""
        repo = InMemoryUserRepository()
        user = User(name="Alice")
        
        saved = repo.save(user)
        
        assert saved.id is not None
    
    def test_find_by_id(self):
        """Test finding user by ID."""
        repo = InMemoryUserRepository()
        user = repo.save(User(name="Alice"))
        
        found = repo.find_by_id(user.id)
        
        assert found is not None
        assert found.name == "Alice"

Markers for Test Categories

import pytest


@pytest.mark.slow
def test_large_data_processing():
    """Test that takes a long time."""
    # Process millions of records
    pass


@pytest.mark.integration
def test_database_connection():
    """Test that requires actual database."""
    pass


@pytest.mark.skip(reason="Feature not implemented yet")
def test_future_feature():
    """Test for planned feature."""
    pass


@pytest.mark.skipif(
    sys.platform == "win32",
    reason="Not supported on Windows"
)
def test_unix_specific():
    """Test that only works on Unix."""
    pass

Run specific markers:

# Run only fast tests (skip slow)
pytest -m "not slow"

# Run only integration tests
pytest -m integration

# Run unit tests only
pytest -m "not integration"

Fixtures

Basic Fixtures

# tests/conftest.py
import pytest
from task_manager.models import Task
from task_manager.repository import InMemoryTaskRepository


@pytest.fixture
def sample_task():
    """Create a sample task for testing."""
    return Task(
        id=1,
        title="Learn pytest",
        description="Master Python testing",
        completed=False,
    )


@pytest.fixture
def task_repository():
    """Create a fresh repository for each test."""
    return InMemoryTaskRepository()


@pytest.fixture
def populated_repository(task_repository):
    """Repository with sample data."""
    tasks = [
        Task(id=1, title="Task 1", completed=False),
        Task(id=2, title="Task 2", completed=True),
        Task(id=3, title="Task 3", completed=False),
    ]
    for task in tasks:
        task_repository.save(task)
    return task_repository

# tests/test_repository.py

def test_save_task(task_repository, sample_task):
    """Test saving a task to repository."""
    saved = task_repository.save(sample_task)
    
    assert saved.id is not None
    assert task_repository.find_by_id(saved.id) == saved


def test_find_incomplete_tasks(populated_repository):
    """Test finding incomplete tasks."""
    incomplete = populated_repository.find_incomplete()
    
    assert len(incomplete) == 2
    assert all(not task.completed for task in incomplete)

Fixture Scopes

import pytest


@pytest.fixture(scope="function")  # Default: new instance per test
def user():
    return User(name="Alice")


@pytest.fixture(scope="class")  # Shared within test class
def database():
    db = create_test_database()
    yield db
    db.cleanup()


@pytest.fixture(scope="module")  # Shared within module
def api_client():
    client = APIClient()
    client.authenticate()
    yield client
    client.logout()


@pytest.fixture(scope="session")  # Shared across all tests
def expensive_resource():
    resource = load_expensive_resource()
    yield resource
    resource.cleanup()

Setup and Teardown

import pytest


@pytest.fixture
def temp_directory():
    """Create a temporary directory for tests."""
    import tempfile
    import shutil
    
    # Setup
    temp_dir = tempfile.mkdtemp()
    
    yield temp_dir  # Provide the fixture value
    
    # Teardown (runs even if test fails)
    shutil.rmtree(temp_dir)


@pytest.fixture
def database_connection():
    """Database connection with transaction rollback."""
    connection = create_connection()
    transaction = connection.begin()
    
    yield connection
    
    # Rollback to clean up any changes
    transaction.rollback()
    connection.close()

Parametrized Tests

Test multiple inputs with a single test function:

import pytest


@pytest.mark.parametrize("input_value,expected", [
    (1, 1),
    (2, 4),
    (3, 9),
    (4, 16),
    (-2, 4),
    (0, 0),
])
def test_square(input_value, expected):
    """Test square function with various inputs."""
    assert square(input_value) == expected


@pytest.mark.parametrize("email,is_valid", [
    ("[email protected]", True),
    ("[email protected]", True),
    ("[email protected]", True),
    ("invalid", False),
    ("@example.com", False),
    ("user@", False),
    ("", False),
])
def test_email_validation(email, is_valid):
    """Test email validation with various inputs."""
    result = validate_email(email)
    assert result == is_valid


@pytest.mark.parametrize("discount_type,amount,expected", [
    ("percentage", Decimal("100"), Decimal("10")),
    ("fixed", Decimal("100"), Decimal("15")),
    ("none", Decimal("100"), Decimal("0")),
])
def test_discount_calculation(discount_type, amount, expected):
    """Test different discount types."""
    calculator = DiscountCalculator(discount_type)
    result = calculator.calculate(amount)
    assert result == expected

Combining Parameters

@pytest.mark.parametrize("x", [1, 2, 3])
@pytest.mark.parametrize("y", [10, 20])
def test_multiplication(x, y):
    """Test all combinations of x and y."""
    # Runs 6 tests: (1,10), (1,20), (2,10), (2,20), (3,10), (3,20)
    assert x * y == x * y

Testing Patterns

Testing Edge Cases

class TestDivide:
    """Tests for divide function."""
    
    def test_normal_division(self):
        """Test normal division."""
        assert divide(10, 2) == 5
    
    def test_division_by_zero(self):
        """Test division by zero raises error."""
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            divide(10, 0)
    
    def test_negative_numbers(self):
        """Test division with negative numbers."""
        assert divide(-10, 2) == -5
        assert divide(10, -2) == -5
        assert divide(-10, -2) == 5
    
    def test_floating_point_result(self):
        """Test division that results in float."""
        assert divide(10, 3) == pytest.approx(3.333, rel=0.01)
    
    def test_large_numbers(self):
        """Test with very large numbers."""
        assert divide(10**18, 10**9) == 10**9
    
    def test_small_numbers(self):
        """Test with very small numbers."""
        assert divide(0.001, 0.001) == pytest.approx(1.0)

Testing Collections

def test_filter_active_users():
    """Test filtering active users from list."""
    users = [
        User(name="Alice", is_active=True),
        User(name="Bob", is_active=False),
        User(name="Charlie", is_active=True),
    ]
    
    active = filter_active_users(users)
    
    # Check length
    assert len(active) == 2
    
    # Check contents (order-independent)
    active_names = {user.name for user in active}
    assert active_names == {"Alice", "Charlie"}


def test_sort_by_priority():
    """Test sorting tasks by priority."""
    tasks = [
        Task(title="Low", priority=3),
        Task(title="High", priority=1),
        Task(title="Medium", priority=2),
    ]
    
    sorted_tasks = sort_by_priority(tasks)
    
    # Check order
    titles = [task.title for task in sorted_tasks]
    assert titles == ["High", "Medium", "Low"]

Testing State Changes

def test_complete_task():
    """Test that completing a task changes its state."""
    task = Task(title="Learn testing", completed=False)
    
    # Verify initial state
    assert task.completed is False
    assert task.completed_at is None
    
    # Perform action
    task.complete()
    
    # Verify state change
    assert task.completed is True
    assert task.completed_at is not None


def test_add_item_to_cart():
    """Test adding items to shopping cart."""
    cart = ShoppingCart()
    product = Product(id=1, name="Widget", price=Decimal("9.99"))
    
    # Initial state
    assert cart.item_count == 0
    assert cart.total == Decimal("0")
    
    # Add item
    cart.add(product, quantity=2)
    
    # Verify changes
    assert cart.item_count == 2
    assert cart.total == Decimal("19.98")

Test Coverage

Running with Coverage

# Run tests with coverage
pytest --cov=src/task_manager --cov-report=term-missing

# Generate HTML report
pytest --cov=src/task_manager --cov-report=html

# Fail if coverage below threshold
pytest --cov=src/task_manager --cov-fail-under=80

Coverage Configuration

# pyproject.toml
[tool.coverage.run]
source = ["src"]
branch = true
omit = [
    "*/tests/*",
    "*/__init__.py",
]

[tool.coverage.report]
exclude_lines = [
    "pragma: no cover",
    "def __repr__",
    "raise NotImplementedError",
    "if TYPE_CHECKING:",
]
show_missing = true
fail_under = 80

Understanding Coverage

def process_order(order: Order) -> str:
    if order.is_empty():
        return "empty"           # Line needs test
    
    if order.total > 1000:
        apply_bulk_discount(order)  # Branch needs test
    
    return "processed"


# Tests for 100% coverage
def test_empty_order():
    order = Order(items=[])
    assert process_order(order) == "empty"


def test_normal_order():
    order = Order(items=[Item(price=50)])
    assert process_order(order) == "processed"


def test_bulk_order():
    order = Order(items=[Item(price=1500)])
    result = process_order(order)
    assert result == "processed"
    assert order.has_discount  # Verify discount was applied

Practical Exercise

Exercise 1: Write Tests for a Calculator

# src/calculator.py
from decimal import Decimal
from typing import Union

Number = Union[int, float, Decimal]


class Calculator:
    """Simple calculator with memory."""
    
    def __init__(self) -> None:
        self._memory: Decimal = Decimal("0")
    
    def add(self, a: Number, b: Number) -> Decimal:
        """Add two numbers."""
        return Decimal(str(a)) + Decimal(str(b))
    
    def subtract(self, a: Number, b: Number) -> Decimal:
        """Subtract b from a."""
        return Decimal(str(a)) - Decimal(str(b))
    
    def multiply(self, a: Number, b: Number) -> Decimal:
        """Multiply two numbers."""
        return Decimal(str(a)) * Decimal(str(b))
    
    def divide(self, a: Number, b: Number) -> Decimal:
        """Divide a by b."""
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return Decimal(str(a)) / Decimal(str(b))
    
    def store(self, value: Number) -> None:
        """Store value in memory."""
        self._memory = Decimal(str(value))
    
    def recall(self) -> Decimal:
        """Recall value from memory."""
        return self._memory
    
    def clear(self) -> None:
        """Clear memory."""
        self._memory = Decimal("0")

# tests/test_calculator.py
import pytest
from decimal import Decimal
from calculator import Calculator


class TestCalculatorOperations:
    """Test basic calculator operations."""
    
    @pytest.fixture
    def calc(self):
        """Fresh calculator for each test."""
        return Calculator()
    
    @pytest.mark.parametrize("a,b,expected", [
        (1, 2, 3),
        (0, 0, 0),
        (-1, 1, 0),
        (0.1, 0.2, Decimal("0.3")),
    ])
    def test_add(self, calc, a, b, expected):
        """Test addition with various inputs."""
        result = calc.add(a, b)
        assert result == Decimal(str(expected))
    
    def test_divide_by_zero(self, calc):
        """Test division by zero raises error."""
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            calc.divide(10, 0)


class TestCalculatorMemory:
    """Test calculator memory functions."""
    
    @pytest.fixture
    def calc(self):
        return Calculator()
    
    def test_initial_memory_is_zero(self, calc):
        """Test memory starts at zero."""
        assert calc.recall() == Decimal("0")
    
    def test_store_and_recall(self, calc):
        """Test storing and recalling values."""
        calc.store(42)
        assert calc.recall() == Decimal("42")
    
    def test_clear_memory(self, calc):
        """Test clearing memory."""
        calc.store(100)
        calc.clear()
        assert calc.recall() == Decimal("0")

Exercise 2: Test a Task Manager

# Write comprehensive tests for this class

@dataclass
class Task:
    id: Optional[int]
    title: str
    completed: bool = False
    due_date: Optional[date] = None


class TaskManager:
    def __init__(self) -> None:
        self._tasks: dict[int, Task] = {}
        self._next_id = 1
    
    def add(self, title: str, due_date: Optional[date] = None) -> Task:
        """Add a new task."""
        if not title.strip():
            raise ValueError("Title cannot be empty")
        
        task = Task(id=self._next_id, title=title, due_date=due_date)
        self._tasks[self._next_id] = task
        self._next_id += 1
        return task
    
    def complete(self, task_id: int) -> None:
        """Mark a task as completed."""
        if task_id not in self._tasks:
            raise KeyError(f"Task {task_id} not found")
        self._tasks[task_id].completed = True
    
    def get_pending(self) -> list[Task]:
        """Get all incomplete tasks."""
        return [t for t in self._tasks.values() if not t.completed]
    
    def get_overdue(self) -> list[Task]:
        """Get incomplete tasks past due date."""
        today = date.today()
        return [
            t for t in self._tasks.values()
            if not t.completed and t.due_date and t.due_date < today
        ]

Testing Best Practices

Do's

• ✅ Test one thing per test

• ✅ Use descriptive test names

• ✅ Follow Arrange-Act-Assert pattern

• ✅ Test edge cases and error conditions

• ✅ Keep tests independent

• ✅ Use fixtures for common setup

Don'ts

• ❌ Test implementation details

• ❌ Write tests that depend on other tests

• ❌ Use sleep() in tests

• ❌ Test external systems in unit tests

• ❌ Ignore flaky tests

• ❌ Write tests after bugs are found (write them to prevent bugs!)

Key Takeaways

1. Tests are code - Apply the same quality standards

2. AAA pattern - Arrange, Act, Assert keeps tests clear

3. Fixtures enable reuse - Share setup across tests

4. Parametrize for coverage - Test multiple inputs efficiently

5. Coverage is a guide - 100% coverage doesn't mean bug-free

What's Next?

With unit testing fundamentals covered, we're ready for advanced techniques. In Article 7: Advanced Testing Strategies, we'll explore mocking, fixtures, integration testing, and test-driven development.

---

This article is part of the Software Engineering 101 series.