Standard Test Framework + unittest

Python's standard library includes a powerful unit testing framework called `unittest`. This framework is part of what's often referred to as a 'Standard Test Framework' because it ships with the language, providing a common and readily available tool for testing Python code. `unittest` is inspired by JUnit and follows the xUnit style of testing, offering a structured approach to writing automated tests.

Key components of `unittest`:

1. Test Cases: These are individual units of testable functionality. In `unittest`, you create a test case by defining a class that inherits from `unittest.TestCase`. Each method within this class whose name starts with `test_` is considered a test method.
2. Assertions: Within test methods, you use assertion methods provided by `unittest.TestCase` to check for expected outcomes. Examples include `assertEqual()`, `assertTrue()`, `assertRaises()`, `assertIn()`, etc. If an assertion fails, the test method fails.
3. Test Fixtures: These are methods used to set up the 'state' needed for tests and tear it down afterward. `setUp()` is called before each test method in a test case, and `tearDown()` is called after each test method. `setUpClass()` and `tearDownClass()` can be used to set up/tear down resources once for all tests in a test case.
4. Test Suites: These are collections of test cases and/or other test suites, used to aggregate tests that should be run together. While `unittest` provides `TestSuite` classes, often `unittest.main()` is sufficient for running all tests found in a module or directory.
5. Test Runner: This is the component that orchestrates the execution of tests and reports the results. `unittest.main()` provides a simple command-line test runner.

Using `unittest` helps ensure code quality, facilitates safe refactoring, serves as executable documentation for the code's expected behavior, and helps detect regressions (bugs that reappear after being fixed or new bugs introduced by changes). It's a fundamental tool for any Python developer practicing good software engineering principles.

Example Code

 First, create a file named 'calculator.py' with the following content:
 -------------------- calculator.py --------------------
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a - b

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

 Next, create a file named 'test_calculator.py' for testing 'calculator.py':
 -------------------- test_calculator.py --------------------
import unittest
import calculator

class TestCalculator(unittest.TestCase):

    def setUp(self):
        """Set up any resources needed for each test."""
         In this simple case, direct module access is fine, or you could instantiate a class if calculator.py had one
        self.calc_instance = calculator
        print(f"\nSetting up for a test: {self._testMethodName}...")

    def tearDown(self):
        """Clean up resources after each test."""
        self.calc_instance = None
        print(f"Tearing down after a test: {self._testMethodName}.")

    def test_add(self):
        """Test the add function."""
        self.assertEqual(self.calc_instance.add(10, 5), 15)
        self.assertEqual(self.calc_instance.add(-1, 1), 0)
        self.assertEqual(self.calc_instance.add(-1, -1), -2)
        self.assertNotEqual(self.calc_instance.add(2, 2), 5)  Example of assertNotEqual

    def test_subtract(self):
        """Test the subtract function."""
        self.assertEqual(self.calc_instance.subtract(10, 5), 5)
        self.assertEqual(self.calc_instance.subtract(-1, 1), -2)
        self.assertEqual(self.calc_instance.subtract(-1, -1), 0)

    def test_multiply(self):
        """Test the multiply function."""
        self.assertEqual(self.calc_instance.multiply(10, 5), 50)
        self.assertEqual(self.calc_instance.multiply(-1, 1), -1)
        self.assertEqual(self.calc_instance.multiply(-1, -1), 1)
        self.assertEqual(self.calc_instance.multiply(0, 5), 0)

    def test_divide(self):
        """Test the divide function."""
        self.assertEqual(self.calc_instance.divide(10, 5), 2)
         Use assertAlmostEqual for floating point comparisons due to precision issues
        self.assertAlmostEqual(self.calc_instance.divide(10, 3), 3.3333333333333335)
        self.assertEqual(self.calc_instance.divide(-10, 5), -2)
        
    def test_divide_by_zero_error(self):
        """Test that dividing by zero raises a ValueError."""
         Use assertRaises to check if a specific exception is raised
        with self.assertRaises(ValueError):
            self.calc_instance.divide(10, 0)

 This block allows running the tests directly from the command line.
 To run: navigate to the directory containing both files in your terminal
 then execute: python -m unittest test_calculator.py
 or simply: python test_calculator.py (if this file is the entry point)
if __name__ == '__main__':
    unittest.main(verbosity=2)  verbosity=2 shows more detailed output

Standard Test Framework + unittest

Example Code

Related Topics