Python Unittest - mit setupclass, und mehr als ein Setup/Takedown?

Question

Ich verstehe, dass setUpClass/tearDownClass Methoden einmal für eine Klasse aufgerufen werden, und setUp()/tearDown() werden vor/nach jedem Komponententest aufgerufen. Sehen Sie den Code-Snippet für diesen Standard-Setup:

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

Allerdings würde ich einige Unit-Tests wie eine andere setUp() und tearDown() von anderen Unit-Tests haben. Was wäre eine gute Teststruktur, um diese Funktionalität zu erreichen? Welche Möglichkeiten habe ich? Ich bin unerfahren in Python und möchte einen guten Stil kennen, der für das Schreiben von Unit-Tests angenommen wird, die teure setUp()-Verfahren beinhalten.

Answer 1

Vielleicht ist das was @Klaus bedeutet?

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

Alternativ können Sie das Setup basierend auf dem Methodennamen ändern.
Obwohl dies ein bisschen mehr Mühe sein könnte, zu erhalten.

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

produzieren beide die gleiche Leistung:

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

OK 

EDIT: Sorry, ich glaube nicht, dass ich voll und ganz verstehen, aber hier ist mein Versuch, Ihren Kommentar zu implementieren. Mein Ansatz hier ist es, BaseTest.setUp() erneut anzuwenden, anstatt zu versuchen, es intakt zu halten, wie Sie beschrieben haben.
TypeOneTests und TypeTwoTests erben BaseTest und sie nennen BaseTest ‚s setUp Funktion innerhalb ihrer eigenen Verwendung 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() 

Ausgang:

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