Wie generieren Sie dynamische (parametrisierte) Unit-Tests in Python?

Ich habe eine Art Testdaten und möchte für jeden Artikel einen Komponententest erstellen. Meine erste Idee war es so zu machen:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequence(unittest.TestCase):
    def testsample(self):
        for name, a,b in l:
            print "test", name
            self.assertEqual(a,b)

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

Der Nachteil dabei ist, dass alle Daten in einem Test verarbeitet werden. Ich möchte einen Test für jeden Artikel im laufenden Betrieb erstellen. Irgendwelche Vorschläge?

Dies wird als "Parametrisierung" bezeichnet.

Es gibt verschiedene Tools, die diesen Ansatz unterstützen. Z.B:

• Dekorateur von pytest
• parametriert

Der resultierende Code sieht folgendermaßen aus:

from parameterized import parameterized

class TestSequence(unittest.TestCase):
    @parameterized.expand([
        ["foo", "a", "a",],
        ["bar", "a", "b"],
        ["lee", "b", "b"],
    ])
    def test_sequence(self, name, a, b):
        self.assertEqual(a,b)

Welches wird die Tests generieren:

test_sequence_0_foo (__main__.TestSequence) ... ok
test_sequence_1_bar (__main__.TestSequence) ... FAIL
test_sequence_2_lee (__main__.TestSequence) ... ok

======================================================================
FAIL: test_sequence_1_bar (__main__.TestSequence)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/site-packages/parameterized/parameterized.py", line 233, in <lambda>
    standalone_func = lambda *a: func(*(a + p.args), **p.kwargs)
  File "x.py", line 12, in test_sequence
    self.assertEqual(a,b)
AssertionError: 'a' != 'b'

Aus historischen Gründen werde ich die ursprüngliche Antwort um 2008 belassen):

Ich benutze so etwas:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequense(unittest.TestCase):
    pass

def test_generator(a, b):
    def test(self):
        self.assertEqual(a,b)
    return test

if __name__ == '__main__':
    for t in l:
        test_name = 'test_%s' % t[0]
        test = test_generator(t[1], t[2])
        setattr(TestSequense, test_name, test)
    unittest.main()

Verwenden von unittest (seit 3.4)

Seit Python 3.4 verfügt das Standardbibliothekspaket unittestüber den subTestKontextmanager.

Siehe die Dokumentation:

• 26.4.7. Unterscheiden von Testiterationen anhand von Untertests
• Untertest

Beispiel:

from unittest import TestCase

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

class TestDemonstrateSubtest(TestCase):
    def test_works_as_expected(self):
        for p1, p2 in param_list:
            with self.subTest():
                self.assertEqual(p1, p2)

Sie können auch eine benutzerdefinierte Nachricht und Parameterwerte angeben, um subTest():

with self.subTest(msg="Checking if p1 equals p2", p1=p1, p2=p2):

Mit der Nase

Die Nase - Test - Framework unterstützt dies .

Beispiel (der folgende Code ist der gesamte Inhalt der Datei, die den Test enthält):

param_list = [('a', 'a'), ('a', 'b'), ('b', 'b')]

def test_generator():
    for params in param_list:
        yield check_em, params[0], params[1]

def check_em(a, b):
    assert a == b

Die Ausgabe des Befehls nosetests:

> nosetests -v
testgen.test_generator('a', 'a') ... ok
testgen.test_generator('a', 'b') ... FAIL
testgen.test_generator('b', 'b') ... ok

======================================================================
FAIL: testgen.test_generator('a', 'b')
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/lib/python2.5/site-packages/nose-0.10.1-py2.5.egg/nose/case.py", line 203, in runTest
    self.test(*self.arg)
  File "testgen.py", line 7, in check_em
    assert a == b
AssertionError

----------------------------------------------------------------------
Ran 3 tests in 0.006s

FAILED (failures=1)

Dies kann elegant mit Metaclasses gelöst werden:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequenceMeta(type):
    def __new__(mcs, name, bases, dict):

        def gen_test(a, b):
            def test(self):
                self.assertEqual(a, b)
            return test

        for tname, a, b in l:
            test_name = "test_%s" % tname
            dict[test_name] = gen_test(a,b)
        return type.__new__(mcs, name, bases, dict)

class TestSequence(unittest.TestCase):
    __metaclass__ = TestSequenceMeta

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

