Teste de unidade Python com base e subclasse

Atualmente, tenho alguns testes de unidade que compartilham um conjunto comum de testes. Aqui está um exemplo:

import unittest

class BaseTest(unittest.TestCase):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

A saída do acima é:

Calling BaseTest:testCommon
.Calling BaseTest:testCommon
.Calling SubTest1:testSub1
.Calling BaseTest:testCommon
.Calling SubTest2:testSub2
.
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK

Existe uma maneira de reescrever o que testCommonfoi dito acima para que o primeiro não seja chamado?

Edição: Em vez de executar 5 testes acima, eu quero executar apenas 4 testes, 2 do SubTest1 e outros 2 do SubTest2. Parece que o Python unittest está executando o BaseTest original por conta própria e preciso de um mecanismo para impedir que isso aconteça.

Use herança múltipla, para que sua classe com testes comuns não herda de TestCase.

import unittest

class CommonTests(object):
    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(unittest.TestCase, CommonTests):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(unittest.TestCase, CommonTests):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

Não use herança múltipla, ela o morderá mais tarde .

Em vez disso, você pode simplesmente mover sua classe base para o módulo separado ou envolvê-la com a classe em branco:

class BaseTestCases:

    class BaseTest(unittest.TestCase):

        def testCommon(self):
            print('Calling BaseTest:testCommon')
            value = 5
            self.assertEqual(value, 5)


class SubTest1(BaseTestCases.BaseTest):

    def testSub1(self):
        print('Calling SubTest1:testSub1')
        sub = 3
        self.assertEqual(sub, 3)


class SubTest2(BaseTestCases.BaseTest):

    def testSub2(self):
        print('Calling SubTest2:testSub2')
        sub = 4
        self.assertEqual(sub, 4)

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

A saída:

Calling BaseTest:testCommon
.Calling SubTest1:testSub1
.Calling BaseTest:testCommon
.Calling SubTest2:testSub2
.
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

Você pode resolver esse problema com um único comando:

del(BaseTest)

Portanto, o código ficaria assim:

import unittest

class BaseTest(unittest.TestCase):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

del(BaseTest)

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

A resposta de Matthew Marshall é ótima, mas requer que você herde de duas classes em cada um dos seus casos de teste, o que é propenso a erros. Em vez disso, eu uso isso (python> = 2.7):

class BaseTest(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        if cls is BaseTest:
            raise unittest.SkipTest("Skip BaseTest tests, it's a base class")
        super(BaseTest, cls).setUpClass()

O que você está tentando alcançar? Se você tiver um código de teste comum (asserções, testes de gabarito etc.), coloque-os em métodos que não sejam prefixados testpara unittestnão carregá-los.

import unittest

class CommonTests(unittest.TestCase):
      def common_assertion(self, foo, bar, baz):
          # whatever common code
          self.assertEqual(foo(bar), baz)

class BaseTest(CommonTests):

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(CommonTests):

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)

class SubTest2(CommonTests):

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

A resposta de Matthew é a que eu precisava usar, pois ainda estou com 2,5. Mas a partir da versão 2.7, você pode usar o decorador @ unittest.skip () em qualquer método de teste que você queira pular.

http://docs.python.org/library/unittest.html#skipping-tests-and-expected-failures

Você precisará implementar seu próprio decorador de pulos para verificar o tipo de base. Não usei esse recurso antes, mas em cima da minha cabeça você poderia usar o BaseTest como marcador tipo de para condicionar o salto:

def skipBaseTest(obj):
    if type(obj) is BaseTest:
        return unittest.skip("BaseTest tests skipped")
    return lambda func: func

Uma maneira de pensar em resolver isso é ocultando os métodos de teste se a classe base for usada. Dessa forma, os testes não são ignorados; portanto, os resultados podem ser verdes em vez de amarelos em muitas ferramentas de relatórios de testes.

Comparado ao método mixin, ide como o PyCharm não vai reclamar que os métodos de teste de unidade estão faltando na classe base.

Se uma classe base herdar dessa classe, ela precisará substituir os métodos setUpClasse tearDownClass.

class BaseTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls._test_methods = []
        if cls is BaseTest:
            for name in dir(cls):
                if name.startswith('test') and callable(getattr(cls, name)):
                    cls._test_methods.append((name, getattr(cls, name)))
                    setattr(cls, name, lambda self: None)

    @classmethod
    def tearDownClass(cls):
        if cls is BaseTest:
            for name, method in cls._test_methods:
                setattr(cls, name, method)
            cls._test_methods = []

Você pode adicionar __test_ = Falsena classe BaseTest, mas, se adicionar, lembre-se de que deve adicionar __test__ = Trueclasses derivadas para poder executar testes.

import unittest

