Writing Your First Test Without a Framework

• Separate code-under-test from test code in two files.
• Organise tests as named functions.
• Run all tests, catch failures, and print a clean summary.
• Appreciate the boilerplate a framework removes.

myproject/
├─ mathtools.py        # the code we're testing
└─ test_mathtools.py   # the tests (imports mathtools)

The code under test

# mathtools.py
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

def factorial(n):
    if n < 0:
        raise ValueError("factorial of negative number")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

The test file

# test_mathtools.py
from mathtools import is_prime, factorial

def test_is_prime_basics():
    assert is_prime(2) is True
    assert is_prime(17) is True
    assert is_prime(4) is False

def test_is_prime_edges():
    assert is_prime(0) is False
    assert is_prime(1) is False
    assert is_prime(-7) is False

def test_factorial():
    assert factorial(0) == 1
    assert factorial(5) == 120

def test_factorial_negative_raises():
    try:
        factorial(-1)
        assert False, "expected ValueError"
    except ValueError:
        pass

def run_all():
    tests = [test_is_prime_basics, test_is_prime_edges,
             test_factorial, test_factorial_negative_raises]
    passed = failed = 0
    for t in tests:
        try:
            t()
            print(f"  PASS  {t.__name__}")
            passed += 1
        except AssertionError as e:
            print(f"  FAIL  {t.__name__}: {e}")
            failed += 1
    print(f"\n{passed} passed, {failed} failed")

if __name__ == "__main__":
    run_all()

Run it

$ python test_mathtools.py
  PASS  test_is_prime_basics
  PASS  test_is_prime_edges
  PASS  test_factorial
  PASS  test_factorial_negative_raises

4 passed, 0 failed

What's annoying here?

• You must manually list every test in run_all — forget one and it silently never runs.
• You hand-wrote the pass/fail counting and try/except.
• Checking an exception took 4 clunky lines.
• A failure shows your message but not the actual vs expected values.

Every one of these annoyances is exactly what unittest (next lesson) and pytest fix for free.

The biggest annoyance — hand-listing tests — we can fix ourselves. Find every function named test_* automatically:

# at the bottom of test_mathtools.py
import sys, inspect

def run_all():
    # auto-collect every test_* function in this module
    module = sys.modules[__name__]
    tests = [fn for name, fn in inspect.getmembers(module, inspect.isfunction)
             if name.startswith("test_")]
    passed = failed = 0
    for t in tests:
        try:
            t(); print(f"  PASS  {t.__name__}"); passed += 1
        except AssertionError as e:
            print(f"  FAIL  {t.__name__}: {e}"); failed += 1
        except Exception as e:
            print(f"  ERROR {t.__name__}: {type(e).__name__}: {e}"); failed += 1
    print(f"\n{passed} passed, {failed} failed")
    sys.exit(1 if failed else 0)    # exit code matters for CI (L6-46)

if __name__ == "__main__":
    run_all()

Read the diff

Now you never forget to register a test — naming it test_* is enough. We also catch unexpected exceptions separately (ERROR vs FAIL) and set a non-zero exit code on failure, which is how CI systems know the build failed. Congratulations: you've just re-invented the core of pytest. From the next lesson, you'll use the real thing.

A real test file lives beside the code (test_foo.py imports foo.py), organises checks as test_* functions, and a runner executes them all, catching failures and printing a summary. Doing it by hand exposes the boilerplate — manual registration, pass/fail counting, clunky exception checks — that frameworks remove. You even built auto-discovery and exit codes. Next: the real built-in framework, unittest.