Ab Python 3.4 wurden zu diesem Zweck Untertests für unittest eingeführt. Einzelheiten finden Sie in der Dokumentation . TestCase.subTest ist ein Kontextmanager, mit dem Asserts in einem Test isoliert werden können, sodass ein Fehler mit Parameterinformationen gemeldet wird, die Testausführung jedoch nicht gestoppt wird. Hier ist das Beispiel aus der Dokumentation:

class NumbersTest(unittest.TestCase):

def test_even(self):
    """
    Test that numbers between 0 and 5 are all even.
    """
    for i in range(0, 6):
        with self.subTest(i=i):
            self.assertEqual(i % 2, 0)

Die Ausgabe eines Testlaufs wäre:

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=3)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=5)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Dies ist auch Teil von unittest2 , sodass es für frühere Versionen von Python verfügbar ist.

load_tests ist ein wenig bekannter Mechanismus, der in 2.7 eingeführt wurde, um eine TestSuite dynamisch zu erstellen. Mit ihm können Sie einfach parametrisierte Tests erstellen.

Beispielsweise:

import unittest

class GeneralTestCase(unittest.TestCase):
    def __init__(self, methodName, param1=None, param2=None):
        super(GeneralTestCase, self).__init__(methodName)

        self.param1 = param1
        self.param2 = param2

    def runTest(self):
        pass  # Test that depends on param 1 and 2.


def load_tests(loader, tests, pattern):
    test_cases = unittest.TestSuite()
    for p1, p2 in [(1, 2), (3, 4)]:
        test_cases.addTest(GeneralTestCase('runTest', p1, p2))
    return test_cases

Dieser Code führt alle Testfälle in der TestSuite aus, die von load_tests zurückgegeben werden. Der Erkennungsmechanismus führt keine anderen Tests automatisch aus.

Alternativ können Sie auch die Vererbung verwenden, wie in diesem Ticket gezeigt: http://bugs.python.org/msg151444

Dies kann mit pytest erfolgen . Schreiben Sie einfach die Datei test_me.pymit Inhalt:

import pytest

@pytest.mark.parametrize('name, left, right', [['foo', 'a', 'a'],
                                               ['bar', 'a', 'b'],
                                               ['baz', 'b', 'b']])
def test_me(name, left, right):
    assert left == right, name

Und führen Sie Ihren Test mit Befehl aus py.test --tb=short test_me.py. Dann sieht die Ausgabe folgendermaßen aus:

=========================== test session starts ============================
platform darwin -- Python 2.7.6 -- py-1.4.23 -- pytest-2.6.1
collected 3 items

test_me.py .F.

================================= FAILURES =================================
_____________________________ test_me[bar-a-b] _____________________________
test_me.py:8: in test_me
    assert left == right, name
E   AssertionError: bar
==================== 1 failed, 2 passed in 0.01 seconds ====================

Es ist einfach!. Auch pytest hat mehr Funktionen wie fixtures, mark, assert, etc ...

Verwenden Sie die ddt- Bibliothek. Es werden einfache Dekoratoren für die Testmethoden hinzugefügt:

import unittest
from ddt import ddt, data
from mycode import larger_than_two

@ddt
class FooTestCase(unittest.TestCase):

    @data(3, 4, 12, 23)
    def test_larger_than_two(self, value):
        self.assertTrue(larger_than_two(value))

    @data(1, -3, 2, 0)
    def test_not_larger_than_two(self, value):
        self.assertFalse(larger_than_two(value))

Diese Bibliothek kann mit installiert werden pip. Es ist nicht erforderlich noseund funktioniert hervorragend mit dem Standardbibliotheksmodul unittest.

Sie würden von der TestScenarios- Bibliothek profitieren .

testscenarios bietet eine saubere Abhängigkeitsinjektion für Python-Tests im unittest-Stil. Dies kann für Schnittstellentests (Testen vieler Implementierungen über eine einzige Testsuite) oder für die klassische Abhängigkeitsinjektion (Bereitstellen von Tests mit Abhängigkeiten außerhalb des Testcodes selbst verwendet werden, um ein einfaches Testen in verschiedenen Situationen zu ermöglichen).

Es gibt auch eine Hypothese, die Fuzz- oder eigenschaftsbasierte Tests hinzufügt: https://pypi.python.org/pypi/hypothesis

