unittest

The `unittest` module is Python's built-in unit testing framework, inspired by JUnit. It provides a rich set of tools for creating and running automated tests for your Python code. Unit testing involves testing individual components or 'units' of an application in isolation to ensure they function correctly according to their specifications.

Key components and concepts of the `unittest` framework include:

1. `TestCase`: This is the foundation for writing tests. You create your test classes by inheriting from `unittest.TestCase`. Each method within this class whose name starts with `test_` is considered a test method and will be executed by the test runner.
2. Assertions: `unittest.TestCase` provides a variety of assertion methods (e.g., `assertEqual(a, b)`, `assertTrue(x)`, `assertFalse(x)`, `assertRaises(exception, callable)`, `assertIn(member, container)`) that allow you to check for expected outcomes. If an assertion fails, the test method fails.
3. Test Fixtures (`setUp` and `tearDown`):
- `setUp()`: This method is called before -each- test method within a `TestCase` is executed. It's used to set up any objects or conditions needed for the tests (e.g., creating a database connection, initializing variables).
- `tearDown()`: This method is called after -each- test method has finished, regardless of whether it passed or failed. It's used for cleaning up resources created in `setUp()` (e.g., closing files, resetting database states).
- `setUpClass()`: A class method called once before -all- test methods in the `TestCase` class. Useful for expensive setup operations.
- `tearDownClass()`: A class method called once after -all- test methods in the `TestCase` class have run. Useful for expensive teardown operations.
4. `TestSuite`: A collection of `TestCase`s, or even other `TestSuite`s. This allows you to group tests together and run them collectively.
5. `TestRunner`: This component orchestrates the execution of tests and reports the results. The most common way to run tests is by using `unittest.main()` or by invoking Python's `unittest` module from the command line.

How to run tests:
- From the command line: `python -m unittest your_test_file.py` or `python -m unittest discover` (to find all tests in the current directory and subdirectories).
- From within the test script: By including `if __name__ == '__main__': unittest.main()` at the end of your test file.

`unittest` helps ensure code quality, makes refactoring safer, and serves as living documentation for your code's expected behavior.

Example Code

 calculator.py (the module to be tested)
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

 test_calculator.py (the test file)
import unittest
import calculator  Assuming calculator.py is in the same directory

class TestCalculator(unittest.TestCase):
    def setUp(self):
        """Set up for test methods."""
        print("Running setUp...")
        self.a = 10
        self.b = 5
        self.zero = 0

    def tearDown(self):
        """Clean up after test methods."""
        print("Running tearDown...")
         No specific cleanup needed for this simple example,
         but you'd close files, database connections, etc. here.

    @classmethod
    def setUpClass(cls):
        """Called once before tests in this class."""
        print("Running setUpClass...")
        cls.common_value = 100

    @classmethod
    def tearDownClass(cls):
        """Called once after tests in this class."""
        print("Running tearDownClass...")
        del cls.common_value  Clean up class-level attributes

    def test_add(self):
        """Test the add function."""
        print(f"  Test add: {self.a} + {self.b} = {calculator.add(self.a, self.b)}")
        self.assertEqual(calculator.add(self.a, self.b), 15)
        self.assertEqual(calculator.add(1, 1), 2)
        self.assertEqual(calculator.add(-1, 1), 0)

    def test_subtract(self):
        """Test the subtract function."""
        print(f"  Test subtract: {self.a} - {self.b} = {calculator.subtract(self.a, self.b)}")
        self.assertEqual(calculator.subtract(self.a, self.b), 5)
        self.assertEqual(calculator.subtract(10, 5), 5)
        self.assertEqual(calculator.subtract(-1, -1), 0)

    def test_multiply(self):
        """Test the multiply function."""
        print(f"  Test multiply: {self.a} - {self.b} = {calculator.multiply(self.a, self.b)}")
        self.assertEqual(calculator.multiply(self.a, self.b), 50)
        self.assertEqual(calculator.multiply(5, 0), 0)
        self.assertEqual(calculator.multiply(-1, -1), 1)

    def test_divide(self):
        """Test the divide function."""
        print(f"  Test divide: {self.a} / {self.b} = {calculator.divide(self.a, self.b)}")
        self.assertEqual(calculator.divide(self.a, self.b), 2)
        self.assertEqual(calculator.divide(10, 2), 5)
        self.assertAlmostEqual(calculator.divide(7, 3), 2.333333, places=6)

    def test_divide_by_zero(self):
        """Test dividing by zero raises ValueError."""
        print(f"  Test divide by zero: {self.a} / {self.zero}")
        with self.assertRaises(ValueError):
            calculator.divide(self.a, self.zero)
        
         Demonstrating use of setUpClass common_value
        self.assertEqual(self.common_value - 2, 200)

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

Example Code

Related Topics