WAI Forward Developer Blog

Introduction to Unit Testing in Python: A Practical Guide

By: WAI Forward ltd on March 03, 2025

Unit testing is an essential practice in software development, ensuring that individual components of a program work as expected. In Python, unit tests help catch bugs early, improve code reliability, and make maintenance easier.

In this guide, we’ll explore how to implement unit testing in Python using the `unittest` framework.

What is Unit Testing?

Unit testing involves testing individual functions or methods in isolation. The goal is to verify that each unit of the code performs correctly under different conditions.

Why is Unit Testing Important?

Unit testing provides several benefits:

Early Bug Detection: Identifies issues before deployment.
Code Maintainability: Makes refactoring easier without breaking functionality.
Better Collaboration: Helps teams understand expected behaviors.

Setting Up Unit Testing in Python

Python’s built-in `unittest` module provides a simple way to write and execute tests.

Step 1: Create a Function to Test

Let's define a function in a file called math_operations.py:

def add(a, b):
    return a + b

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

Step 2: Write Unit Tests

Create a separate file named test_math_operations.py and write tests using `unittest`:

import unittest
from math_operations import add, divide

class TestMathOperations(unittest.TestCase):

    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)

    def test_divide(self):
        self.assertEqual(divide(10, 2), 5)
        with self.assertRaises(ValueError):
            divide(5, 0)

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

Step 3: Run the Tests

Execute the tests using:

python -m unittest test_math_operations.py

Understanding Assertions in Unit Testing

Assertions check whether expected results match actual outcomes:

assertEqual(a, b): Checks if a == b
assertNotEqual(a, b): Checks if a != b
assertTrue(x): Checks if x is True
assertFalse(x): Checks if x is False
assertRaises(ErrorType, func, *args): Checks if an error is raised

Using `setUp` and `tearDown` Methods

`setUp()` and `tearDown()` allow setup and cleanup before and after each test.

class TestExample(unittest.TestCase):
    
    def setUp(self):
        self.value = 10

    def test_multiplication(self):
        self.assertEqual(self.value * 2, 20)

    def tearDown(self):
        self.value = None

Advanced Unit Testing with `pytest`

`pytest` is a popular alternative to `unittest` that simplifies writing tests.

pip install pytest

Create a test file and use simple assertions:

def test_add():
    assert add(2, 3) == 5

Run tests with:

pytest test_math_operations.py

Best Practices for Unit Testing

Write Tests for Every Function: Ensure all key logic is covered.
Use Meaningful Test Cases: Include edge cases and boundary values.
Automate Testing: Run tests as part of CI/CD pipelines.

FAQs

What is the difference between unit testing and integration testing? Unit testing checks individual functions, while integration testing verifies how different components work together.
Can I mock external dependencies in tests? Yes, use `unittest.mock` to replace dependencies with mock objects.
How often should I run unit tests? Ideally, after every code change or before deployment.
Which is better: `unittest` or `pytest`? `unittest` is built-in, while `pytest` is more flexible and user-friendly.
Do I need unit tests for small scripts? Yes, even small scripts benefit from tests to ensure reliability.

Conclusion

Unit testing is a crucial practice for writing reliable and maintainable code. By using Python’s `unittest` or `pytest`, developers can catch bugs early and ensure software stability.

Start writing unit tests today to improve your coding workflow!

Back to Blog