ti-enxame.com

Unittest setUp / tearDown para vários testes

Existe uma função que é acionada no início/final de um cenário de testes? As funções setUp e tearDown são disparadas antes/depois de cada teste.

Eu normalmente gostaria de ter isso:

class TestSequenceFunctions(unittest.TestCase):

    def setUpScenario(self):
        start() #launched at the beginning, once

    def test_choice(self):
        element = random.choice(self.seq)
        self.assertTrue(element in self.seq)

    def test_sample(self):
        with self.assertRaises(ValueError):
            random.sample(self.seq, 20)
        for element in random.sample(self.seq, 5):
            self.assertTrue(element in self.seq)

    def tearDownScenario(self):
        end() #launched at the end, once

Por enquanto, esses setUp e tearDown são testes de unidade e se espalham em todos os meus cenários (contendo muitos testes), um é o primeiro teste, o outro é o último teste.

102
swan

A partir de 2.7 (por a documentação ) você obtém setUpClass e tearDownClass que executam antes e depois dos testes em uma determinada classe serem executados, respectivamente. Como alternativa, se você tiver um grupo deles em um arquivo, poderá usar setUpModule e tearDownModule ( documentation ).

Caso contrário, sua melhor aposta provavelmente será criar seu próprio derivado TestSuite e substituir run(). Todas as outras chamadas seriam gerenciadas pelo pai, e o run chamaria o código de configuração e desmontagem de uma chamada até o método run do pai.

122
David H. Clements

Eu tenho o mesmo cenário, para mim os métodos setUpClass e tearDownClass funcionam perfeitamente

import unittest

class Test(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls._connection = createExpensiveConnectionObject()

    @classmethod
    def tearDownClass(cls):
        cls._connection.destroy()
43
V.Gupta

Para python 2.5, e ao trabalhar com o pydev, é um pouco difícil. Parece que o pydev não usa o conjunto de testes, mas encontra todos os casos de teste individuais e os executa separadamente.

Minha solução para isso foi usar uma variável de classe como esta:

class TestCase(unittest.TestCase):
    runCount = 0

    def setUpClass(self):
        pass # overridden in actual testcases

    def run(self, result=None):
        if type(self).runCount == 0:
            self.setUpClass()

        super(TestCase, self).run(result)
        type(self).runCount += 1

Com este truque, quando você herda deste TestCase (ao invés do original unittest.TestCase), você também herdará o runCount de 0. Então, no método run, o runCount do child testcase é verificado e incrementado. Isso deixa a variável runCount para essa classe em 0.

Isso significa que o setUpClass só será executado uma vez por classe e não uma vez por instância.

Eu ainda não tenho um método tearDownClass, mas acho que algo poderia ser feito com o uso desse contador.

1
sanderd17