Core Components of unittest

The unittest module is Python’s built-in unit testing framework, inspired by JUnit. It revolevs around four foundational abstractions:

• Test Case: A subclass of unittest.TestCase. Each method prefixed with test_ represents a individual test. The class may define setUp() and tearDown() for per-test setup and cleanup, and setUpClass()/tearDownClass() (with @classmethod) for one-time class-level initialization and finalization.

• Test Suite: A container for aggregating multiple test cases or nested suites via unittest.TestSuite. Suites enable logical grouping and selective execution.

• Test Loader: Manages discovery and instantiation of test cases. Common methods include loadTestsFromModule(), loadTestsFromTestCase(), and discover() for filesystem-based scanning.

• Test Runner: Executes suites or cases and reports outcomes. unittest.TextTestRunner is the default console runner; verbosity controls output detail.

Minimal Working Example

import unittest

class CalculatorTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("Initializing shared test context")

    def setUp(self):
        self.calculator = lambda x, y: x + y  # Minimal fixture

    def test_addition_returns_correct_sum(self):
        result = self.calculator(2, 3)
        self.assertEqual(result, 5)

    def test_addition_handles_zero(self):
        result = self.calculator(0, 7)
        self.assertEqual(result, 7)

    def tearDown(self):
        del self.calculator

    @classmethod
    def tearDownClass(cls):
        print("Releasing shared resources")

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

Key Assertion Methods

Custom Test Discovery and Execution

Instead of relying solely on unittest.main(), you can programmatically collect tests from a directory:

import os
import unittest
import importlib

def collect_test_modules(test_dir):
    modules = []
    for root, _, files in os.walk(test_dir):
        for filename in files:
            if filename.startswith('test') and filename.endswith('.py'):
                full_path = os.path.join(root, filename)
                rel_path = os.path.relpath(full_path, start=os.getcwd())
                module_name = rel_path.replace(os.sep, '.').rstrip('.py')
                modules.append(module_name)
    return modules

if __name__ == "__main__":
    test_suite = unittest.TestSuite()
    test_dir = os.path.join(os.path.dirname(__file__), 'tests')
    
    for mod_name in collect_test_modules(test_dir):
        try:
            module = importlib.import_module(mod_name)
            test_suite.addTests(unittest.TestLoader().loadTestsFromModule(module))
        except ImportError as e:
            print(f"Failed to load {mod_name}: {e}")
    
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(test_suite)

Simplified Auto-Discovery

For most projects, use TestLoader.discover():

if __name__ == "__main__":
    loader = unittest.TestLoader()
    suite = loader.discover(
        start_dir='tests',
        pattern='test_*.py',
        top_level_dir='.'
    )
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(suite)