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