如何在Python（2.7）单元测试中参数化setUpClass（）

Question

I am currently implementing a kind of table with interpolation between the values, boundary handling, etc. and want to write unit tests for it.

There is quite a set of possible scenarios eg the tables could have only one/multiple row(s)/column(s) and different boundary conditions. The tables in all of these scenarios should all pass the same set of unittests.

For now I am writing a base class for one of the cases and derive from it overriding the setUpClass() method. This is however tedious for testing all combinations.

Is there to generate the TestCase classes dynamically run them with different parameters.

When googling for the problem the best thing I found was overloading load_tests() and add all test methods one by one (which means setting up the objects prior to running each test method instead of once per scenario).

Answer 1

Thanks to the hint from @jonrsharpe I managed to do it.

My solution is to create the classes dynamically and then add them to the TestSuite using load_tests :

def create_test_case(testcase_name, scenario_data):
    class ScenarioTestCase(BaseTestCase):
        @classmethod
        def setUpClass(cls):
            cls.fillClassVariables(scenario_data)
    return_class = ScenarioTestCase
    return_class.__name__ = testcase_name #for separating the results
    return return_class


def load_tests(loader, tests, pattern):
    list_scenario_names = [...]
    list_scenario_data = [...]

    loader = unittest.TestLoader()
    tests = TestSuite()
    for scenario_name, scenario_data in zip(list_scenario_names, list_scenario_data):
        tests.addTests(loader.loadTestsFromTestCase(
            create_test_case(scenario_name, scenario_data)))
    return tests

This way the TestCases are created dynamically with different parameters and listed separately in PyCharm's Test Runner Tab.

Answer 2

Though this has an accepted answer, I want to document how to do this with subclassing, since it took me a long time to find the details of such a solution. In my case, the goal is for a TestCase class with several methods to have a class fixture (setting up files on the filesystem to test a cli tool), and vary this slightly in the parametrization.

# Inherit from object to not run this abstract class
class TemporaryFolderClassSetup(object):

    @classmethod
    def setUpClass(cls):
        try:
            cls._root = tempfile.mkdtemp()
            # .. create some files here ...
            # allow subclasses to manipulate file tre
            cls.prepare_directory(cls._root)
        except Exception as e:
            cls.tearDownClass()
            raise

    @classmethod
    def tearDownClass(cls):
        shutil.rmtree(cls._root)

    @classmethod
    def prepare_directory(cls, root):
        pass

    # test methods that will run in each subclass
    def testX():
        pass

# scenariotest, must inherit from superclass first, before unittest.TestCase)
class ScenarioTests(TemporaryFolderClassSetup, unittest.TestCase):

    # ... called by parent class
    @classmethod
    def prepare_directory(cls, root):
        pass

    # test only for this scenario
    def testY(self):
        pass