Dies ist eine sehr leistungsfähige Testmethode.

Sie können das Nose-Ittr- Plugin ( pip install nose-ittr) verwenden.

Die Integration in vorhandene Tests ist sehr einfach. Es sind nur minimale Änderungen (falls vorhanden) erforderlich. Es unterstützt auch das Nasen- Multiprocessing-Plugin.

Nicht, dass Sie auch eine Anpassungsfunktion setuppro Test haben können.

@ittr(number=[1, 2, 3, 4])   
def test_even(self):   
    assert_equal(self.number % 2, 0)

Es ist auch möglich, nosetestParameter wie mit ihrem eingebauten Plugin zu übergeben attrib. Auf diese Weise können Sie nur einen bestimmten Test mit bestimmten Parametern ausführen:

nosetest -a number=2

Ich benutze Metaklassen und Dekorateure, um Tests zu generieren. Sie können meine Implementierung python_wrap_cases überprüfen . Diese Bibliothek benötigt keine Test-Frameworks.

Ihr Beispiel:

import unittest
from python_wrap_cases import wrap_case


@wrap_case
class TestSequence(unittest.TestCase):

    @wrap_case("foo", "a", "a")
    @wrap_case("bar", "a", "b")
    @wrap_case("lee", "b", "b")
    def testsample(self, name, a, b):
        print "test", name
        self.assertEqual(a, b)

Konsolenausgabe:

testsample_u'bar'_u'a'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test bar
FAIL
testsample_u'foo'_u'a'_u'a' (tests.example.test_stackoverflow.TestSequence) ... test foo
ok
testsample_u'lee'_u'b'_u'b' (tests.example.test_stackoverflow.TestSequence) ... test lee
ok

Sie können auch Generatoren verwenden . Beispielsweise generiert dieser Code alle möglichen Kombinationen von Tests mit Argumenten a__listundb__list

import unittest
from python_wrap_cases import wrap_case


@wrap_case
class TestSequence(unittest.TestCase):

    @wrap_case(a__list=["a", "b"], b__list=["a", "b"])
    def testsample(self, a, b):
        self.assertEqual(a, b)

Konsolenausgabe:

testsample_a(u'a')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... ok
testsample_a(u'a')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'a') (tests.example.test_stackoverflow.TestSequence) ... FAIL
testsample_a(u'b')_b(u'b') (tests.example.test_stackoverflow.TestSequence) ... ok

Ich bin neulich auf ParamUnittest gestoßen, als ich mir den Quellcode für Radon angesehen habe ( Beispiel für die Verwendung im Github-Repo ). Es sollte mit anderen Frameworks funktionieren, die TestCase erweitern (wie Nose).

Hier ist ein Beispiel:

import unittest
import paramunittest


@paramunittest.parametrized(
    ('1', '2'),
    #(4, 3),    <---- uncomment to have a failing test
    ('2', '3'),
    (('4', ), {'b': '5'}),
    ((), {'a': 5, 'b': 6}),
    {'a': 5, 'b': 6},
)
class TestBar(TestCase):
    def setParameters(self, a, b):
        self.a = a
        self.b = b

    def testLess(self):
        self.assertLess(self.a, self.b)

import unittest

def generator(test_class, a, b):
    def test(self):
        self.assertEqual(a, b)
    return test

def add_test_methods(test_class):
    #First element of list is variable "a", then variable "b", then name of test case that will be used as suffix.
    test_list = [[2,3, 'one'], [5,5, 'two'], [0,0, 'three']]
    for case in test_list:
        test = generator(test_class, case[0], case[1])
        setattr(test_class, "test_%s" % case[2], test)


class TestAuto(unittest.TestCase):
    def setUp(self):
        print 'Setup'
        pass

    def tearDown(self):
        print 'TearDown'
        pass

_add_test_methods(TestAuto)  # It's better to start with underscore so it is not detected as a test itself

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

ERGEBNIS:

>>> 
Setup
FTearDown
Setup
TearDown
.Setup
TearDown
.
======================================================================
FAIL: test_one (__main__.TestAuto)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/inchowar/Desktop/PyTrash/test_auto_3.py", line 5, in test
    self.assertEqual(a, b)
AssertionError: 2 != 3

----------------------------------------------------------------------
Ran 3 tests in 0.019s

