Detecting Dynamically Created unittest Testcases When Using python -m unittest
Learn how to ensure Python's unittest test discovery detects dynamically added test methods and how to structure such tests for compatibility with standard test runners.
---
This video is based on the question https://stackoverflow.com/q/79467238/ asked by the user 'Егор' ( https://stackoverflow.com/u/27478195/ ) and on the answer https://stackoverflow.com/a/79467426/ provided by the user 'J_H' ( https://stackoverflow.com/u/8431111/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.
Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Detecting testcases created dynamically while running unittest module
Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.
If anything seems off to you, please feel free to drop me a comment under this video.
---
Introduction
When creating test cases dynamically in Python's unittest framework, tests often run fine with unittest.main(). However, using the command-line discovery tool python -m unittest typically fails to detect these dynamically generated tests.
Why? The unittest test discovery scans for methods named with the test* pattern before any dynamic additions happen at runtime, so dynamically generated test methods may be missing during discovery.
The Problem Explained
Here's a common pattern to add tests dynamically:
[[See Video to Reveal this Text or Code Snippet]]
This works with unittest.main(), but running python -m unittest test_module fails to find any tests since discovery happens before the loop assigning methods runs.
Why Does python -m unittest Miss Them?
Test discovery is static. It looks at classes and their methods as defined in the source code, prior to running any module-level code that modifies those classes.
Dynamically added test methods using setattr happen at runtime, after discovery.
Solutions and Best Practices
1. Force Test Generation in a Standard Test Method
One approach is to have at least one test method that calls the generator methods explicitly:
[[See Video to Reveal this Text or Code Snippet]]
But this is more a workaround and complicates test reporting.
2. Generate Static Test Code
The recommended modern approach is:
Write scripts that generate static test source files.
The generated .py files contain all your tests as regular methods.
Place these files under your test directory.
Then use python -m unittest or other discovery tools normally.
This transforms dynamic tests into static, discoverable tests.
3. Use Parameterized Testing Libraries
For dynamic test scenarios, consider libraries like:
parameterized
pytest
These tools provide native support for generating multiple test cases from parameters, fully compatible with test discovery.
Summary
python -m unittest discovery won’t detect dynamically added test methods because discovery inspects classes before runtime modifications.
To work with standard discovery, either:
Generate static test files,
Use parameterized testing support,
Or restructure tests to fit unittest's static discovery model.
Adapting your test generation approach ensures compatibility with advanced tooling like Allure and standard test runners.
On this page of the site you can watch the video online Detecting Dynamically Created unittest Testcases When Using python -m unittest with a duration of hours minute second in good quality, which was uploaded by the user vlogommentary 19 December 2025, share the link with friends and acquaintances, this video has already been watched No times on youtube and it was liked by like viewers. Enjoy your viewing!
