Home | History | Annotate | Download | only in test
      1 import sys
      2 
      3 from cStringIO import StringIO
      4 
      5 import unittest
      6 
      7 
      8 def resultFactory(*_):
      9     return unittest.TestResult()
     10 
     11 
     12 class TestSetups(unittest.TestCase):
     13 
     14     def getRunner(self):
     15         return unittest.TextTestRunner(resultclass=resultFactory,
     16                                           stream=StringIO())
     17     def runTests(self, *cases):
     18         suite = unittest.TestSuite()
     19         for case in cases:
     20             tests = unittest.defaultTestLoader.loadTestsFromTestCase(case)
     21             suite.addTests(tests)
     22 
     23         runner = self.getRunner()
     24 
     25         # creating a nested suite exposes some potential bugs
     26         realSuite = unittest.TestSuite()
     27         realSuite.addTest(suite)
     28         # adding empty suites to the end exposes potential bugs
     29         suite.addTest(unittest.TestSuite())
     30         realSuite.addTest(unittest.TestSuite())
     31         return runner.run(realSuite)
     32 
     33     def test_setup_class(self):
     34         class Test(unittest.TestCase):
     35             setUpCalled = 0
     36             @classmethod
     37             def setUpClass(cls):
     38                 Test.setUpCalled += 1
     39                 unittest.TestCase.setUpClass()
     40             def test_one(self):
     41                 pass
     42             def test_two(self):
     43                 pass
     44 
     45         result = self.runTests(Test)
     46 
     47         self.assertEqual(Test.setUpCalled, 1)
     48         self.assertEqual(result.testsRun, 2)
     49         self.assertEqual(len(result.errors), 0)
     50 
     51     def test_teardown_class(self):
     52         class Test(unittest.TestCase):
     53             tearDownCalled = 0
     54             @classmethod
     55             def tearDownClass(cls):
     56                 Test.tearDownCalled += 1
     57                 unittest.TestCase.tearDownClass()
     58             def test_one(self):
     59                 pass
     60             def test_two(self):
     61                 pass
     62 
     63         result = self.runTests(Test)
     64 
     65         self.assertEqual(Test.tearDownCalled, 1)
     66         self.assertEqual(result.testsRun, 2)
     67         self.assertEqual(len(result.errors), 0)
     68 
     69     def test_teardown_class_two_classes(self):
     70         class Test(unittest.TestCase):
     71             tearDownCalled = 0
     72             @classmethod
     73             def tearDownClass(cls):
     74                 Test.tearDownCalled += 1
     75                 unittest.TestCase.tearDownClass()
     76             def test_one(self):
     77                 pass
     78             def test_two(self):
     79                 pass
     80 
     81         class Test2(unittest.TestCase):
     82             tearDownCalled = 0
     83             @classmethod
     84             def tearDownClass(cls):
     85                 Test2.tearDownCalled += 1
     86                 unittest.TestCase.tearDownClass()
     87             def test_one(self):
     88                 pass
     89             def test_two(self):
     90                 pass
     91 
     92         result = self.runTests(Test, Test2)
     93 
     94         self.assertEqual(Test.tearDownCalled, 1)
     95         self.assertEqual(Test2.tearDownCalled, 1)
     96         self.assertEqual(result.testsRun, 4)
     97         self.assertEqual(len(result.errors), 0)
     98 
     99     def test_error_in_setupclass(self):
    100         class BrokenTest(unittest.TestCase):
    101             @classmethod
    102             def setUpClass(cls):
    103                 raise TypeError('foo')
    104             def test_one(self):
    105                 pass
    106             def test_two(self):
    107                 pass
    108 
    109         result = self.runTests(BrokenTest)
    110 
    111         self.assertEqual(result.testsRun, 0)
    112         self.assertEqual(len(result.errors), 1)
    113         error, _ = result.errors[0]
    114         self.assertEqual(str(error),
    115                     'setUpClass (%s.BrokenTest)' % __name__)
    116 
    117     def test_error_in_teardown_class(self):
    118         class Test(unittest.TestCase):
    119             tornDown = 0
    120             @classmethod
    121             def tearDownClass(cls):
    122                 Test.tornDown += 1
    123                 raise TypeError('foo')
    124             def test_one(self):
    125                 pass
    126             def test_two(self):
    127                 pass
    128 
    129         class Test2(unittest.TestCase):
    130             tornDown = 0
    131             @classmethod
    132             def tearDownClass(cls):
    133                 Test2.tornDown += 1
    134                 raise TypeError('foo')
    135             def test_one(self):
    136                 pass
    137             def test_two(self):
    138                 pass
    139 
    140         result = self.runTests(Test, Test2)
    141         self.assertEqual(result.testsRun, 4)
    142         self.assertEqual(len(result.errors), 2)
    143         self.assertEqual(Test.tornDown, 1)
    144         self.assertEqual(Test2.tornDown, 1)
    145 
    146         error, _ = result.errors[0]
    147         self.assertEqual(str(error),
    148                     'tearDownClass (%s.Test)' % __name__)
    149 
    150     def test_class_not_torndown_when_setup_fails(self):
    151         class Test(unittest.TestCase):
    152             tornDown = False
    153             @classmethod
    154             def setUpClass(cls):
    155                 raise TypeError
    156             @classmethod
    157             def tearDownClass(cls):
    158                 Test.tornDown = True
    159                 raise TypeError('foo')
    160             def test_one(self):
    161                 pass
    162 
    163         self.runTests(Test)
    164         self.assertFalse(Test.tornDown)
    165 
    166     def test_class_not_setup_or_torndown_when_skipped(self):
    167         class Test(unittest.TestCase):
    168             classSetUp = False
    169             tornDown = False
    170             @classmethod
    171             def setUpClass(cls):
    172                 Test.classSetUp = True
    173             @classmethod
    174             def tearDownClass(cls):
    175                 Test.tornDown = True
    176             def test_one(self):
    177                 pass
    178 
    179         Test = unittest.skip("hop")(Test)
    180         self.runTests(Test)
    181         self.assertFalse(Test.classSetUp)
    182         self.assertFalse(Test.tornDown)
    183 
    184     def test_setup_teardown_order_with_pathological_suite(self):
    185         results = []
    186 
    187         class Module1(object):
    188             @staticmethod
    189             def setUpModule():
    190                 results.append('Module1.setUpModule')
    191             @staticmethod
    192             def tearDownModule():
    193                 results.append('Module1.tearDownModule')
    194 
    195         class Module2(object):
    196             @staticmethod
    197             def setUpModule():
    198                 results.append('Module2.setUpModule')
    199             @staticmethod
    200             def tearDownModule():
    201                 results.append('Module2.tearDownModule')
    202 
    203         class Test1(unittest.TestCase):
    204             @classmethod
    205             def setUpClass(cls):
    206                 results.append('setup 1')
    207             @classmethod
    208             def tearDownClass(cls):
    209                 results.append('teardown 1')
    210             def testOne(self):
    211                 results.append('Test1.testOne')
    212             def testTwo(self):
    213                 results.append('Test1.testTwo')
    214 
    215         class Test2(unittest.TestCase):
    216             @classmethod
    217             def setUpClass(cls):
    218                 results.append('setup 2')
    219             @classmethod
    220             def tearDownClass(cls):
    221                 results.append('teardown 2')
    222             def testOne(self):
    223                 results.append('Test2.testOne')
    224             def testTwo(self):
    225                 results.append('Test2.testTwo')
    226 
    227         class Test3(unittest.TestCase):
    228             @classmethod
    229             def setUpClass(cls):
    230                 results.append('setup 3')
    231             @classmethod
    232             def tearDownClass(cls):
    233                 results.append('teardown 3')
    234             def testOne(self):
    235                 results.append('Test3.testOne')
    236             def testTwo(self):
    237                 results.append('Test3.testTwo')
    238 
    239         Test1.__module__ = Test2.__module__ = 'Module'
    240         Test3.__module__ = 'Module2'
    241         sys.modules['Module'] = Module1
    242         sys.modules['Module2'] = Module2
    243 
    244         first = unittest.TestSuite((Test1('testOne'),))
    245         second = unittest.TestSuite((Test1('testTwo'),))
    246         third = unittest.TestSuite((Test2('testOne'),))
    247         fourth = unittest.TestSuite((Test2('testTwo'),))
    248         fifth = unittest.TestSuite((Test3('testOne'),))
    249         sixth = unittest.TestSuite((Test3('testTwo'),))
    250         suite = unittest.TestSuite((first, second, third, fourth, fifth, sixth))
    251 
    252         runner = self.getRunner()
    253         result = runner.run(suite)
    254         self.assertEqual(result.testsRun, 6)
    255         self.assertEqual(len(result.errors), 0)
    256 
    257         self.assertEqual(results,
    258                          ['Module1.setUpModule', 'setup 1',
    259                           'Test1.testOne', 'Test1.testTwo', 'teardown 1',
    260                           'setup 2', 'Test2.testOne', 'Test2.testTwo',
    261                           'teardown 2', 'Module1.tearDownModule',
    262                           'Module2.setUpModule', 'setup 3',
    263                           'Test3.testOne', 'Test3.testTwo',
    264                           'teardown 3', 'Module2.tearDownModule'])
    265 
    266     def test_setup_module(self):
    267         class Module(object):
    268             moduleSetup = 0
    269             @staticmethod
    270             def setUpModule():
    271                 Module.moduleSetup += 1
    272 
    273         class Test(unittest.TestCase):
    274             def test_one(self):
    275                 pass
    276             def test_two(self):
    277                 pass
    278         Test.__module__ = 'Module'
    279         sys.modules['Module'] = Module
    280 
    281         result = self.runTests(Test)
    282         self.assertEqual(Module.moduleSetup, 1)
    283         self.assertEqual(result.testsRun, 2)
    284         self.assertEqual(len(result.errors), 0)
    285 
    286     def test_error_in_setup_module(self):
    287         class Module(object):
    288             moduleSetup = 0
    289             moduleTornDown = 0
    290             @staticmethod
    291             def setUpModule():
    292                 Module.moduleSetup += 1
    293                 raise TypeError('foo')
    294             @staticmethod
    295             def tearDownModule():
    296                 Module.moduleTornDown += 1
    297 
    298         class Test(unittest.TestCase):
    299             classSetUp = False
    300             classTornDown = False
    301             @classmethod
    302             def setUpClass(cls):
    303                 Test.classSetUp = True
    304             @classmethod
    305             def tearDownClass(cls):
    306                 Test.classTornDown = True
    307             def test_one(self):
    308                 pass
    309             def test_two(self):
    310                 pass
    311 
    312         class Test2(unittest.TestCase):
    313             def test_one(self):
    314                 pass
    315             def test_two(self):
    316                 pass
    317         Test.__module__ = 'Module'
    318         Test2.__module__ = 'Module'
    319         sys.modules['Module'] = Module
    320 
    321         result = self.runTests(Test, Test2)
    322         self.assertEqual(Module.moduleSetup, 1)
    323         self.assertEqual(Module.moduleTornDown, 0)
    324         self.assertEqual(result.testsRun, 0)
    325         self.assertFalse(Test.classSetUp)
    326         self.assertFalse(Test.classTornDown)
    327         self.assertEqual(len(result.errors), 1)
    328         error, _ = result.errors[0]
    329         self.assertEqual(str(error), 'setUpModule (Module)')
    330 
    331     def test_testcase_with_missing_module(self):
    332         class Test(unittest.TestCase):
    333             def test_one(self):
    334                 pass
    335             def test_two(self):
    336                 pass
    337         Test.__module__ = 'Module'
    338         sys.modules.pop('Module', None)
    339 
    340         result = self.runTests(Test)
    341         self.assertEqual(result.testsRun, 2)
    342 
    343     def test_teardown_module(self):
    344         class Module(object):
    345             moduleTornDown = 0
    346             @staticmethod
    347             def tearDownModule():
    348                 Module.moduleTornDown += 1
    349 
    350         class Test(unittest.TestCase):
    351             def test_one(self):
    352                 pass
    353             def test_two(self):
    354                 pass
    355         Test.__module__ = 'Module'
    356         sys.modules['Module'] = Module
    357 
    358         result = self.runTests(Test)
    359         self.assertEqual(Module.moduleTornDown, 1)
    360         self.assertEqual(result.testsRun, 2)
    361         self.assertEqual(len(result.errors), 0)
    362 
    363     def test_error_in_teardown_module(self):
    364         class Module(object):
    365             moduleTornDown = 0
    366             @staticmethod
    367             def tearDownModule():
    368                 Module.moduleTornDown += 1
    369                 raise TypeError('foo')
    370 
    371         class Test(unittest.TestCase):
    372             classSetUp = False
    373             classTornDown = False
    374             @classmethod
    375             def setUpClass(cls):
    376                 Test.classSetUp = True
    377             @classmethod
    378             def tearDownClass(cls):
    379                 Test.classTornDown = True
    380             def test_one(self):
    381                 pass
    382             def test_two(self):
    383                 pass
    384 
    385         class Test2(unittest.TestCase):
    386             def test_one(self):
    387                 pass
    388             def test_two(self):
    389                 pass
    390         Test.__module__ = 'Module'
    391         Test2.__module__ = 'Module'
    392         sys.modules['Module'] = Module
    393 
    394         result = self.runTests(Test, Test2)
    395         self.assertEqual(Module.moduleTornDown, 1)
    396         self.assertEqual(result.testsRun, 4)
    397         self.assertTrue(Test.classSetUp)
    398         self.assertTrue(Test.classTornDown)
    399         self.assertEqual(len(result.errors), 1)
    400         error, _ = result.errors[0]
    401         self.assertEqual(str(error), 'tearDownModule (Module)')
    402 
    403     def test_skiptest_in_setupclass(self):
    404         class Test(unittest.TestCase):
    405             @classmethod
    406             def setUpClass(cls):
    407                 raise unittest.SkipTest('foo')
    408             def test_one(self):
    409                 pass
    410             def test_two(self):
    411                 pass
    412 
    413         result = self.runTests(Test)
    414         self.assertEqual(result.testsRun, 0)
    415         self.assertEqual(len(result.errors), 0)
    416         self.assertEqual(len(result.skipped), 1)
    417         skipped = result.skipped[0][0]
    418         self.assertEqual(str(skipped), 'setUpClass (%s.Test)' % __name__)
    419 
    420     def test_skiptest_in_setupmodule(self):
    421         class Test(unittest.TestCase):
    422             def test_one(self):
    423                 pass
    424             def test_two(self):
    425                 pass
    426 
    427         class Module(object):
    428             @staticmethod
    429             def setUpModule():
    430                 raise unittest.SkipTest('foo')
    431 
    432         Test.__module__ = 'Module'
    433         sys.modules['Module'] = Module
    434 
    435         result = self.runTests(Test)
    436         self.assertEqual(result.testsRun, 0)
    437         self.assertEqual(len(result.errors), 0)
    438         self.assertEqual(len(result.skipped), 1)
    439         skipped = result.skipped[0][0]
    440         self.assertEqual(str(skipped), 'setUpModule (Module)')
    441 
    442     def test_suite_debug_executes_setups_and_teardowns(self):
    443         ordering = []
    444 
    445         class Module(object):
    446             @staticmethod
    447             def setUpModule():
    448                 ordering.append('setUpModule')
    449             @staticmethod
    450             def tearDownModule():
    451                 ordering.append('tearDownModule')
    452 
    453         class Test(unittest.TestCase):
    454             @classmethod
    455             def setUpClass(cls):
    456                 ordering.append('setUpClass')
    457             @classmethod
    458             def tearDownClass(cls):
    459                 ordering.append('tearDownClass')
    460             def test_something(self):
    461                 ordering.append('test_something')
    462 
    463         Test.__module__ = 'Module'
    464         sys.modules['Module'] = Module
    465 
    466         suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
    467         suite.debug()
    468         expectedOrder = ['setUpModule', 'setUpClass', 'test_something', 'tearDownClass', 'tearDownModule']
    469         self.assertEqual(ordering, expectedOrder)
    470 
    471     def test_suite_debug_propagates_exceptions(self):
    472         class Module(object):
    473             @staticmethod
    474             def setUpModule():
    475                 if phase == 0:
    476                     raise Exception('setUpModule')
    477             @staticmethod
    478             def tearDownModule():
    479                 if phase == 1:
    480                     raise Exception('tearDownModule')
    481 
    482         class Test(unittest.TestCase):
    483             @classmethod
    484             def setUpClass(cls):
    485                 if phase == 2:
    486                     raise Exception('setUpClass')
    487             @classmethod
    488             def tearDownClass(cls):
    489                 if phase == 3:
    490                     raise Exception('tearDownClass')
    491             def test_something(self):
    492                 if phase == 4:
    493                     raise Exception('test_something')
    494 
    495         Test.__module__ = 'Module'
    496         sys.modules['Module'] = Module
    497 
    498         _suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
    499         suite = unittest.TestSuite()
    500         suite.addTest(_suite)
    501 
    502         messages = ('setUpModule', 'tearDownModule', 'setUpClass', 'tearDownClass', 'test_something')
    503         for phase, msg in enumerate(messages):
    504             with self.assertRaisesRegexp(Exception, msg):
    505                 suite.debug()
    506 
    507 if __name__ == '__main__':
    508     unittest.main()
    509