class BaseTest(unittest.TestCase):
    __test__ = False

    def testCommon(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)

class SubTest1(BaseTest):
    __test__ = True

    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):
    __test__ = True

    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

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

Outra opção é não executar

unittest.main()

Em vez disso, você pode usar

suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
unittest.TextTestRunner(verbosity=2).run(suite)

Então você só executa os testes na classe TestClass

Eu fiz o mesmo que @Vladim P. ( https://stackoverflow.com/a/25695512/2451329 ), mas modifiquei um pouco:

import unittest2


from some_module import func1, func2


def make_base_class(func):

    class Base(unittest2.TestCase):

        def test_common1(self):
            print("in test_common1")
            self.assertTrue(func())

        def test_common2(self):
            print("in test_common1")
            self.assertFalse(func(42))

    return Base



class A(make_base_class(func1)):
    pass


class B(make_base_class(func2)):

    def test_func2_with_no_arg_return_bar(self):
        self.assertEqual("bar", func2())

e lá vamos nós.

No Python 3.2, você pode adicionar uma função test_loader a um módulo para controlar quais testes (se houver) são encontrados pelo mecanismo de descoberta de testes.

Por exemplo, o seguinte carregará apenas os pôsteres SubTest1e SubTest2casos de teste originais , ignorando Base:

def load_tests(loader, standard_tests, pattern):
    suite = TestSuite()
    suite.addTests([SubTest1, SubTest2])
    return suite

Deveria ser possível iterar standard_tests(a TestSuitecontendo os testes encontrados pelo carregador padrão) e copiar tudo, exceto Basepara suite, mas a natureza aninhada TestSuite.__iter__torna isso muito mais complicado.

Apenas renomeie o método testCommon para outra coisa. O Unittest (geralmente) pula qualquer coisa que não tenha 'teste'.

Rápido e simples

  import unittest

  class BaseTest(unittest.TestCase):

   def methodCommon(self):
       print 'Calling BaseTest:testCommon'
       value = 5
       self.assertEquals(value, 5)

  class SubTest1(BaseTest):

      def testSub1(self):
          print 'Calling SubTest1:testSub1'
          sub = 3
          self.assertEquals(sub, 3)


  class SubTest2(BaseTest):

      def testSub2(self):
          print 'Calling SubTest2:testSub2'
          sub = 4
          self.assertEquals(sub, 4)

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

Portanto, esse é um tipo de tópico antigo, mas me deparei com esse problema hoje e pensei em meu próprio truque. Ele usa um decorador que torna os valores das funções None quando acessados ​​através da classe base. Não precisa se preocupar com setup e setupclass porque, se a classe base não tiver testes, ela não será executada.

import types
import unittest


class FunctionValueOverride(object):
    def __init__(self, cls, default, override=None):
        self.cls = cls
        self.default = default
        self.override = override

    def __get__(self, obj, klass):
        if klass == self.cls:
            return self.override
        else:
            if obj:
                return types.MethodType(self.default, obj)
            else:
                return self.default


def fixture(cls):
    for t in vars(cls):
        if not callable(getattr(cls, t)) or t[:4] != "test":
            continue
        setattr(cls, t, FunctionValueOverride(cls, getattr(cls, t)))
    return cls


@fixture
class BaseTest(unittest.TestCase):
    def testCommon(self):
        print('Calling BaseTest:testCommon')
        value = 5
        self.assertEqual(value, 5)


class SubTest1(BaseTest):
    def testSub1(self):
        print('Calling SubTest1:testSub1')
        sub = 3
        self.assertEqual(sub, 3)


class SubTest2(BaseTest):

    def testSub2(self):
        print('Calling SubTest2:testSub2')
        sub = 4
        self.assertEqual(sub, 4)

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

Altere o nome do método BaseTest para setUp:

class BaseTest(unittest.TestCase):
    def setUp(self):
        print 'Calling BaseTest:testCommon'
        value = 5
        self.assertEquals(value, 5)


class SubTest1(BaseTest):
    def testSub1(self):
        print 'Calling SubTest1:testSub1'
        sub = 3
        self.assertEquals(sub, 3)


class SubTest2(BaseTest):
    def testSub2(self):
        print 'Calling SubTest2:testSub2'
        sub = 4
        self.assertEquals(sub, 4)

Resultado:

Realizou 2 testes em 0.000s

Chamando BaseTest: testCommon Chamando
SubTest1: testSub1 Chamando
BaseTest: testCommon Chamando
SubTest2: testSub2

A partir da documentação :

Método TestCase.setUp () chamado para preparar o dispositivo de teste. Isso é chamado imediatamente antes de chamar o método de teste; qualquer exceção gerada por esse método será considerada um erro e não uma falha no teste. A implementação padrão não faz nada.