Hvordan skaper du dynamiske (parametriseres) enhet tester i python?

stemmer
165

Jeg har en slags test data og ønsker å skape en enhet test for hvert element. Min første idé var å gjøre det på denne måten:

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()

Ulempen med dette er at den håndterer alle data i en test. Jeg ønsker å generere en test for hvert element på fly. Noen forslag?

Publisert på 28/08/2008 klokken 17:49
kilden bruker
På andre språk...                            


23 svar

stemmer
118

jeg bruker noe sånt som dette:

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()

Den parameterizedpakken kan brukes til å automatisere denne prosessen:

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)

Som vil generere testene:

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'
Svarte 28/08/2008 kl. 18:02
kilden bruker

stemmer
80

Bruke unittest (siden 3.4)

Siden Python 3.4, standard bibliotek unittesthar pakken subTestsammenheng manager.

Se dokumentasjonen:

Eksempel:

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)

Du kan også angi en egendefinert melding og parameterverdier til subTest():

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

Ved hjelp av nesen

Den nese testing rammer støtter denne .

Eksempel (koden nedenfor er hele innholdet i filen som inneholder det test):

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

Utgangen av nosetests kommandoen:

> 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)
Svarte 29/08/2008 kl. 07:10
kilden bruker

stemmer
56

Dette kan løses elegant ved hjelp av metaklasser:

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()
Svarte 01/01/2014 kl. 16:52
kilden bruker

stemmer
40

Per i Python 3.4 deltestene har blitt introdusert til unittest for dette formålet. Se dokumentasjonen for detaljer. TestCase.subTest er en sammenheng manager som gjør det mulig å isolere hevder i en test slik at en feil vil bli rapportert med parameter informasjon, men stopper ikke testutførelsen. Her er et eksempel fra dokumentasjon:

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)

Utgangen av en testkjøring vil væ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

Dette er også en del av unittest2 , så det er tilgjengelig for tidligere versjoner av Python.

Svarte 01/04/2015 kl. 06:46
kilden bruker

stemmer
29

load_tests er et lite kjent mekanisme introdusert i 2,7 for å skape en dynamisk TestSuite. Med det kan du enkelt lage parametriseres tester.

For eksempel:

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

At koden vil kjøre alle test-tilfeller i TestSuite returnert av load_tests. Ingen andre tester er automatisk drevet av oppdagelsen mekanisme.

Alternativt kan du også bruke arv som vist i denne billetten: http://bugs.python.org/msg151444

Svarte 07/05/2014 kl. 03:55
kilden bruker

stemmer
25

Det kan gjøres ved hjelp av pytest . Bare skrive filen test_me.pymed innhold:

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

Og kjøre test med kommando py.test --tb=short test_me.py. Da produksjonen vil være ser slik ut:

=========================== 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 ====================

Det enkle !. Også pytest har flere funksjoner som fixtures, mark, assert, osv ...

Svarte 02/09/2014 kl. 15:08
kilden bruker

stemmer
8

Bruk DDT biblioteket. Den legger enkle dekoratører for testmetoder:

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))

Dette biblioteket kan installeres med pip. Det krever ikke nose, og fungerer utmerket med standard bibliotek unittestmodulen.

Svarte 21/04/2015 kl. 08:24
kilden bruker

stemmer
6

Du vil ha nytte av å prøve TestScenarios biblioteket.

testscenarios gir ren avhengighet injeksjon for python unittest stil tester. Dette kan brukes for grensesnitt testing (test mange implementasjoner via en enkelt test suite) eller den klassiske avhengighet injeksjon (gi tester med avhengig eksternt til testkoden i seg selv, noe som gir enkel testing i forskjellige situasjoner).

Svarte 01/05/2009 kl. 03:59
kilden bruker

stemmer
4

Det er også hypotesen som legger fuzz eller eiendom basert testing: https://pypi.python.org/pypi/hypothesis

Dette er en svært kraftig testmetode.

Svarte 24/11/2015 kl. 02:00
kilden bruker

stemmer
4

Du kan bruke nese-ittr plugin ( pip install nose-ittr).

Det er veldig lett å integrere med eksisterende tester, er minimale endringer (hvis noen) som kreves. Den støtter også nese multi plugin.

Ikke at du også kan ha en tilpasse setupfunksjon per test.

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

Det er også mulig å passere nosetestparametere som med sin innebygde plugin attrib, på denne måten kan du kjøre bare en bestemt test med spesifikke parameter:

nosetest -a number=2
Svarte 02/12/2014 kl. 13:39
kilden bruker

stemmer
2

Jeg bruker metaklasser og dekoratører for generere tester. Du kan sjekke min implementerings python_wrap_cases . Dette biblioteket krever ingen test rammer.

Ditt eksempel:

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)

Konsoll utgang:

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

Også du kan bruke generatorer . For eksempel denne koden genererer alle mulige kombinasjoner av tester med argumenter a__listogb__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)

Konsoll utgang:

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
Svarte 01/07/2015 kl. 12:28
kilden bruker

stemmer
2

Jeg kom over ParamUnittest den andre dagen når du ser på kildekoden til radon ( f.eks bruk på GitHub repo ). Det skal fungere med andre rammer som strekker Testcase (som Nose).

