Como você gerar (parametrizada) testes de unidade dinâmicos em python?

votos
154

Eu tenho algum tipo de dados de teste e quer criar um teste de unidade para cada item. Minha primeira idéia era fazê-lo como este:

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

A desvantagem desta situação é que ele lida com todos os dados em um teste. Eu gostaria de gerar um teste para cada item na mosca. Alguma sugestão?

Publicado 28/08/2008 em 18:49
fonte usuário
Em outras línguas...                            


23 respostas

votos
114

i usar algo como isto:

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

O nose-parameterizedpacote pode ser usado para automatizar esse processo:

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

O que irá gerar os testes:

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/nose_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'
Respondeu 28/08/2008 em 19:02
fonte usuário

votos
66

O nariz framework de testes suporta este .

Exemplo (o código abaixo é todo o conteúdo do ficheiro contendo o teste):

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

A saída do comando 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)

ATUALIZAÇÃO - unittest apoio desde 3.4:

Desde Python 3.4, a biblioteca padrão unittestpacote tem o subTestgerente de contexto, permitindo funcionalidade semelhante usando unittestsomente.

Consulte a documentação:

Exemplo:

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)

Você também pode especificar uma mensagem personalizada e os valores de parâmetro para subTest():

with self.subTest(msg="Checking if p1 equals p2", p1=p1, p2=p2):
Respondeu 29/08/2008 em 08:10
fonte usuário

votos
53

Isso pode ser resolvido com elegância usando Metaclasses:

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()
Respondeu 01/01/2014 em 17:52
fonte usuário

votos
37

A partir de Python 3.4 subtestes foram introduzidas para UnitTest para esta finalidade. Veja a documentação para mais detalhes. TestCase.subTest é um gerenciador de contexto que permite isolar afirma em um teste para que uma falha será relatado com informações de parâmetro, mas não parar a execução do teste. Aqui está o exemplo da documentação:

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)

A saída de um teste seria:

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

Isso também faz parte da unittest2 , para que esteja disponível para versões anteriores do Python.

Respondeu 01/04/2015 em 06:46
fonte usuário

votos
27

load_tests é um pouco mecanismo conhecido introduzido em 2,7 para criar dinamicamente um TestSuite. Com ele, você pode facilmente criar testes parametrizadas.

Por exemplo:

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

Esse código irá executar todos os TestCases no TestSuite retornado por load_tests. Não há outros testes são executados automaticamente pelo mecanismo de descoberta.

Alternativamente, você também pode usar a herança como mostra este bilhete: http://bugs.python.org/msg151444

Respondeu 07/05/2014 em 04:55
fonte usuário

votos
24

Isso pode ser feito usando pytest . Basta escrever o arquivo test_me.pycom o conteúdo:

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

E executar o teste com o comando py.test --tb=short test_me.py. Então, a saída será parece:

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

It !. simples Também pytest tem mais recursos, como fixtures, mark, assert, etc ...

Respondeu 02/09/2014 em 16:08
fonte usuário

votos
8

Use o ddt biblioteca. Acrescenta decoradores simples para os métodos de ensaio:

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

Esta biblioteca pode ser instalado com pip. Ele não requer nose, e funciona excelente com a biblioteca padrão unittestmódulo.

Respondeu 21/04/2015 em 08:24
fonte usuário

votos
6

Você se beneficiaria de tentar o TestScenarios biblioteca.

testscenarios fornece injecção dependência limpo para testes de estilo python unittest. Isto pode ser utilizado para testes de interface (testando muitas implementações através de um único conjunto de teste) ou por injecção dependência clássico (proporcionam testes com dependências externamente ao próprio código de teste, permitindo o fácil ensaio em situações diferentes).

Respondeu 01/05/2009 em 04:59
fonte usuário

votos
4

Há também Hipótese que acrescenta Fuzzing ou propriedade com base: https://pypi.python.org/pypi/hypothesis

Este é um método de teste muito poderoso.

Respondeu 24/11/2015 em 02:00
fonte usuário

votos
4

Você pode usar nariz-ittr plug-in ( pip install nose-ittr).

É muito fácil de integrar com os testes existentes, alterações mínimas (se houver) são obrigatórios. Ele também suporta nariz multiprocessamento plugin.

Não é que você também pode ter um customize setupfunção por teste.

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

Também é possível passar nosetestparâmetros como com o seu plugin build-in attrib, desta forma você pode executar apenas um teste específico com o parâmetro específico:

nosetest -a number=2
Respondeu 02/12/2014 em 13:39
fonte usuário

votos
2

Eu uso metaclasses e decoradores para gerar testes. Você pode verificar minha implementação python_wrap_cases . Esta biblioteca não requer quaisquer estruturas de teste.

O seu exemplo:

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)

saída do console:

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

Além disso, você pode usar geradores . Por exemplo, este código de gerar todas as possíveis combinações de testes com argumentos a__listeb__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)

saída do console:

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
Respondeu 01/07/2015 em 12:28
fonte usuário

votos
2

Me deparei com ParamUnittest no outro dia quando se olha para o código fonte para o radão ( exemplo de uso no repo github ). Ele deve funcionar com outras estruturas que se estendem TestCase (como nariz).

