Unit Testing

Advanced ~30 min read

Unit testing is essential for writing reliable, maintainable code. Python's built-in unittest module provides a comprehensive testing framework inspired by JUnit. Learn to write test cases, use assertions, test exceptions, and organize your tests effectively. Good tests catch bugs early and give confidence when refactoring!

Basic Test Structure

The unittest module provides the TestCase class that you inherit from. Test methods must start with test_ to be automatically discovered. Use assertion methods like assertEqual, assertTrue, and assertRaises to verify expected behavior.

Output

Click Run to execute your code

Test Method Naming:
- Methods starting with test_ are automatically discovered and run
- Use descriptive names: test_add_positive_numbers, test_divide_by_zero_raises_error
- One test method should test one specific behavior
- Keep tests simple and focused

Common Assertions

The TestCase class provides many assertion methods to verify expected behavior. Use the most specific assertion that fits your test case for clearer error messages.

# Common Assertions in unittest

import unittest

class TestAssertions(unittest.TestCase):
    """Demonstrating various assertion methods."""
    
    def test_assert_equal(self):
        """Test assertEqual for equality."""
        self.assertEqual(2 + 2, 4)
        self.assertEqual("hello", "hello")
    
    def test_assert_not_equal(self):
        """Test assertNotEqual for inequality."""
        self.assertNotEqual(2 + 2, 5)
        self.assertNotEqual("hello", "world")
    
    def test_assert_true_false(self):
        """Test assertTrue and assertFalse."""
        self.assertTrue(2 > 1)
        self.assertTrue(len([1, 2, 3]) > 0)
        self.assertFalse(2 < 1)
        self.assertFalse(not True)
    
    def test_assert_in(self):
        """Test assertIn for membership."""
        self.assertIn(2, [1, 2, 3])
        self.assertIn("a", "apple")
        self.assertNotIn(5, [1, 2, 3])
    
    def test_assert_is_none(self):
        """Test assertIsNone for None values."""
        value = None
        self.assertIsNone(value)
        self.assertIsNotNone("not none")
    
    def test_assert_is_instance(self):
        """Test assertIsInstance for type checking."""
        self.assertIsInstance([1, 2, 3], list)
        self.assertIsInstance("hello", str)
        self.assertIsInstance(42, int)
    
    def test_assert_almost_equal(self):
        """Test assertAlmostEqual for floating point."""
        # Useful for float comparison (handles rounding errors)
        self.assertAlmostEqual(0.1 + 0.2, 0.3, places=7)
        self.assertAlmostEqual(1/3, 0.333333, places=5)

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

Output

Click Run to execute your code

Pro Tip: Use specific assertions like assertEqual instead of assertTrue(x == y). Specific assertions provide better error messages showing the expected and actual values when tests fail!

Testing Exceptions

Use assertRaises to verify that functions raise expected exceptions under certain conditions. This ensures your error handling works correctly.

# Testing Exceptions with assertRaises

import unittest

def divide(x, y):
    """Divide x by y, raise ValueError if y is zero."""
    if y == 0:
        raise ValueError("Cannot divide by zero")
    return x / y

def get_item(items, index):
    """Get item at index, raise IndexError if out of range."""
    if index < 0 or index >= len(items):
        raise IndexError("Index out of range")
    return items[index]

class TestExceptions(unittest.TestCase):
    """Testing that functions raise expected exceptions."""
    
    def test_divide_by_zero_raises_error(self):
        """Test that dividing by zero raises ValueError."""
        with self.assertRaises(ValueError):
            divide(10, 0)
    
    def test_divide_by_zero_message(self):
        """Test exception message."""
        with self.assertRaises(ValueError) as context:
            divide(10, 0)
        
        self.assertIn("Cannot divide by zero", str(context.exception))
    
    def test_divide_normal_no_error(self):
        """Test that normal division doesn't raise error."""
        # This should NOT raise an exception
        result = divide(10, 2)
        self.assertEqual(result, 5.0)
    
    def test_index_error(self):
        """Test that invalid index raises IndexError."""
        items = [1, 2, 3]
        with self.assertRaises(IndexError):
            get_item(items, 5)  # Index out of range
    
    def test_index_error_negative(self):
        """Test negative index raises IndexError."""
        items = [1, 2, 3]
        with self.assertRaises(IndexError):
            get_item(items, -1)  # Negative index not allowed

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

Output

Click Run to execute your code

setUp and tearDown

The setUp method runs before each test method, and tearDown runs after. Use them to initialize test fixtures (common test data) and clean up resources. This keeps test methods focused on testing logic rather than setup code.

# setUp and tearDown Methods

import unittest

class Calculator:
    """Simple calculator class for testing."""
    def __init__(self):
        self.history = []
    
    def add(self, a, b):
        result = a + b
        self.history.append(f"{a} + {b} = {result}")
        return result
    
    def clear_history(self):
        self.history = []

class TestCalculator(unittest.TestCase):
    """Tests using setUp and tearDown."""
    
    def setUp(self):
        """Set up test fixtures before each test method."""
        # This runs BEFORE each test method
        self.calc = Calculator()
        print("setUp: Creating new Calculator instance")
    
    def tearDown(self):
        """Clean up after each test method."""
        # This runs AFTER each test method
        self.calc.clear_history()
        print("tearDown: Clearing calculator history")
    
    def test_add_positive(self):
        """Test addition with positive numbers."""
        result = self.calc.add(2, 3)
        self.assertEqual(result, 5)
        self.assertEqual(len(self.calc.history), 1)
    
    def test_add_negative(self):
        """Test addition with negative numbers."""
        # Each test gets a fresh Calculator instance from setUp
        result = self.calc.add(-2, -3)
        self.assertEqual(result, -5)
        # History is fresh for this test
        self.assertEqual(len(self.calc.history), 1)
    
    def test_add_zero(self):
        """Test addition with zero."""
        result = self.calc.add(5, 0)
        self.assertEqual(result, 5)