Her er et eksempel:

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)
Svarte 06/03/2015 kl. 01:21
kilden bruker

stemmer
1
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)

RESULTAT:

>>> 
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)
Svarte 07/12/2016 kl. 06:10
kilden bruker

stemmer
1

Du kan bruke TestSuiteog tilpassede TestCaseklasser.

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)
Svarte 20/12/2015 kl. 15:41
kilden bruker

stemmer
1

Bare bruk metaklasser, sett her;

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

Produksjon:

test_sample (ExampleTestCase) ... OK
Svarte 10/05/2015 kl. 11:43
kilden bruker

stemmer
0

Jeg har funnet ut at dette fungerer godt for mitt formål, spesielt hvis jeg trenger å generere tester som gjør litt forskjell prosesser på en samling av data.

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()

Den TestGeneratorklassen kan brukes for å gyte forskjellige sett med testtilfeller som TestCluster.

TestClusterkan betraktes som en implementering av TestGeneratorgrensesnittet.

Svarte 06/08/2019 kl. 17:10
kilden bruker

stemmer
0

Super sent til festen, men jeg hadde problemer med å gjøre disse fungerer for setUpClass.

Her er en versjon av @ Javier svar som gir setUpClasstilgang til dynamisk tildelte attributter.

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

utganger

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

OK
Svarte 25/01/2018 kl. 21:24
kilden bruker

stemmer
0

Meta-programmering er gøy, men kan få på veien. De fleste løsninger her gjør det vanskelig å:

  • selektivt å starte en test
  • peker tilbake til koden gitt test navn

Så, mitt første forslag til å følge den enkle / eksplisitt bane (fungerer med alle test løper):

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()

Siden vi ikke skal gjenta oss selv, bygger min andre forslag på @ Javier svar: omfavne eiendom basert testing. Hypotese bibliotek:

  • er "mer nådeløst utspekulerte om test generasjon enn oss vanlige mennesker"
  • vil gi enkle telle eksempler
  • fungerer med alle test runner
  • har mange flere interessante funksjoner (statistikk, ekstra test utgang, ...)

    klasse TestSequence (unittest.TestCase):

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

For å teste dine spesifikke eksempler, bare legge til:

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

For å kjøre bare ett bestemt eksempel kan du kommentere ut de andre eksemplene (forut eksempel skal kjøres først). Det kan være lurt å bruke @given(st.nothing()). Et annet alternativ er å erstatte hele blokken etter:

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

Ok, du trenger ikke ha forskjellige test navn. Men kanskje du bare trenger:

  • et beskrivende navn på eiendommen under test.
  • hvilken inngang fører til svikt (forfalske eksempel).

funnier eksempel

Svarte 08/08/2017 kl. 13:59
kilden bruker

stemmer
0

De metaclass baserte svar fortsatt arbeid i Python3, men i stedet for __metaclass__attributtet må man bruke metaclassparameter, som i:

class ExampleTestCase(TestCase,metaclass=DocTestMeta):
    pass
Svarte 08/05/2017 kl. 15:25
kilden bruker

stemmer
0

Denne løsningen fungerer med unittestog nose:

#!/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()
Svarte 06/09/2016 kl. 13:57
kilden bruker

stemmer
0

Jeg hadde hatt problemer med en veldig spesiell stil av parameteriserte tester. Alle våre Selen tester kan kjøres lokalt, men de bør også kunne kjøres eksternt mot flere plattformer på SauceLabs. I utgangspunktet ønsket jeg å ta en stor mengde av allerede skrevet testtilfeller og parameter dem med færrest endringer i koden mulig. Videre jeg trengte for å være i stand til å sende parameterne til innstillingsmetode, noe som jeg ikke har sett noen løsninger for andre steder.

Her er hva jeg har kommet opp med:

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

Med dette, alt jeg måtte gjøre var å legge en enkel dekoratør @sauce_labs () til hver vanlige gamle Testcase, og nå når du kjører dem, de er pakket opp og omskrevet, slik at alle testmetoder er parametrisert og omdøpt. LoginTests.test_login (selv) løper som LoginTests.test_login_internet_explorer_10.0 (selv), LoginTests.test_login_internet_explorer_11.0 (selv), og LoginTests.test_login_firefox_43.0 (selv), og hver har den parameter self.platform for å bestemme hvilken browser / plattform for å kjøre mot, selv i LoginTests.setUp, noe som er avgjørende for min oppgave, siden det er der forbindelsen til SauceLabs er initialisert.

Uansett, jeg håper dette kan være til hjelp for noen som ønsker å gjøre en lignende "global" parametrisering av sine tester!

Svarte 22/04/2016 kl. 08:02
kilden bruker

stemmer
-1

Følgende er min løsning. Jeg finner dette nyttig når: 1. Bør arbeide for unittest.Testcase og unittest oppdage 2. Ha et sett med tester som skal kjøres for ulike parameterinnstillingene. 3. Veldig enkelt ingen avhengighet av andre pakker importere 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
Svarte 02/08/2016 kl. 16:35
kilden bruker

stemmer
-1

Dessuten bruker setattr, kan vi bruke load_tests siden python 3.2. Vennligst referer til blogginnlegg blog.livreuro.com/en/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()
Svarte 26/05/2016 kl. 20:20
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more