FAILED (failures=1)

Verwenden Sie einfach Metaklassen, wie hier gezeigt;

class DocTestMeta(type):
    """
    Test functions are generated in metaclass due to the way some
    test loaders work. For example, setupClass() won't get called
    unless there are other existing test methods, and will also
    prevent unit test loader logic being called before the test
    methods have been defined.
    """
    def __init__(self, name, bases, attrs):
        super(DocTestMeta, self).__init__(name, bases, attrs)

    def __new__(cls, name, bases, attrs):
        def func(self):
            """Inner test method goes here"""
            self.assertTrue(1)

        func.__name__ = 'test_sample'
        attrs[func.__name__] = func
        return super(DocTestMeta, cls).__new__(cls, name, bases, attrs)

class ExampleTestCase(TestCase):
    """Our example test case, with no methods defined"""
    __metaclass__ = DocTestMeta

Ausgabe:

test_sample (ExampleTestCase) ... OK

Sie können TestSuitebenutzerdefinierte TestCaseKlassen verwenden.

import unittest

class CustomTest(unittest.TestCase):
    def __init__(self, name, a, b):
        super().__init__()
        self.name = name
        self.a = a
        self.b = b

    def runTest(self):
        print("test", self.name)
        self.assertEqual(self.a, self.b)

if __name__ == '__main__':
    suite = unittest.TestSuite()
    suite.addTest(CustomTest("Foo", 1337, 1337))
    suite.addTest(CustomTest("Bar", 0xDEAD, 0xC0DE))
    unittest.TextTestRunner().run(suite)

Ich habe festgestellt, dass dies für meine Zwecke gut funktioniert, insbesondere wenn ich Tests generieren muss, die geringfügig unterschiedliche Prozesse für eine Datensammlung ausführen.

import unittest

def rename(newName):
    def renamingFunc(func):
        func.__name__ == newName
        return func
    return renamingFunc

class TestGenerator(unittest.TestCase):

    TEST_DATA = {}

    @classmethod
    def generateTests(cls):
        for dataName, dataValue in TestGenerator.TEST_DATA:
            for func in cls.getTests(dataName, dataValue):
                setattr(cls, "test_{:s}_{:s}".format(func.__name__, dataName), func)

    @classmethod
    def getTests(cls):
        raise(NotImplementedError("This must be implemented"))

class TestCluster(TestGenerator):

    TEST_CASES = []

    @staticmethod
    def getTests(dataName, dataValue):

        def makeTest(case):

            @rename("{:s}".format(case["name"]))
            def test(self):
                # Do things with self, case, data
                pass

            return test

        return [makeTest(c) for c in TestCluster.TEST_CASES]

TestCluster.generateTests()

Die TestGeneratorKlasse kann verwendet werden, um verschiedene Sätze von Testfällen wie zu erzeugen TestCluster.

TestClusterkann als Implementierung der TestGeneratorSchnittstelle betrachtet werden.

Diese Lösung funktioniert mit unittestund nosefür Python 2 und Python 3:

#!/usr/bin/env python
import unittest

def make_function(description, a, b):
    def ghost(self):
        self.assertEqual(a, b, description)
    print(description)
    ghost.__name__ = 'test_{0}'.format(description)
    return ghost


class TestsContainer(unittest.TestCase):
    pass

testsmap = {
    'foo': [1, 1],
    'bar': [1, 2],
    'baz': [5, 5]}

def generator():
    for name, params in testsmap.iteritems():
        test_func = make_function(name, params[0], params[1])
        setattr(TestsContainer, 'test_{0}'.format(name), test_func)

generator()

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

Ich hatte Probleme mit einem ganz bestimmten Stil parametrisierter Tests. Alle unsere Selenium-Tests können lokal ausgeführt werden, sie sollten jedoch auch remote auf mehreren Plattformen in SauceLabs ausgeführt werden können. Grundsätzlich wollte ich eine große Anzahl bereits geschriebener Testfälle mit möglichst wenigen Codeänderungen parametrisieren. Außerdem musste ich in der Lage sein, die Parameter an die setUp-Methode zu übergeben, für die ich anderswo keine Lösungen gesehen habe.

Folgendes habe ich mir ausgedacht:

import inspect
import types

