How do you generate dynamic (parameterized) unit tests in Python?

python

pytest

unit-tests

parameterized-tests

byNikita Barsukov·Oct 26, 2024

To create parameterized unit tests in Python, use a loop and setattr to inject test methods into a unittest.TestCase subclass. Each data set should generate a test method that asserts expected outcomes, with a dynamically assigned unique name.

import unittest

class ParametrizedTestCase(unittest.TestCase):
    pass

def generate_test(value):
    def test(self):
        self.assertEqual(value, value)
    return test

parameters = ["test_value1", "test_value2", "test_value3"]
for index, param in enumerate(parameters):
    test_name = f"test_{param}"
    test_method = generate_test(param)
    setattr(ParametrizedTestCase, test_name, test_method)

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

This code "magically"😉 creates a test for each item in parameters, expanding your test suite with robust parameterized tests.

Quick wins with Pytest

pytest significantly simplifies the dynamic generation of unit tests through the use of the @pytest.mark.parametrize decorator; it sends multiple sets of variables into your test functions:

import pytest

@pytest.mark.parametrize("input, expected", [
    ("input1", "expected1"),  # when 'input' is so insightful that 'output' becomes 'expected'
    ("input2", "expected2"),  # because aliens would also use 'expected' as output
    ("input3", "expected3")   # amazingly, 'expected' continues to be a universal constant
])
def test_evaluation(input, expected):
    assert some_function(input) == expected

pytest generates a separate test case for each set of parameters. It enhances your test reports’ clarity and eases the debugging process.

Sub-test with Unittest

Python 3.4 introduced the subTest context manager into unittest. It provides a convenient way to iterate through a set of test cases within a single test method:

import unittest

class TestMathOperations(unittest.TestCase):
    def test_multiplication(self):
        for x in range(5):
            with self.subTest(i=x):
                self.assertEqual(x * x, x ** 2)

Using subTest ensures that all test cases are executed even if some fail. The fails are reported with the corresponding parameter information.

The Parameterized Package Advantage

The parameterized package takes the dynamic nature of testing a step further by reducing boilerplate code:

from parameterized import parameterized
import unittest

class TestStringMethods(unittest.TestCase):
    @parameterized.expand([
        ("hello world", 0, 'h'),
        ("hello world", -1, 'd'),
    ])
    def test_indexing(self, string, index, expected):
        self.assertEqual(string[index], expected)

Where every tuple represents a set of parameters for the test method, generating a separate test case with each tuple.

Diving deeper with advanced scenarios

Custom TestSuite creation

If you need a higher level of control over your tests, create a TestSuite using the load_tests protocol. This is particularly useful for complex parameter combinations:

def load_tests(loader, tests, pattern):
    suite = unittest.TestSuite()
    test_data = [("apple", "fruit"), ("broccoli", "vegetable")]
    for param1, param2 in test_data:
        suite.addTest(MyTestCase('test_relation', param1, param2))
    return suite

Maneuvering complex parameters

For complex data structures like dictionaries or objects, ensure your test methods remain readable by breaking them down appropriately:

@pytest.mark.parametrize("data", [
    ({'key1': 'value1'},),
    ({'key2': 'value2'},),
])
def test_complex_data(data):
    assert data_processor(data) == expected_output(data)

Customize each test case with docstrings or named parameters for clarity.

Managing code repetition

Avoid the pitfall of code repetition in your tests. Use setup method and helper functions where possible. The DRY (Don't Repeat Yourself) rule applies here as in application code.

Managing unique test names

When creating test cases dynamically, ensure each test has a unique name. This prevents tests from being overwritten and inadvertently excluded from the test runs.

explain-codes / Python / How do you generate dynamic (parameterized) unit tests in Python?

Linked

Is it possible to break a long line to multiple lines in Python?



What is the use of "assert" in Python?



How to call a shell script from python code?



Simple argparse example wanted: 1 argument, 3 results



Why use def main()?

