unittest — Python's Built-in Framework

• Write a unittest.TestCase subclass with test_* methods.
• Use self.assertEqual and friends instead of bare assert.
• Run tests with python -m unittest.
• Read the dots, the F/E markers, and the summary.

unittest is part of the standard library — it's already on your machine. It's based on the classic "xUnit" style: tests are methods inside a class that inherits from TestCase.

The structure

# test_mathtools.py
import unittest
from mathtools import is_prime, factorial

class TestMathTools(unittest.TestCase):

    def test_is_prime_true(self):
        self.assertTrue(is_prime(17))

    def test_is_prime_false(self):
        self.assertFalse(is_prime(4))

    def test_factorial(self):
        self.assertEqual(factorial(5), 120)

if __name__ == "__main__":
    unittest.main()

Run it — two ways

$ python test_mathtools.py        # if you added unittest.main()
$ python -m unittest test_mathtools   # the standard way
$ python -m unittest                  # auto-discover all test_*.py

...
----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

Reading the output

.   a passing test (one dot per test)
F   a failed assertion
E   an unexpected error (exception)

...F.   means: 3 pass, 1 fail, 1 pass

Why self.assertEqual beats assert

# bare assert — unhelpful on failure
assert factorial(5) == 120

# unittest assertion — prints expected vs actual automatically
self.assertEqual(factorial(5), 120)

# when it fails, unittest tells you:
AssertionError: 119 != 120

You get the actual value (119) and the expected (120) for free — no need to write your own message.

The verbose flag

$ python -m unittest -v
test_factorial (test_mathtools.TestMathTools) ... ok
test_is_prime_false (...) ... ok
test_is_prime_true (...) ... ok

# bank.py
class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount
    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount

# test_bank.py
import unittest
from bank import BankAccount

class TestBankAccount(unittest.TestCase):

    def test_starts_at_zero(self):
        self.assertEqual(BankAccount().balance, 0)

    def test_deposit_increases_balance(self):
        acc = BankAccount()
        acc.deposit(100)
        self.assertEqual(acc.balance, 100)

    def test_withdraw_decreases_balance(self):
        acc = BankAccount(100)
        acc.withdraw(40)
        self.assertEqual(acc.balance, 60)

    def test_overdraw_raises(self):
        acc = BankAccount(50)
        with self.assertRaises(ValueError):
            acc.withdraw(100)

    def test_negative_deposit_raises(self):
        with self.assertRaises(ValueError):
            BankAccount().deposit(-5)

if __name__ == "__main__":
    unittest.main()

Run

$ python -m unittest test_bank -v
test_deposit_increases_balance ... ok
test_negative_deposit_raises ... ok
test_overdraw_raises ... ok
test_starts_at_zero ... ok
test_withdraw_decreases_balance ... ok

Ran 5 tests in 0.001s
OK

Read the diff

Notice with self.assertRaises(ValueError): — testing an exception is now one clean line instead of the clunky try/except from Lesson 5. Each method is one focused test with a descriptive name, so a failure tells you exactly which behaviour broke. That readability is the whole point of a framework.

unittest is built into Python. Subclass TestCase; each test_* method is one test, auto-discovered. Use self.assertEqual / assertTrue / assertRaises for clear failure messages. Run with python -m unittest [-v]. The dots/F/E show progress at a glance. Next: the full assertion toolkit.