test_platforms = [
    {'browserName': "internet explorer", 'platform': "Windows 7", 'version': "10.0"},
    {'browserName': "internet explorer", 'platform': "Windows 7", 'version': "11.0"},
    {'browserName': "firefox", 'platform': "Linux", 'version': "43.0"},
]


def sauce_labs():
    def wrapper(cls):
        return test_on_platforms(cls)
    return wrapper


def test_on_platforms(base_class):
    for name, function in inspect.getmembers(base_class, inspect.isfunction):
        if name.startswith('test_'):
            for platform in test_platforms:
                new_name = '_'.join(list([name, ''.join(platform['browserName'].title().split()), platform['version']]))
                new_function = types.FunctionType(function.__code__, function.__globals__, new_name,
                                                  function.__defaults__, function.__closure__)
                setattr(new_function, 'platform', platform)
                setattr(base_class, new_name, new_function)
            delattr(base_class, name)

    return base_class

Alles, was ich tun musste, war, jedem normalen alten TestCase einen einfachen Dekorator @sauce_labs () hinzuzufügen, und jetzt, wenn sie ausgeführt werden, werden sie verpackt und neu geschrieben, sodass alle Testmethoden parametrisiert und umbenannt werden. LoginTests.test_login (self) wird ausgeführt als LoginTests.test_login_internet_explorer_10.0 (self), LoginTests.test_login_internet_explorer_11.0 (self) und LoginTests.test_login_firefox_43.0 (self), und jeder hat den Parameter self.platform zu entscheiden Plattform, auf der auch in LoginTests.setUp ausgeführt werden kann, was für meine Aufgabe von entscheidender Bedeutung ist, da dort die Verbindung zu SauceLabs initialisiert wird.

Wie auch immer, ich hoffe, dies könnte jemandem helfen, der eine ähnliche "globale" Parametrisierung seiner Tests durchführen möchte!

Die metaklassenbasierten Antworten funktionieren weiterhin in Python3, aber anstelle des __metaclass__Attributs muss der metaclassParameter wie folgt verwendet werden:

class ExampleTestCase(TestCase,metaclass=DocTestMeta):
    pass

Meta-Programmierung macht Spaß, kann aber auf dem Weg sein. Die meisten Lösungen hier machen es schwierig:

• Starten Sie selektiv einen Test
• Zeigen Sie zurück auf den Code, der dem Namen des Tests gegeben wurde

Mein erster Vorschlag ist also, dem einfachen / expliziten Pfad zu folgen (funktioniert mit jedem Testläufer):

import unittest

class TestSequence(unittest.TestCase):

    def _test_complex_property(self, a, b):
        self.assertEqual(a,b)

    def test_foo(self):
        self._test_complex_property("a", "a")
    def test_bar(self):
        self._test_complex_property("a", "b")
    def test_lee(self):
        self._test_complex_property("b", "b")

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

Da wir uns nicht wiederholen sollten, baut mein zweiter Vorschlag auf der Antwort von @ Javier auf: Umfassen Sie eigenschaftsbasierte Tests. Hypothesenbibliothek:

• ist "unerbittlicher in Bezug auf die Erstellung von Testfällen als wir Menschen"
• wird einfache Zählbeispiele liefern
• funktioniert mit jedem Testläufer

• hat viele weitere interessante Funktionen (Statistiken, zusätzliche Testausgabe, ...)

  Klasse TestSequence (unittest.TestCase):

  @given(st.text(), st.text())
  def test_complex_property(self, a, b):
      self.assertEqual(a,b)

Um Ihre spezifischen Beispiele zu testen, fügen Sie einfach hinzu:

    @example("a", "a")
    @example("a", "b")
    @example("b", "b")

Um nur ein bestimmtes Beispiel auszuführen, können Sie die anderen Beispiele auskommentieren (vorausgesetzt, das Beispiel wird zuerst ausgeführt). Möglicherweise möchten Sie verwenden @given(st.nothing()). Eine andere Möglichkeit besteht darin, den gesamten Block durch Folgendes zu ersetzen:

    @given(st.just("a"), st.just("b"))

Ok, Sie haben keine eindeutigen Testnamen. Aber vielleicht brauchen Sie nur:

• ein beschreibender Name der zu testenden Eigenschaft.
• Welche Eingabe führt zu einem Fehler (fälschendes Beispiel).

Lustigeres Beispiel

