Unit Testing in Python: Getting Started with unittest and pytest
Introduction
Writing code is only half the battle—testing it ensures your program works as expected and helps catch bugs early. Unit testing is a fundamental software development practice that involves testing small parts (units) of your code independently.
Python offers powerful testing frameworks like the built-in unittest module and the popular third-party tool pytest. In this guide, you’ll learn how to write and run unit tests with both, helping you improve code quality and reliability.
What is Unit Testing?
Unit testing focuses on verifying that individual pieces of code (functions, classes, methods) behave correctly in isolation. By writing tests for these units, you create a safety net that alerts you when changes break functionality.
Using Python’s Built-in unittest Module
Python comes with the unittest framework pre-installed.
Writing Your First Test Case
Suppose you have a simple function:
def add(a, b):
return a + b
Here’s how to test it with unittest:
import unittest
from your_module import add # Replace with actual module name
class TestAddFunction(unittest.TestCase):
def test_add_positive_numbers(self):
self.assertEqual(add(2, 3), 5)
def test_add_negative_numbers(self):
self.assertEqual(add(-1, -1), -2)
if __name__ == '__main__':
unittest.main()
Run this test file, and unittest will report if the tests pass or fail.
Introduction to pytest
pytest is a popular third-party testing tool that simplifies writing tests and offers advanced features.
Installing pytest
pip install pytest
Writing Tests with pytest
You don’t need to use classes or inherit from test frameworks. Just write test functions:
from your_module import add
def test_add_positive():
assert add(2, 3) == 5
def test_add_negative():
assert add(-1, -1) == -2
Run tests using the command:
pytest
Key Differences Between unittest and pytest
| Feature | unittest |
pytest |
|---|---|---|
| Test style | Class-based | Function-based |
| Setup/teardown | Methods like setUp, tearDown |
Fixtures with decorators |
| Assertions | Specific assert methods | Python’s native assert |
| Plugins | Limited | Extensive plugin ecosystem |
| Ease of use | More boilerplate | Minimal code, more expressive |
Example: Testing a Simple Function
Suppose your function calculates the factorial of a number:
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
unittest version
import unittest
from your_module import factorial
class TestFactorial(unittest.TestCase):
def test_factorial_zero(self):
self.assertEqual(factorial(0), 1)
def test_factorial_positive(self):
self.assertEqual(factorial(5), 120)
if __name__ == '__main__':
unittest.main()
pytest version
from your_module import factorial
def test_factorial_zero():
assert factorial(0) == 1
def test_factorial_positive():
assert factorial(5) == 120
Running Tests and Interpreting Results
-
With
unittest, run your test file directly. -
With
pytest, run thepytestcommand in your terminal.
Both tools will tell you which tests passed or failed and provide helpful output to diagnose issues.
Tips for Effective Testing
-
Write tests for edge cases and normal cases.
-
Use meaningful test names.
-
Test one thing per test function.
-
Use assertions effectively to validate expected results.
-
Consider test coverage tools like
coverage.pyto measure how much code your tests cover.
Conclusion
Unit testing helps ensure your Python code is reliable, maintainable, and bug-free. Whether you choose Python’s built-in unittest or the powerful pytest, adding tests to your workflow is a valuable skill.
Start small—test your utility functions—and gradually expand coverage to larger components.
For more Python insights and practical guides, check out our other posts on Python Projects for Beginners and Publishing Python Packages.
What’s Next?
👉 In Next article, we’ll learn Python List Comprehensions
