Python unittest - en utilisant setupclass, et plus d'un setup/démontage?

Question

Je comprends que les méthodes setUpClass/tearDownClass sont appelées une fois pour une classe, et setUp()/tearDown() sont appelées avant/après chaque test unitaire. Voir l'extrait de code ci-dessous pour cette configuration standard:

class Example(unittest.TestCase): 
    @classmethod 
    def setUpClass(cls): 
     do_expensive_setup_of_immutable_objects_used_by_all_tests() 

    def setUp(self): 
     do_setup_before_each_test() 

    def test1(self): 
     do_test1_stuff() 

    def test2(self): 
     do_test1_stuff() 

    def tearDown(self): 
     do_teardown_after_each_test() 

    @classmethod 
    def tearDownClass(cls): 
     do_teardown_of_immutable_objects_used_from_all_tests() 

Cependant, je voudrais quelques tests unitaires pour avoir un autre setUp() et tearDown() d'autres tests unitaires. Qu'est-ce qui serait considéré comme une bonne structure de test pour réaliser cette fonctionnalité? Quelles options ai-je? Je suis inexpérimenté en Python et aimerais connaître un bon style à adopter pour écrire des tests unitaires impliquant des procédures coûteuses setUp().

Answer 1

Peut-être que c'est ce que veut dire @ Klaus?

import unittest 


class TestA(unittest.TestCase): 
    def setUp(self): 
     print "Setup # 1" 

    def test1(self): 
     print "Doing test1" 

class TestB(unittest.TestCase): 
    def setUp(self): 
     print "Setup # 2" 

    def test2(self): 
     print "Doing test2" 


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

Vous pouvez également modifier l'installation en fonction du nom de la méthode.
Bien que cela puisse être un peu plus difficile à maintenir.

class TestA(unittest.TestCase): 
    def setUp(self): 
     if self._testMethodName == "test1": 
      print "Setup # 1" 
     elif self._testMethodName == "test2": 
      print "Setup # 2" 

    def test1(self): 
     print "Doing test1" 

    def test2(self): 
     print "Doing test2" 


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

Les deux produisent la même sortie:

Output: 
Setup # 1 
Doing test1 
.Setup # 2 
Doing test2 
. 
---------------------------------------------------------------------- 
Ran 2 tests in 0.001s 

OK 

EDIT: Désolé, je ne pense pas que je comprends très bien, mais voici ma tentative de mise en œuvre de votre commentaire. Mon approche ici est de réappliquer BaseTest.setUp() plutôt que d'essayer de le garder intact comme vous l'avez décrit.
TypeOneTests et TypeTwoTests hériteront BaseTest et ils appellent la fonction BaseTest est setUp l'intérieur de leur propre en utilisant super(...)

class BaseTest(unittest.TestCase): 
    def setUp(self): 
     print "BaseTest setUp" 

    def tearDown(self): 
     print "BaseTest tearDown" 

    # you could add tests here but I didn't add any based on your comment 


class TypeOneTests(BaseTest): 
    def setUp(self): 
     super(TypeOneTests, self).setUp() 
     print "TypeOneTests setUp" 

    def tearDown(self): 
     print "TypeOneTests tearDown" 

    def test(self): 
     print "a test in TypeOneTests" 


class TypeTwoTests(BaseTest): 
    def setUp(self): 
     super(TypeTwoTests, self).setUp() 
     print "TypeTwoTests additional setUp" 

    def tearDown(self): 
     print "TypeTwoTests tearDown" 
     super(TypeTwoTests, self).tearDown() 

    def test(self): 
     print "a test in TypeTwoTests" 


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

Sortie:

BaseTest setUp 
TypeOneTests setUp 
a test in TypeOneTests 
TypeOneTests tearDown 
.BaseTest setUp 
TypeTwoTests additional setUp 
a test in TypeTwoTests 
TypeTwoTests tearDown 
BaseTest tearDown 
. 
---------------------------------------------------------------------- 
Ran 2 tests in 0.002s 

OK