Aqui está um exemplo:

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)
Respondeu 06/03/2015 em 01:21
fonte usuário

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

RESULTADO:

>>> 
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)
Respondeu 07/12/2016 em 06:10
fonte usuário

votos
1

Você pode usar TestSuitee personalizados TestCaseclasses.

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)
Respondeu 20/12/2015 em 15:41
fonte usuário

votos
1

Basta utilizar metaclasses, como visto aqui;

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

Saída:

test_sample (ExampleTestCase) ... OK
Respondeu 10/05/2015 em 11:43
fonte usuário

votos
0

Eu descobri que isso funciona bem para os meus propósitos, especialmente se eu preciso para gerar testes que fazer um pouco de diferença processos em uma coleção de dados.

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

A TestGeneratorclasse pode ser usada para gerar diferentes conjuntos de casos de teste como TestCluster.

TestClusterpode ser pensado como uma implementação da TestGeneratorinterface.

Respondeu 06/08/2019 em 17:10
fonte usuário

votos
0

Super atrasado para a festa, mas tive problemas para fazer esses trabalhos para setUpClass.

Aqui está uma versão de @ resposta de Javier , que dá setUpClassacesso a atributos alocados dinamicamente.

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

saídas

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

OK
Respondeu 25/01/2018 em 21:24
fonte usuário

votos
0

Meta-programação é divertido, mas pode ficar no caminho. A maioria das soluções aqui tornam difícil:

  • iniciar selectivamente um teste
  • apontar para o nome do teste de código dado

Então, minha primeira sugestão é seguir o caminho simples / explícita (funciona com qualquer corredor de teste):

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

Uma vez que não deve repetir-nos, minha segunda sugestão baseia-se na resposta da @ Javier: abraçar testes baseados propriedade. biblioteca hipótese:

  • é "mais implacavelmente desonesto sobre o teste de geração de casos do que nós, meros seres humanos"
  • irá fornecer contagem de exemplos simples
  • funciona com qualquer corredor de teste
  • tem muitos mais interessante características (estatísticas, saída de teste adicional, ...)

    TestSequence classe (unittest.TestCase):

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

Para testar seus exemplos específicos, basta adicionar:

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

Para executar apenas um exemplo particular, pode comentar os outros exemplos (desde exemplo será executado em primeiro lugar). Você pode querer usar @given(st.nothing()). Outra opção é substituir todo o bloco por:

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

Ok, você não tem nomes de teste distintas. Mas talvez você só precisa:

  • um nome descritivo da propriedade em teste.
  • que de entrada leva à falha (falsificar exemplo).

exemplo mais engraçado

Respondeu 08/08/2017 em 13:59
fonte usuário

votos
0

As respostas baseadas em metaclasse ainda trabalhar em Python3, mas em vez do __metaclass__atributo tem de se usar o metaclassparâmetro, como em:

class ExampleTestCase(TestCase,metaclass=DocTestMeta):
    pass
Respondeu 08/05/2017 em 15:25
fonte usuário

votos
0

Esta solução funciona com unitteste 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()
Respondeu 06/09/2016 em 13:57
fonte usuário

votos
0

Eu estava tendo problemas com um estilo muito particular de testes com parâmetros. Todos os nossos testes de selênio pode ser executado localmente, mas também deve ser capaz de ser executado remotamente em várias plataformas on SauceLabs. Basicamente, eu queria tirar uma grande quantidade de casos de teste já escritas e parametrizar-los com o menor número de alterações de código possível. Além disso, eu precisava ser capaz de passar os parâmetros para o método de configuração, algo que eu não vi nenhuma solução para outro lugar.

Aqui está o que eu vim acima com:

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

Com isso, tudo o que eu tinha a fazer era adicionar um simples @sauce_labs decorador () para cada TestCase de idade regular, e agora, quando executá-los, eles estão embrulhados e reescrito, para que todos os métodos de ensaio são parametrizados e renomeado. LoginTests.test_login (self) é executado como LoginTests.test_login_internet_explorer_10.0 (self), LoginTests.test_login_internet_explorer_11.0 (self) e LoginTests.test_login_firefox_43.0 (self), e cada um tem o self.platform parâmetro para decidir o navegador / plataforma para executar contra, mesmo em LoginTests.setUp, que é crucial para a minha tarefa já que é onde a conexão com SauceLabs é inicializado.

De qualquer forma, espero que este pode ser de ajuda para alguém que olha para fazer uma parametrização similar "global" de seus testes!

Respondeu 22/04/2016 em 08:02
fonte usuário

votos
-1

A seguir é a minha solução. I encontrar este útil quando: 1. Deve trabalhar para unittest.TestCase e unittest descobrir 2. Ter um conjunto de testes a serem executados para diferentes ajustes de parâmetros. 3. Muito simples nenhuma dependência de outros pacotes importar 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
Respondeu 02/08/2016 em 16:35
fonte usuário

votos
-1

Além de usar setattr, podemos usar load_tests desde python 3.2. Consulte a postagem no blog 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()
Respondeu 26/05/2016 em 20:20
fonte usuário

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