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.