Unit testing involves validating the smallest testable components of a software system. In Python, these components are typically individual functions or methods. The objective is to confirm each unit operates as intended.

Advantages of Unit Testing

• Enhanced Code Reliability: Tests identify defects early, ensuring functional correctness.
• Safer Refactoring: A comprehensive test suite allows code modifications with confidence that existing behavior is preserved.
• Reduced Debugging Effort: Issues are detected during development rather than in later integration phases or production.

The unittest Framework in Python

Python's standard library includes the unittest framework, inspired by JUnit, which provides tools for constructing and executing tests.

Writting Tests with unittest

Core Procedure

1. Import the unittest module.
2. Define a test class inheriting from unittest.TestCase.
3. Implement test methods whose names begin with test_.
4. Execute the tests.

Code Example

Consider a module (math_ops.py) with a function to sum two numbers:

# math_ops.py
def sum_values(x, y):
    return x + y

Corresponding unit tests (test_math_ops.py):

# test_math_ops.py
import unittest
from math_ops import sum_values

class TestMathOperations(unittest.TestCase):
    def test_sum_values(self):
        self.assertEqual(sum_values(5, 7), 12)
        self.assertEqual(sum_values(-3, 3), 0)
        self.assertEqual(sum_values(0, -5), -5)

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

Explanation

• class TestMathOperations(unittest.TestCase): creates the test class.
• def test_sum_values(self): defines a single test case.
• self.assertEqual(...) is an assertion method verifying the function's output matches the expected value.

Common Assertion Methods

The unittest.TestCase class offers several assertion methods:

• assertEqual(first, second): Verifies equality of first and second.
• assertNotEqual(first, second): Verifies first and second are not equal.
• assertTrue(expr): Checks that expr is truthy.
• assertFalse(expr): Checks that expr is falsy.
• assertIs(first, second): Checks first and second are the same object.
• assertIsNot(first, second): Checks first and second are not the same object.
• assertIsNone(expr): Checks expr is None.
• assertIsNotNone(expr): Checks expr is not None.
• assertIn(member, container): Checks member is in container.
• assertNotIn(member, container): Checks member is not in container.

Executing Tests

Run tests from the command line:

python -m unittest test_math_ops.py

Or execute the test file directly:

python test_math_ops.py

Alternative Python Testing Libraries

pytest

pytest is a feature-rich, concise framework that simplifies test creation and execution.

• Key Features: Automatic test discovery, plain assert statements, extensive plugin ecosystem, detailed output.
• Example:

  # test_calc.py
  def sum_values(x, y):
      return x + y
  
  def test_sum():
      assert sum_values(2, 3) == 5
      assert sum_values(10, -10) == 0
  

  Run with: pytest

doctest

doctest is part of the standard library and embeds tests within docstrings, ideal for documentation and examples.

• Key Features: Tests written in docstrings, promotes self-documenting code.
• Example:

  # operations.py
  def sum_values(x, y):
      """
      Return the sum of two integers.
  
      >>> sum_values(2, 3)
      5
      >>> sum_values(-1, 1)
      0
      """
      return x + y
  

  Run with: python -m doctest -v operations.py

nose2

nose2 (successor to nose) extends unittest with additional capabilities and plugins.

• Key Features: Plugin-based architecture, test discovery, compatible with unittest test cases.
• Example:

  # test_module.py
  import unittest
  
  def sum_values(x, y):
      return x + y
  
  class TestExample(unittest.TestCase):
      def test_sum(self):
          self.assertEqual(sum_values(1, 1), 2)
  

  Run with: nose2