# setUpClass and tearDownClass (run once for the class)
class TestDatabase(unittest.TestCase):
    """Example using class-level setup."""
    
    @classmethod
    def setUpClass(cls):
        """Run once before all tests in this class."""
        print("setUpClass: Connecting to database")
        cls.db_connection = "connected"  # Simulated connection
    
    @classmethod
    def tearDownClass(cls):
        """Run once after all tests in this class."""
        print("tearDownClass: Closing database connection")
        cls.db_connection = None
    
    def test_query1(self):
        """First test."""
        self.assertEqual(self.db_connection, "connected")
    
    def test_query2(self):
        """Second test."""
        self.assertEqual(self.db_connection, "connected")

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

Output

Click Run to execute your code

Important: Tests should be independent - each test should be able to run alone and in any order. Don't rely on test execution order or shared state between tests. Use setUp to create fresh test data for each test!

Common Mistakes

1. Forgetting 'test_' prefix on test methods

# Wrong - won't be discovered by unittest
class TestMath(unittest.TestCase):
    def check_add(self):  # No 'test_' prefix!
        self.assertEqual(add(2, 3), 5)

# Correct - method starts with 'test_'
class TestMath(unittest.TestCase):
    def test_add(self):  # Correct prefix
        self.assertEqual(add(2, 3), 5)

2. Testing multiple things in one test

# Wrong - multiple assertions for different behaviors
def test_math_operations(self):
    self.assertEqual(add(2, 3), 5)
    self.assertEqual(subtract(5, 2), 3)
    self.assertEqual(multiply(4, 3), 12)
    # If first fails, you don't know if others work

# Correct - one test per behavior
def test_add(self):
    self.assertEqual(add(2, 3), 5)

def test_subtract(self):
    self.assertEqual(subtract(5, 2), 3)

def test_multiply(self):
    self.assertEqual(multiply(4, 3), 12)

3. Not testing edge cases and error conditions

# Wrong - only testing happy path
def test_divide(self):
    self.assertEqual(divide(10, 2), 5)

# Correct - test normal case AND edge cases
def test_divide_normal(self):
    self.assertEqual(divide(10, 2), 5)

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

def test_divide_negative(self):
    self.assertEqual(divide(-10, 2), -5)

4. Tests that depend on execution order

# Wrong - tests depend on each other
class TestCounter(unittest.TestCase):
    counter = 0  # Class variable - shared state!
    
    def test_increment_first(self):
        TestCounter.counter += 1
        self.assertEqual(TestCounter.counter, 1)
    
    def test_increment_second(self):
        TestCounter.counter += 1
        self.assertEqual(TestCounter.counter, 2)  # Fails if run alone!

# Correct - each test is independent
class TestCounter(unittest.TestCase):
    def setUp(self):
        self.counter = 0  # Fresh instance variable per test
    
    def test_increment(self):
        self.counter += 1
        self.assertEqual(self.counter, 1)

Exercise: Write Comprehensive Tests

Task: Write a complete test suite for a Calculator class that has methods for basic math operations. Test both normal cases and edge cases.

Requirements:

Create a TestCalculator class inheriting from unittest.TestCase
Use setUp to create a Calculator instance
Test add method: positive numbers, negative numbers, zero
Test divide method: normal division and division by zero (should raise ValueError)
Test multiply method: normal case, with zero, negative numbers
Run the tests and verify they all pass

Output

Click Run to execute your code

Show Solution

import unittest

class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def multiply(self, a, b):
        return a * b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b


class TestCalculator(unittest.TestCase):
    def setUp(self):
        """Set up test fixtures before each test method."""
        self.calc = Calculator()
    
    def test_add_positive(self):
        self.assertEqual(self.calc.add(2, 3), 5)
    
    def test_add_negative(self):
        self.assertEqual(self.calc.add(-2, -3), -5)
    
    def test_add_zero(self):
        self.assertEqual(self.calc.add(5, 0), 5)
    
    def test_divide_normal(self):
        self.assertEqual(self.calc.divide(10, 2), 5.0)
    
    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            self.calc.divide(10, 0)
    
    def test_multiply_normal(self):
        self.assertEqual(self.calc.multiply(3, 4), 12)
    
    def test_multiply_with_zero(self):
        self.assertEqual(self.calc.multiply(5, 0), 0)
    
    def test_multiply_negative(self):
        self.assertEqual(self.calc.multiply(-2, 3), -6)


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

Summary

unittest Module: Python's built-in testing framework, inspired by JUnit
TestCase: Inherit from unittest.TestCase to create test classes
Test Methods: Methods starting with test_ are automatically discovered and run
Assertions: Use assertEqual, assertTrue, assertRaises, etc. for verification
setUp/tearDown: Run before/after each test method for fixture setup and cleanup
Testing Exceptions: Use assertRaises to verify functions raise expected exceptions
Test Independence: Tests should be independent and runnable in any order
Best Practices: One test per behavior, test edge cases, use descriptive names, keep tests simple

What's Next?

Unit testing ensures your code works correctly! Next, we'll explore logging, which helps you track application behavior and debug issues in production. The logging module is much more powerful than print() statements and is essential for professional Python applications!

Previous Virtual Envs

Next Logging

Basic Test Structure

Common Assertions

Testing Exceptions

setUp and tearDown

Common Mistakes

1. Forgetting 'test_' prefix on test methods

2. Testing multiple things in one test

3. Not testing edge cases and error conditions

4. Tests that depend on execution order

Exercise: Write Comprehensive Tests

Summary

What's Next?

Enjoying these tutorials?