Super spät zur Party, aber ich hatte Probleme damit, dass diese funktionieren setUpClass .

Hier ist eine Version von @ Javiers Antwort , die den setUpClassZugriff auf dynamisch zugewiesene Attribute ermöglicht.

import unittest


class GeneralTestCase(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print ''
        print cls.p1
        print cls.p2

    def runTest1(self):
        self.assertTrue((self.p2 - self.p1) == 1)

    def runTest2(self):
        self.assertFalse((self.p2 - self.p1) == 2)


def load_tests(loader, tests, pattern):
    test_cases = unittest.TestSuite()
    for p1, p2 in [(1, 2), (3, 4)]:
        clsname = 'TestCase_{}_{}'.format(p1, p2)
        dct = {
            'p1': p1,
            'p2': p2,
        }
        cls = type(clsname, (GeneralTestCase,), dct)
        test_cases.addTest(cls('runTest1'))
        test_cases.addTest(cls('runTest2'))
    return test_cases

Ausgänge

1
2
..
3
4
..
----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK

Nur um eine andere Lösung in die Mischung zu werfen;)

Dies ist praktisch das gleiche wie parameterizedoben erwähnt, jedoch spezifisch für unittest:

def sub_test(param_list):
    """Decorates a test case to run it as a set of subtests."""

    def decorator(f):

        @functools.wraps(f)
        def wrapped(self):
            for param in param_list:
                with self.subTest(**param):
                    f(self, **param)

        return wrapped

    return decorator

Anwendungsbeispiel:

class TestStuff(unittest.TestCase):
    @sub_test([
        dict(arg1='a', arg2='b'),
        dict(arg1='x', arg2='y'),
    ])
    def test_stuff(self, a, b):
        ...

Neben setattr können wir seit Python 3.2 load_tests verwenden. Bitte lesen Sie den Blog-Beitrag blog.livreuro.com/de/coding/python/how-to-generate-discoverable-unit-tests-in-python-dynamically/

class Test(unittest.TestCase):
    pass

def _test(self, file_name):
    open(file_name, 'r') as f:
        self.assertEqual('test result',f.read())

def _generate_test(file_name):
    def test(self):
        _test(self, file_name)
    return test

def _generate_tests():
    for file in files:
        file_name = os.path.splitext(os.path.basename(file))[0]
        setattr(Test, 'test_%s' % file_name, _generate_test(file))

test_cases = (Test,)

def load_tests(loader, tests, pattern):
    _generate_tests()
    suite = TestSuite()
    for test_class in test_cases:
        tests = loader.loadTestsFromTestCase(test_class)
        suite.addTests(tests)
    return suite

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

Das Folgende ist meine Lösung. Ich finde dies nützlich, wenn: 1. für unittest funktionieren sollte. Testfall und unittest entdecken 2. Eine Reihe von Tests für verschiedene Parametereinstellungen ausführen lassen. 3. Sehr einfach, keine Abhängigkeit von anderen Paketen importieren unittest

    class BaseClass(unittest.TestCase):
        def setUp(self):
            self.param = 2
            self.base = 2

        def test_me(self):
            self.assertGreaterEqual(5, self.param+self.base)

        def test_me_too(self):
            self.assertLessEqual(3, self.param+self.base)



     class Child_One(BaseClass):
        def setUp(self):
            BaseClass.setUp(self)
            self.param = 4


     class Child_Two(BaseClass):
        def setUp(self):
            BaseClass.setUp(self)
            self.param = 1

import unittest

def generator(test_class, a, b,c,d,name):
    def test(self):
        print('Testexecution=',name)
        print('a=',a)
        print('b=',b)
        print('c=',c)
        print('d=',d)

    return test

def add_test_methods(test_class):
    test_list = [[3,3,5,6, 'one'], [5,5,8,9, 'two'], [0,0,5,6, 'three'],[0,0,2,3,'Four']]
    for case in test_list:
        print('case=',case[0], case[1],case[2],case[3],case[4])
        test = generator(test_class, case[0], case[1],case[2],case[3],case[4])
        setattr(test_class, "test_%s" % case[4], test)


class TestAuto(unittest.TestCase):
    def setUp(self):
        print ('Setup')
        pass

    def tearDown(self):
        print ('TearDown')
        pass

add_test_methods(TestAuto)

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