Master Python Code Coverage with Coverage: Step-by-Step Guide and Examples

1. Code Coverage

Unit‑test code coverage measures the proportion of source code executed by the test suite, calculated as the number of executed statements divided by the total number of statements.

2. Coverage Tool

Coverage is a Python package that reports code‑coverage statistics, supports branch coverage, generates HTML reports, and can be integrated into CI pipelines such as Jenkins.

Install Coverage with pip:

# Install Coverage dependency
pip3 install coverage

Coverage provides two ways to collect data:

Coverage command‑line interface

Coverage Python API

3. Practical Example

First, create a simple function to be tested (save as main.py):

# Tested code
# main.py
def get_level(cource):
    """Return a grade based on the score.
    :param cource: score
    :return: grade string
    """
    if cource >= 90:
        return "优秀"
    elif cource >= 80:
        return "良好"
    elif cource >= 60:
        return "合格"
    elif cource >= 40:
        return "不合格"
    else:
        return "差"

Then write two unit‑test cases using the built‑in unittest framework (save as test_get_level.py):

# Unit tests
# test_get_level.py
import unittest
from main import *

class GetLevel(unittest.TestCase):
    def test_get_level1(self):
        self.assertEquals(get_level(90), "优秀")

    def test_get_level2(self):
        self.assertEquals(get_level(80), "良好")

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

Run the tests; both cases should pass.

4. Generate Coverage Report via CLI

Collect coverage data and produce an HTML report:

# Collect coverage data
coverage run test_get_level.py
# Generate HTML report in the folder "coverage_result"
coverage html -d coverage_result

Open coverage_result/index.html in a browser. The report shows:

statements : total executable lines (excluding blanks and comments)

missing : lines not executed

coverage : percentage of covered statements

Clicking a source file (e.g., test_get_level.py) highlights covered and uncovered lines.

5. Generate Coverage Report via API

Using the Coverage API allows programmatic control:

# exec_api.py
import coverage
import unittest

# Start coverage collection
cov = coverage.coverage()
cov.start()

# Discover and run tests
suite = unittest.defaultTestLoader.discover("./", "test_get_level.py")
unittest.TextTestRunner().run(suite)

# Stop and save results
cov.stop()
cov.save()

# Print report to console
cov.report()
# Generate HTML report in "result_html" directory
cov.html_report(directory='result_html')

6. Conclusion

The example demonstrates how to obtain code‑coverage statistics for a simple Python function using unittest and the Coverage tool. In real projects, this technique is essential for Python, Django, or Flask web applications to ensure test quality and improve product reliability.