With those concepts in mind, let's see how we can actually use the unittest module in practice. For this example, we'll use test-driven development to write a simple text-analysis function. This function will take a file name as its only parameter. It will then read
that file and calculate:
- The number of lines in the file
- The number of characters in the file
TDD is an iterative development process, so rather than work at the REPL we'll put the code for our tests in a file named text_analyzer.py. To start with, we'll create our first test with just enough supporting code to actually run it:
# text_analyzer.py
import unittest
class TextAnalysisTests(unittest.TestCase):
"""Tests for the ``analyze_text()`` function."""
def test_function_runs(self):
"""Basic smoke test: does the function run."""
analyze_text()
if __name__ == '__main__':
unittest.main()
Ths first thing we do is import the unittest module. We then create our test case by defining a class – TextAnalysisTests – which derives from unittest.TestCase. This is how you create test cases with the unittest framework.
To define individual test methods in a test case, you simple create methods on your TestCase subclasses that start with test_. The unittest framework automatically discovers methods like this at execution time, so you don't need to explicitly register your test methods.
In this case we define the simplest possible test: We check whether the analyze_text() function runs at all! Our test doesn't make any explicit checks, but rather it relies on the fact that a test method will fail if it throws any exceptions. In this case, our test will fail if analyze_text() isn't defined.
Finally, we define the idiomatic "main" block which calls unittest.main() when this module is executed. The unittest.main() function will search for all TestCase subclasses in a module and execute all of their test methods.