Unit Testing

Introduction

So far, you have checked whether your code works by running it and looking at the output yourself. That works fine for a five-line script, but it quickly breaks down as programs grow — you cannot realistically re-check every function by hand every time you change a single line.

Unit testing solves this by letting you write code that checks your code. A test is simply a small piece of Python that calls a function with known inputs and verifies it produces the expected output — automatically, repeatedly, and in seconds. This is the final lesson of the course, and it ties everything you have learned together: you will use functions, classes, exceptions, and modules to build a safety net around the programs you write.

Why Automated Testing Matters

As a program grows, changing one function can accidentally break another part of the code without you noticing — this is called a regression. Automated tests catch regressions immediately, because you can re-run every test in seconds after any change.

The unittest Module

Python ships with a built-in testing framework called unittest. To use it, you create a class that inherits from unittest.TestCase, and write methods whose names start with test_.

import unittest

class TestMath(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(2 + 2, 4)

    def test_subtraction(self):
        self.assertEqual(5 - 3, 2)


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

..
----------------------------------------------------------------
Ran 2 tests in 0.001s

OK

unittest automatically discovers every method starting with test_ inside a TestCase subclass and runs each one independently. Each dot in the output represents one passing test.

Common Assertions

Assertions are the checks inside a test method. If an assertion fails, unittest marks that test as failed and reports what went wrong.

import unittest

class TestAssertions(unittest.TestCase):
    def test_equal(self):
        self.assertEqual("python".upper(), "PYTHON")

    def test_true(self):
        self.assertTrue(5 > 3)

    def test_in_list(self):
        self.assertTrue("apple" in ["apple", "banana"])


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

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

OK

Running Your Tests

You can run a test file directly from the command line, either by executing the file itself (if it calls unittest.main()) or using Python's built-in test discovery.

python test_basic.py

# or, to discover and run every test file automatically:
python -m unittest discover

..
----------------------------------------------------------------
Ran 2 tests in 0.001s

OK

When a test fails, unittest shows exactly which assertion failed, the expected value, and the actual value, making it easy to pinpoint the problem.

import unittest

class TestMath(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(2 + 2, 5)   # deliberately wrong


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

F
======================================================================
FAIL: test_addition (__main__.TestMath)
----------------------------------------------------------------
AssertionError: 4 != 5

----------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (failures=1)

Testing for Exceptions

Sometimes correct behavior means raising an error — for example, dividing by zero should fail loudly rather than silently returning a wrong number. assertRaises checks that the expected exception actually occurs.

import unittest

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

class TestDivide(unittest.TestCase):
    def test_normal_division(self):
        self.assertEqual(divide(10, 2), 5)

    def test_divide_by_zero_raises(self):
        with self.assertRaises(ValueError):
            divide(10, 0)


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

..
----------------------------------------------------------------
Ran 2 tests in 0.001s

OK

A Worked Example

Let's test a small, realistic function: one that calculates a discounted price. We will cover a normal case, an edge case, and an invalid input case.

def calculate_discounted_price(price, discount_percent):
    if price < 0:
        raise ValueError("Price cannot be negative")
    if not (0 <= discount_percent <= 100):
        raise ValueError("Discount must be between 0 and 100")
    return price - (price * discount_percent / 100)

import unittest
from shopping import calculate_discounted_price

class TestDiscountedPrice(unittest.TestCase):
    def test_normal_discount(self):
        self.assertEqual(calculate_discounted_price(200, 10), 180)

    def test_zero_discount(self):
        self.assertEqual(calculate_discounted_price(150, 0), 150)

    def test_full_discount(self):
        self.assertEqual(calculate_discounted_price(150, 100), 0)

    def test_negative_price_raises(self):
        with self.assertRaises(ValueError):
            calculate_discounted_price(-50, 10)

    def test_invalid_discount_raises(self):
        with self.assertRaises(ValueError):
            calculate_discounted_price(100, 150)


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

.....
----------------------------------------------------------------
Ran 5 tests in 0.001s

OK

Notice how each test covers one specific behavior. This makes it immediately obvious which part of calculate_discounted_price broke if a test ever fails after a future change.

pytest: A Simpler Alternative

While unittest ships with Python and works well, many developers prefer pytest, a hugely popular third-party testing library. pytest lets you write tests as plain functions using ordinary assert statements — no test class or self.assertEqual boilerplate required.

pip install pytest

from shopping import calculate_discounted_price
import pytest

def test_normal_discount():
    assert calculate_discounted_price(200, 10) == 180

def test_zero_discount():
    assert calculate_discounted_price(150, 0) == 150

def test_negative_price_raises():
    with pytest.raises(ValueError):
        calculate_discounted_price(-50, 10)

pytest test_shopping_pytest.py

===================== test session starts ======================
collected 3 items

test_shopping_pytest.py ...                                 [100%]

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

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Unit testing turns "I think my code works" into "I can prove my code works, automatically, every time." Whether you use the built-in unittest module or the simpler pytest library, writing tests alongside your code is one of the most valuable habits you can build as a Python developer.

What to Learn Next

Congratulations — you have reached the end of this 58-lesson Python course! You now have a solid foundation covering syntax, data structures, functions, object-oriented programming, error handling, modules, type hints, context managers, and testing. That foundation is exactly what you need to specialize in whatever area excites you most.

Whichever path you choose, keep writing code, keep testing it, and keep building. That is how every Python developer, no matter how experienced, continues to grow.