python (3.12.0)
1 import io
2 import os
3 import sys
4 import pickle
5 import subprocess
6 from test import support
7
8 import unittest
9 from unittest.case import _Outcome
10
11 from test.test_unittest.support import (
12 BufferedWriter,
13 LoggingResult,
14 ResultWithNoStartTestRunStopTestRun,
15 )
16
17
18 def resultFactory(*_):
19 return unittest.TestResult()
20
21
22 def getRunner():
23 return unittest.TextTestRunner(resultclass=resultFactory,
24 stream=io.StringIO())
25
26
27 class ESC[4;38;5;81mCustomError(ESC[4;38;5;149mException):
28 pass
29
30 # For test output compat:
31 CustomErrorRepr = f"{__name__ + '.' if __name__ != '__main__' else ''}CustomError"
32
33
34 def runTests(*cases):
35 suite = unittest.TestSuite()
36 for case in cases:
37 tests = unittest.defaultTestLoader.loadTestsFromTestCase(case)
38 suite.addTests(tests)
39
40 runner = getRunner()
41
42 # creating a nested suite exposes some potential bugs
43 realSuite = unittest.TestSuite()
44 realSuite.addTest(suite)
45 # adding empty suites to the end exposes potential bugs
46 suite.addTest(unittest.TestSuite())
47 realSuite.addTest(unittest.TestSuite())
48 return runner.run(realSuite)
49
50
51 def cleanup(ordering, blowUp=False):
52 if not blowUp:
53 ordering.append('cleanup_good')
54 else:
55 ordering.append('cleanup_exc')
56 raise CustomError('CleanUpExc')
57
58
59 class ESC[4;38;5;81mTestCM:
60 def __init__(self, ordering, enter_result=None):
61 self.ordering = ordering
62 self.enter_result = enter_result
63
64 def __enter__(self):
65 self.ordering.append('enter')
66 return self.enter_result
67
68 def __exit__(self, *exc_info):
69 self.ordering.append('exit')
70
71
72 class ESC[4;38;5;81mLacksEnterAndExit:
73 pass
74 class ESC[4;38;5;81mLacksEnter:
75 def __exit__(self, *exc_info):
76 pass
77 class ESC[4;38;5;81mLacksExit:
78 def __enter__(self):
79 pass
80
81
82 class ESC[4;38;5;81mTestCleanUp(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
83 def testCleanUp(self):
84 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
85 def testNothing(self):
86 pass
87
88 test = TestableTest('testNothing')
89 self.assertEqual(test._cleanups, [])
90
91 cleanups = []
92
93 def cleanup1(*args, **kwargs):
94 cleanups.append((1, args, kwargs))
95
96 def cleanup2(*args, **kwargs):
97 cleanups.append((2, args, kwargs))
98
99 test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')
100 test.addCleanup(cleanup2)
101
102 self.assertEqual(test._cleanups,
103 [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),
104 (cleanup2, (), {})])
105
106 self.assertTrue(test.doCleanups())
107 self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), dict(four='hello', five='goodbye'))])
108
109 def testCleanUpWithErrors(self):
110 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
111 def testNothing(self):
112 pass
113
114 test = TestableTest('testNothing')
115 result = unittest.TestResult()
116 outcome = test._outcome = _Outcome(result=result)
117
118 CleanUpExc = CustomError('foo')
119 exc2 = CustomError('bar')
120 def cleanup1():
121 raise CleanUpExc
122
123 def cleanup2():
124 raise exc2
125
126 test.addCleanup(cleanup1)
127 test.addCleanup(cleanup2)
128
129 self.assertFalse(test.doCleanups())
130 self.assertFalse(outcome.success)
131
132 (_, msg2), (_, msg1) = result.errors
133 self.assertIn('in cleanup1', msg1)
134 self.assertIn('raise CleanUpExc', msg1)
135 self.assertIn(f'{CustomErrorRepr}: foo', msg1)
136 self.assertIn('in cleanup2', msg2)
137 self.assertIn('raise exc2', msg2)
138 self.assertIn(f'{CustomErrorRepr}: bar', msg2)
139
140 def testCleanupInRun(self):
141 blowUp = False
142 ordering = []
143
144 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
145 def setUp(self):
146 ordering.append('setUp')
147 test.addCleanup(cleanup2)
148 if blowUp:
149 raise CustomError('foo')
150
151 def testNothing(self):
152 ordering.append('test')
153 test.addCleanup(cleanup3)
154
155 def tearDown(self):
156 ordering.append('tearDown')
157
158 test = TestableTest('testNothing')
159
160 def cleanup1():
161 ordering.append('cleanup1')
162 def cleanup2():
163 ordering.append('cleanup2')
164 def cleanup3():
165 ordering.append('cleanup3')
166 test.addCleanup(cleanup1)
167
168 def success(some_test):
169 self.assertEqual(some_test, test)
170 ordering.append('success')
171
172 result = unittest.TestResult()
173 result.addSuccess = success
174
175 test.run(result)
176 self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup3',
177 'cleanup2', 'cleanup1', 'success'])
178
179 blowUp = True
180 ordering = []
181 test = TestableTest('testNothing')
182 test.addCleanup(cleanup1)
183 test.run(result)
184 self.assertEqual(ordering, ['setUp', 'cleanup2', 'cleanup1'])
185
186 def testTestCaseDebugExecutesCleanups(self):
187 ordering = []
188
189 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
190 def setUp(self):
191 ordering.append('setUp')
192 self.addCleanup(cleanup1)
193
194 def testNothing(self):
195 ordering.append('test')
196 self.addCleanup(cleanup3)
197
198 def tearDown(self):
199 ordering.append('tearDown')
200 test.addCleanup(cleanup4)
201
202 test = TestableTest('testNothing')
203
204 def cleanup1():
205 ordering.append('cleanup1')
206 test.addCleanup(cleanup2)
207 def cleanup2():
208 ordering.append('cleanup2')
209 def cleanup3():
210 ordering.append('cleanup3')
211 def cleanup4():
212 ordering.append('cleanup4')
213
214 test.debug()
215 self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup4',
216 'cleanup3', 'cleanup1', 'cleanup2'])
217
218
219 def test_enterContext(self):
220 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
221 def testNothing(self):
222 pass
223
224 test = TestableTest('testNothing')
225 cleanups = []
226
227 test.addCleanup(cleanups.append, 'cleanup1')
228 cm = TestCM(cleanups, 42)
229 self.assertEqual(test.enterContext(cm), 42)
230 test.addCleanup(cleanups.append, 'cleanup2')
231
232 self.assertTrue(test.doCleanups())
233 self.assertEqual(cleanups, ['enter', 'cleanup2', 'exit', 'cleanup1'])
234
235 def test_enterContext_arg_errors(self):
236 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
237 def testNothing(self):
238 pass
239
240 test = TestableTest('testNothing')
241
242 with self.assertRaisesRegex(TypeError, 'the context manager'):
243 test.enterContext(LacksEnterAndExit())
244 with self.assertRaisesRegex(TypeError, 'the context manager'):
245 test.enterContext(LacksEnter())
246 with self.assertRaisesRegex(TypeError, 'the context manager'):
247 test.enterContext(LacksExit())
248
249 self.assertEqual(test._cleanups, [])
250
251
252 class ESC[4;38;5;81mTestClassCleanup(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
253 def test_addClassCleanUp(self):
254 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
255 def testNothing(self):
256 pass
257 test = TestableTest('testNothing')
258 self.assertEqual(test._class_cleanups, [])
259 class_cleanups = []
260
261 def class_cleanup1(*args, **kwargs):
262 class_cleanups.append((3, args, kwargs))
263
264 def class_cleanup2(*args, **kwargs):
265 class_cleanups.append((4, args, kwargs))
266
267 TestableTest.addClassCleanup(class_cleanup1, 1, 2, 3,
268 four='hello', five='goodbye')
269 TestableTest.addClassCleanup(class_cleanup2)
270
271 self.assertEqual(test._class_cleanups,
272 [(class_cleanup1, (1, 2, 3),
273 dict(four='hello', five='goodbye')),
274 (class_cleanup2, (), {})])
275
276 TestableTest.doClassCleanups()
277 self.assertEqual(class_cleanups, [(4, (), {}), (3, (1, 2, 3),
278 dict(four='hello', five='goodbye'))])
279
280 def test_run_class_cleanUp(self):
281 ordering = []
282 blowUp = True
283
284 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
285 @classmethod
286 def setUpClass(cls):
287 ordering.append('setUpClass')
288 cls.addClassCleanup(cleanup, ordering)
289 if blowUp:
290 raise CustomError()
291 def testNothing(self):
292 ordering.append('test')
293 @classmethod
294 def tearDownClass(cls):
295 ordering.append('tearDownClass')
296
297 runTests(TestableTest)
298 self.assertEqual(ordering, ['setUpClass', 'cleanup_good'])
299
300 ordering = []
301 blowUp = False
302 runTests(TestableTest)
303 self.assertEqual(ordering,
304 ['setUpClass', 'test', 'tearDownClass', 'cleanup_good'])
305
306 def test_run_class_cleanUp_without_tearDownClass(self):
307 ordering = []
308 blowUp = True
309
310 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
311 @classmethod
312 def setUpClass(cls):
313 ordering.append('setUpClass')
314 cls.addClassCleanup(cleanup, ordering)
315 if blowUp:
316 raise CustomError()
317 def testNothing(self):
318 ordering.append('test')
319 @classmethod
320 @property
321 def tearDownClass(cls):
322 raise AttributeError
323
324 runTests(TestableTest)
325 self.assertEqual(ordering, ['setUpClass', 'cleanup_good'])
326
327 ordering = []
328 blowUp = False
329 runTests(TestableTest)
330 self.assertEqual(ordering,
331 ['setUpClass', 'test', 'cleanup_good'])
332
333 def test_debug_executes_classCleanUp(self):
334 ordering = []
335 blowUp = False
336
337 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
338 @classmethod
339 def setUpClass(cls):
340 ordering.append('setUpClass')
341 cls.addClassCleanup(cleanup, ordering, blowUp=blowUp)
342 def testNothing(self):
343 ordering.append('test')
344 @classmethod
345 def tearDownClass(cls):
346 ordering.append('tearDownClass')
347
348 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
349 suite.debug()
350 self.assertEqual(ordering,
351 ['setUpClass', 'test', 'tearDownClass', 'cleanup_good'])
352
353 ordering = []
354 blowUp = True
355 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
356 with self.assertRaises(CustomError) as cm:
357 suite.debug()
358 self.assertEqual(str(cm.exception), 'CleanUpExc')
359 self.assertEqual(ordering,
360 ['setUpClass', 'test', 'tearDownClass', 'cleanup_exc'])
361
362 def test_debug_executes_classCleanUp_when_teardown_exception(self):
363 ordering = []
364 blowUp = False
365
366 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
367 @classmethod
368 def setUpClass(cls):
369 ordering.append('setUpClass')
370 cls.addClassCleanup(cleanup, ordering, blowUp=blowUp)
371 def testNothing(self):
372 ordering.append('test')
373 @classmethod
374 def tearDownClass(cls):
375 ordering.append('tearDownClass')
376 raise CustomError('TearDownClassExc')
377
378 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
379 with self.assertRaises(CustomError) as cm:
380 suite.debug()
381 self.assertEqual(str(cm.exception), 'TearDownClassExc')
382 self.assertEqual(ordering, ['setUpClass', 'test', 'tearDownClass'])
383 self.assertTrue(TestableTest._class_cleanups)
384 TestableTest._class_cleanups.clear()
385
386 ordering = []
387 blowUp = True
388 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
389 with self.assertRaises(CustomError) as cm:
390 suite.debug()
391 self.assertEqual(str(cm.exception), 'TearDownClassExc')
392 self.assertEqual(ordering, ['setUpClass', 'test', 'tearDownClass'])
393 self.assertTrue(TestableTest._class_cleanups)
394 TestableTest._class_cleanups.clear()
395
396 def test_doClassCleanups_with_errors_addClassCleanUp(self):
397 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
398 def testNothing(self):
399 pass
400
401 def cleanup1():
402 raise CustomError('cleanup1')
403
404 def cleanup2():
405 raise CustomError('cleanup2')
406
407 TestableTest.addClassCleanup(cleanup1)
408 TestableTest.addClassCleanup(cleanup2)
409 TestableTest.doClassCleanups()
410
411 self.assertEqual(len(TestableTest.tearDown_exceptions), 2)
412
413 e1, e2 = TestableTest.tearDown_exceptions
414 self.assertIsInstance(e1[1], CustomError)
415 self.assertEqual(str(e1[1]), 'cleanup2')
416 self.assertIsInstance(e2[1], CustomError)
417 self.assertEqual(str(e2[1]), 'cleanup1')
418
419 def test_with_errors_addCleanUp(self):
420 ordering = []
421 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
422 @classmethod
423 def setUpClass(cls):
424 ordering.append('setUpClass')
425 cls.addClassCleanup(cleanup, ordering)
426 def setUp(self):
427 ordering.append('setUp')
428 self.addCleanup(cleanup, ordering, blowUp=True)
429 def testNothing(self):
430 pass
431 @classmethod
432 def tearDownClass(cls):
433 ordering.append('tearDownClass')
434
435 result = runTests(TestableTest)
436 self.assertEqual(result.errors[0][1].splitlines()[-1],
437 f'{CustomErrorRepr}: CleanUpExc')
438 self.assertEqual(ordering,
439 ['setUpClass', 'setUp', 'cleanup_exc',
440 'tearDownClass', 'cleanup_good'])
441
442 def test_run_with_errors_addClassCleanUp(self):
443 ordering = []
444 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
445 @classmethod
446 def setUpClass(cls):
447 ordering.append('setUpClass')
448 cls.addClassCleanup(cleanup, ordering, blowUp=True)
449 def setUp(self):
450 ordering.append('setUp')
451 self.addCleanup(cleanup, ordering)
452 def testNothing(self):
453 ordering.append('test')
454 @classmethod
455 def tearDownClass(cls):
456 ordering.append('tearDownClass')
457
458 result = runTests(TestableTest)
459 self.assertEqual(result.errors[0][1].splitlines()[-1],
460 f'{CustomErrorRepr}: CleanUpExc')
461 self.assertEqual(ordering,
462 ['setUpClass', 'setUp', 'test', 'cleanup_good',
463 'tearDownClass', 'cleanup_exc'])
464
465 def test_with_errors_in_addClassCleanup_and_setUps(self):
466 ordering = []
467 class_blow_up = False
468 method_blow_up = False
469
470 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
471 @classmethod
472 def setUpClass(cls):
473 ordering.append('setUpClass')
474 cls.addClassCleanup(cleanup, ordering, blowUp=True)
475 if class_blow_up:
476 raise CustomError('ClassExc')
477 def setUp(self):
478 ordering.append('setUp')
479 if method_blow_up:
480 raise CustomError('MethodExc')
481 def testNothing(self):
482 ordering.append('test')
483 @classmethod
484 def tearDownClass(cls):
485 ordering.append('tearDownClass')
486
487 result = runTests(TestableTest)
488 self.assertEqual(result.errors[0][1].splitlines()[-1],
489 f'{CustomErrorRepr}: CleanUpExc')
490 self.assertEqual(ordering,
491 ['setUpClass', 'setUp', 'test',
492 'tearDownClass', 'cleanup_exc'])
493
494 ordering = []
495 class_blow_up = True
496 method_blow_up = False
497 result = runTests(TestableTest)
498 self.assertEqual(result.errors[0][1].splitlines()[-1],
499 f'{CustomErrorRepr}: ClassExc')
500 self.assertEqual(result.errors[1][1].splitlines()[-1],
501 f'{CustomErrorRepr}: CleanUpExc')
502 self.assertEqual(ordering,
503 ['setUpClass', 'cleanup_exc'])
504
505 ordering = []
506 class_blow_up = False
507 method_blow_up = True
508 result = runTests(TestableTest)
509 self.assertEqual(result.errors[0][1].splitlines()[-1],
510 f'{CustomErrorRepr}: MethodExc')
511 self.assertEqual(result.errors[1][1].splitlines()[-1],
512 f'{CustomErrorRepr}: CleanUpExc')
513 self.assertEqual(ordering,
514 ['setUpClass', 'setUp', 'tearDownClass',
515 'cleanup_exc'])
516
517 def test_with_errors_in_tearDownClass(self):
518 ordering = []
519 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
520 @classmethod
521 def setUpClass(cls):
522 ordering.append('setUpClass')
523 cls.addClassCleanup(cleanup, ordering)
524 def testNothing(self):
525 ordering.append('test')
526 @classmethod
527 def tearDownClass(cls):
528 ordering.append('tearDownClass')
529 raise CustomError('TearDownExc')
530
531 result = runTests(TestableTest)
532 self.assertEqual(result.errors[0][1].splitlines()[-1],
533 f'{CustomErrorRepr}: TearDownExc')
534 self.assertEqual(ordering,
535 ['setUpClass', 'test', 'tearDownClass', 'cleanup_good'])
536
537 def test_enterClassContext(self):
538 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
539 def testNothing(self):
540 pass
541
542 cleanups = []
543
544 TestableTest.addClassCleanup(cleanups.append, 'cleanup1')
545 cm = TestCM(cleanups, 42)
546 self.assertEqual(TestableTest.enterClassContext(cm), 42)
547 TestableTest.addClassCleanup(cleanups.append, 'cleanup2')
548
549 TestableTest.doClassCleanups()
550 self.assertEqual(cleanups, ['enter', 'cleanup2', 'exit', 'cleanup1'])
551
552 def test_enterClassContext_arg_errors(self):
553 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
554 def testNothing(self):
555 pass
556
557 with self.assertRaisesRegex(TypeError, 'the context manager'):
558 TestableTest.enterClassContext(LacksEnterAndExit())
559 with self.assertRaisesRegex(TypeError, 'the context manager'):
560 TestableTest.enterClassContext(LacksEnter())
561 with self.assertRaisesRegex(TypeError, 'the context manager'):
562 TestableTest.enterClassContext(LacksExit())
563
564 self.assertEqual(TestableTest._class_cleanups, [])
565
566 def test_run_nested_test(self):
567 ordering = []
568
569 class ESC[4;38;5;81mInnerTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
570 @classmethod
571 def setUpClass(cls):
572 ordering.append('inner setup')
573 cls.addClassCleanup(ordering.append, 'inner cleanup')
574 def test(self):
575 ordering.append('inner test')
576
577 class ESC[4;38;5;81mOuterTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
578 @classmethod
579 def setUpClass(cls):
580 ordering.append('outer setup')
581 cls.addClassCleanup(ordering.append, 'outer cleanup')
582 def test(self):
583 ordering.append('start outer test')
584 runTests(InnerTest)
585 ordering.append('end outer test')
586
587 runTests(OuterTest)
588 self.assertEqual(ordering, [
589 'outer setup', 'start outer test',
590 'inner setup', 'inner test', 'inner cleanup',
591 'end outer test', 'outer cleanup'])
592
593 def test_run_empty_suite_error_message(self):
594 class ESC[4;38;5;81mEmptyTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
595 pass
596
597 suite = unittest.defaultTestLoader.loadTestsFromTestCase(EmptyTest)
598 runner = getRunner()
599 runner.run(suite)
600
601 self.assertIn("\nNO TESTS RAN\n", runner.stream.getvalue())
602
603
604 class ESC[4;38;5;81mTestModuleCleanUp(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
605 def test_add_and_do_ModuleCleanup(self):
606 module_cleanups = []
607
608 def module_cleanup1(*args, **kwargs):
609 module_cleanups.append((3, args, kwargs))
610
611 def module_cleanup2(*args, **kwargs):
612 module_cleanups.append((4, args, kwargs))
613
614 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
615 unittest.addModuleCleanup(module_cleanup1, 1, 2, 3,
616 four='hello', five='goodbye')
617 unittest.addModuleCleanup(module_cleanup2)
618
619 self.assertEqual(unittest.case._module_cleanups,
620 [(module_cleanup1, (1, 2, 3),
621 dict(four='hello', five='goodbye')),
622 (module_cleanup2, (), {})])
623
624 unittest.case.doModuleCleanups()
625 self.assertEqual(module_cleanups, [(4, (), {}), (3, (1, 2, 3),
626 dict(four='hello', five='goodbye'))])
627 self.assertEqual(unittest.case._module_cleanups, [])
628
629 def test_doModuleCleanup_with_errors_in_addModuleCleanup(self):
630 module_cleanups = []
631
632 def module_cleanup_good(*args, **kwargs):
633 module_cleanups.append((3, args, kwargs))
634
635 def module_cleanup_bad(*args, **kwargs):
636 raise CustomError('CleanUpExc')
637
638 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
639 unittest.addModuleCleanup(module_cleanup_good, 1, 2, 3,
640 four='hello', five='goodbye')
641 unittest.addModuleCleanup(module_cleanup_bad)
642 self.assertEqual(unittest.case._module_cleanups,
643 [(module_cleanup_good, (1, 2, 3),
644 dict(four='hello', five='goodbye')),
645 (module_cleanup_bad, (), {})])
646 with self.assertRaises(CustomError) as e:
647 unittest.case.doModuleCleanups()
648 self.assertEqual(str(e.exception), 'CleanUpExc')
649 self.assertEqual(unittest.case._module_cleanups, [])
650
651 def test_addModuleCleanup_arg_errors(self):
652 cleanups = []
653 def cleanup(*args, **kwargs):
654 cleanups.append((args, kwargs))
655
656 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
657 unittest.addModuleCleanup(cleanup, 1, 2, function='hello')
658 with self.assertRaises(TypeError):
659 unittest.addModuleCleanup(function=cleanup, arg='hello')
660 with self.assertRaises(TypeError):
661 unittest.addModuleCleanup()
662 unittest.case.doModuleCleanups()
663 self.assertEqual(cleanups,
664 [((1, 2), {'function': 'hello'})])
665
666 def test_run_module_cleanUp(self):
667 blowUp = True
668 ordering = []
669 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
670 @staticmethod
671 def setUpModule():
672 ordering.append('setUpModule')
673 unittest.addModuleCleanup(cleanup, ordering)
674 if blowUp:
675 raise CustomError('setUpModule Exc')
676 @staticmethod
677 def tearDownModule():
678 ordering.append('tearDownModule')
679
680 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
681 @classmethod
682 def setUpClass(cls):
683 ordering.append('setUpClass')
684 def testNothing(self):
685 ordering.append('test')
686 @classmethod
687 def tearDownClass(cls):
688 ordering.append('tearDownClass')
689
690 TestableTest.__module__ = 'Module'
691 sys.modules['Module'] = Module
692 result = runTests(TestableTest)
693 self.assertEqual(ordering, ['setUpModule', 'cleanup_good'])
694 self.assertEqual(result.errors[0][1].splitlines()[-1],
695 f'{CustomErrorRepr}: setUpModule Exc')
696
697 ordering = []
698 blowUp = False
699 runTests(TestableTest)
700 self.assertEqual(ordering,
701 ['setUpModule', 'setUpClass', 'test', 'tearDownClass',
702 'tearDownModule', 'cleanup_good'])
703 self.assertEqual(unittest.case._module_cleanups, [])
704
705 def test_run_multiple_module_cleanUp(self):
706 blowUp = True
707 blowUp2 = False
708 ordering = []
709 class ESC[4;38;5;81mModule1(ESC[4;38;5;149mobject):
710 @staticmethod
711 def setUpModule():
712 ordering.append('setUpModule')
713 unittest.addModuleCleanup(cleanup, ordering)
714 if blowUp:
715 raise CustomError()
716 @staticmethod
717 def tearDownModule():
718 ordering.append('tearDownModule')
719
720 class ESC[4;38;5;81mModule2(ESC[4;38;5;149mobject):
721 @staticmethod
722 def setUpModule():
723 ordering.append('setUpModule2')
724 unittest.addModuleCleanup(cleanup, ordering)
725 if blowUp2:
726 raise CustomError()
727 @staticmethod
728 def tearDownModule():
729 ordering.append('tearDownModule2')
730
731 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
732 @classmethod
733 def setUpClass(cls):
734 ordering.append('setUpClass')
735 def testNothing(self):
736 ordering.append('test')
737 @classmethod
738 def tearDownClass(cls):
739 ordering.append('tearDownClass')
740
741 class ESC[4;38;5;81mTestableTest2(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
742 @classmethod
743 def setUpClass(cls):
744 ordering.append('setUpClass2')
745 def testNothing(self):
746 ordering.append('test2')
747 @classmethod
748 def tearDownClass(cls):
749 ordering.append('tearDownClass2')
750
751 TestableTest.__module__ = 'Module1'
752 sys.modules['Module1'] = Module1
753 TestableTest2.__module__ = 'Module2'
754 sys.modules['Module2'] = Module2
755 runTests(TestableTest, TestableTest2)
756 self.assertEqual(ordering, ['setUpModule', 'cleanup_good',
757 'setUpModule2', 'setUpClass2', 'test2',
758 'tearDownClass2', 'tearDownModule2',
759 'cleanup_good'])
760 ordering = []
761 blowUp = False
762 blowUp2 = True
763 runTests(TestableTest, TestableTest2)
764 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
765 'tearDownClass', 'tearDownModule',
766 'cleanup_good', 'setUpModule2',
767 'cleanup_good'])
768
769 ordering = []
770 blowUp = False
771 blowUp2 = False
772 runTests(TestableTest, TestableTest2)
773 self.assertEqual(ordering,
774 ['setUpModule', 'setUpClass', 'test', 'tearDownClass',
775 'tearDownModule', 'cleanup_good', 'setUpModule2',
776 'setUpClass2', 'test2', 'tearDownClass2',
777 'tearDownModule2', 'cleanup_good'])
778 self.assertEqual(unittest.case._module_cleanups, [])
779
780 def test_run_module_cleanUp_without_teardown(self):
781 ordering = []
782 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
783 @staticmethod
784 def setUpModule():
785 ordering.append('setUpModule')
786 unittest.addModuleCleanup(cleanup, ordering)
787
788 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
789 @classmethod
790 def setUpClass(cls):
791 ordering.append('setUpClass')
792 def testNothing(self):
793 ordering.append('test')
794 @classmethod
795 def tearDownClass(cls):
796 ordering.append('tearDownClass')
797
798 TestableTest.__module__ = 'Module'
799 sys.modules['Module'] = Module
800 runTests(TestableTest)
801 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
802 'tearDownClass', 'cleanup_good'])
803 self.assertEqual(unittest.case._module_cleanups, [])
804
805 def test_run_module_cleanUp_when_teardown_exception(self):
806 ordering = []
807 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
808 @staticmethod
809 def setUpModule():
810 ordering.append('setUpModule')
811 unittest.addModuleCleanup(cleanup, ordering)
812 @staticmethod
813 def tearDownModule():
814 ordering.append('tearDownModule')
815 raise CustomError('CleanUpExc')
816
817 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
818 @classmethod
819 def setUpClass(cls):
820 ordering.append('setUpClass')
821 def testNothing(self):
822 ordering.append('test')
823 @classmethod
824 def tearDownClass(cls):
825 ordering.append('tearDownClass')
826
827 TestableTest.__module__ = 'Module'
828 sys.modules['Module'] = Module
829 result = runTests(TestableTest)
830 self.assertEqual(result.errors[0][1].splitlines()[-1],
831 f'{CustomErrorRepr}: CleanUpExc')
832 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
833 'tearDownClass', 'tearDownModule',
834 'cleanup_good'])
835 self.assertEqual(unittest.case._module_cleanups, [])
836
837 def test_debug_module_executes_cleanUp(self):
838 ordering = []
839 blowUp = False
840 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
841 @staticmethod
842 def setUpModule():
843 ordering.append('setUpModule')
844 unittest.addModuleCleanup(cleanup, ordering, blowUp=blowUp)
845 @staticmethod
846 def tearDownModule():
847 ordering.append('tearDownModule')
848
849 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
850 @classmethod
851 def setUpClass(cls):
852 ordering.append('setUpClass')
853 def testNothing(self):
854 ordering.append('test')
855 @classmethod
856 def tearDownClass(cls):
857 ordering.append('tearDownClass')
858
859 TestableTest.__module__ = 'Module'
860 sys.modules['Module'] = Module
861 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
862 suite.debug()
863 self.assertEqual(ordering,
864 ['setUpModule', 'setUpClass', 'test', 'tearDownClass',
865 'tearDownModule', 'cleanup_good'])
866 self.assertEqual(unittest.case._module_cleanups, [])
867
868 ordering = []
869 blowUp = True
870 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
871 with self.assertRaises(CustomError) as cm:
872 suite.debug()
873 self.assertEqual(str(cm.exception), 'CleanUpExc')
874 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
875 'tearDownClass', 'tearDownModule', 'cleanup_exc'])
876 self.assertEqual(unittest.case._module_cleanups, [])
877
878 def test_debug_module_cleanUp_when_teardown_exception(self):
879 ordering = []
880 blowUp = False
881 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
882 @staticmethod
883 def setUpModule():
884 ordering.append('setUpModule')
885 unittest.addModuleCleanup(cleanup, ordering, blowUp=blowUp)
886 @staticmethod
887 def tearDownModule():
888 ordering.append('tearDownModule')
889 raise CustomError('TearDownModuleExc')
890
891 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
892 @classmethod
893 def setUpClass(cls):
894 ordering.append('setUpClass')
895 def testNothing(self):
896 ordering.append('test')
897 @classmethod
898 def tearDownClass(cls):
899 ordering.append('tearDownClass')
900
901 TestableTest.__module__ = 'Module'
902 sys.modules['Module'] = Module
903 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
904 with self.assertRaises(CustomError) as cm:
905 suite.debug()
906 self.assertEqual(str(cm.exception), 'TearDownModuleExc')
907 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
908 'tearDownClass', 'tearDownModule'])
909 self.assertTrue(unittest.case._module_cleanups)
910 unittest.case._module_cleanups.clear()
911
912 ordering = []
913 blowUp = True
914 suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
915 with self.assertRaises(CustomError) as cm:
916 suite.debug()
917 self.assertEqual(str(cm.exception), 'TearDownModuleExc')
918 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
919 'tearDownClass', 'tearDownModule'])
920 self.assertTrue(unittest.case._module_cleanups)
921 unittest.case._module_cleanups.clear()
922
923 def test_addClassCleanup_arg_errors(self):
924 cleanups = []
925 def cleanup(*args, **kwargs):
926 cleanups.append((args, kwargs))
927
928 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
929 @classmethod
930 def setUpClass(cls):
931 cls.addClassCleanup(cleanup, 1, 2, function=3, cls=4)
932 with self.assertRaises(TypeError):
933 cls.addClassCleanup(function=cleanup, arg='hello')
934 def testNothing(self):
935 pass
936
937 with self.assertRaises(TypeError):
938 TestableTest.addClassCleanup()
939 with self.assertRaises(TypeError):
940 unittest.TestCase.addCleanup(cls=TestableTest(), function=cleanup)
941 runTests(TestableTest)
942 self.assertEqual(cleanups,
943 [((1, 2), {'function': 3, 'cls': 4})])
944
945 def test_addCleanup_arg_errors(self):
946 cleanups = []
947 def cleanup(*args, **kwargs):
948 cleanups.append((args, kwargs))
949
950 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
951 def setUp(self2):
952 self2.addCleanup(cleanup, 1, 2, function=3, self=4)
953 with self.assertRaises(TypeError):
954 self2.addCleanup(function=cleanup, arg='hello')
955 def testNothing(self):
956 pass
957
958 with self.assertRaises(TypeError):
959 TestableTest().addCleanup()
960 with self.assertRaises(TypeError):
961 unittest.TestCase.addCleanup(self=TestableTest(), function=cleanup)
962 runTests(TestableTest)
963 self.assertEqual(cleanups,
964 [((1, 2), {'function': 3, 'self': 4})])
965
966 def test_with_errors_in_addClassCleanup(self):
967 ordering = []
968
969 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
970 @staticmethod
971 def setUpModule():
972 ordering.append('setUpModule')
973 unittest.addModuleCleanup(cleanup, ordering)
974 @staticmethod
975 def tearDownModule():
976 ordering.append('tearDownModule')
977
978 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
979 @classmethod
980 def setUpClass(cls):
981 ordering.append('setUpClass')
982 cls.addClassCleanup(cleanup, ordering, blowUp=True)
983 def testNothing(self):
984 ordering.append('test')
985 @classmethod
986 def tearDownClass(cls):
987 ordering.append('tearDownClass')
988
989 TestableTest.__module__ = 'Module'
990 sys.modules['Module'] = Module
991
992 result = runTests(TestableTest)
993 self.assertEqual(result.errors[0][1].splitlines()[-1],
994 f'{CustomErrorRepr}: CleanUpExc')
995 self.assertEqual(ordering,
996 ['setUpModule', 'setUpClass', 'test', 'tearDownClass',
997 'cleanup_exc', 'tearDownModule', 'cleanup_good'])
998
999 def test_with_errors_in_addCleanup(self):
1000 ordering = []
1001 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
1002 @staticmethod
1003 def setUpModule():
1004 ordering.append('setUpModule')
1005 unittest.addModuleCleanup(cleanup, ordering)
1006 @staticmethod
1007 def tearDownModule():
1008 ordering.append('tearDownModule')
1009
1010 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1011 def setUp(self):
1012 ordering.append('setUp')
1013 self.addCleanup(cleanup, ordering, blowUp=True)
1014 def testNothing(self):
1015 ordering.append('test')
1016 def tearDown(self):
1017 ordering.append('tearDown')
1018
1019 TestableTest.__module__ = 'Module'
1020 sys.modules['Module'] = Module
1021
1022 result = runTests(TestableTest)
1023 self.assertEqual(result.errors[0][1].splitlines()[-1],
1024 f'{CustomErrorRepr}: CleanUpExc')
1025 self.assertEqual(ordering,
1026 ['setUpModule', 'setUp', 'test', 'tearDown',
1027 'cleanup_exc', 'tearDownModule', 'cleanup_good'])
1028
1029 def test_with_errors_in_addModuleCleanup_and_setUps(self):
1030 ordering = []
1031 module_blow_up = False
1032 class_blow_up = False
1033 method_blow_up = False
1034 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
1035 @staticmethod
1036 def setUpModule():
1037 ordering.append('setUpModule')
1038 unittest.addModuleCleanup(cleanup, ordering, blowUp=True)
1039 if module_blow_up:
1040 raise CustomError('ModuleExc')
1041 @staticmethod
1042 def tearDownModule():
1043 ordering.append('tearDownModule')
1044
1045 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1046 @classmethod
1047 def setUpClass(cls):
1048 ordering.append('setUpClass')
1049 if class_blow_up:
1050 raise CustomError('ClassExc')
1051 def setUp(self):
1052 ordering.append('setUp')
1053 if method_blow_up:
1054 raise CustomError('MethodExc')
1055 def testNothing(self):
1056 ordering.append('test')
1057 @classmethod
1058 def tearDownClass(cls):
1059 ordering.append('tearDownClass')
1060
1061 TestableTest.__module__ = 'Module'
1062 sys.modules['Module'] = Module
1063
1064 result = runTests(TestableTest)
1065 self.assertEqual(result.errors[0][1].splitlines()[-1],
1066 f'{CustomErrorRepr}: CleanUpExc')
1067 self.assertEqual(ordering,
1068 ['setUpModule', 'setUpClass', 'setUp', 'test',
1069 'tearDownClass', 'tearDownModule',
1070 'cleanup_exc'])
1071
1072 ordering = []
1073 module_blow_up = True
1074 class_blow_up = False
1075 method_blow_up = False
1076 result = runTests(TestableTest)
1077 self.assertEqual(result.errors[0][1].splitlines()[-1],
1078 f'{CustomErrorRepr}: ModuleExc')
1079 self.assertEqual(result.errors[1][1].splitlines()[-1],
1080 f'{CustomErrorRepr}: CleanUpExc')
1081 self.assertEqual(ordering, ['setUpModule', 'cleanup_exc'])
1082
1083 ordering = []
1084 module_blow_up = False
1085 class_blow_up = True
1086 method_blow_up = False
1087 result = runTests(TestableTest)
1088 self.assertEqual(result.errors[0][1].splitlines()[-1],
1089 f'{CustomErrorRepr}: ClassExc')
1090 self.assertEqual(result.errors[1][1].splitlines()[-1],
1091 f'{CustomErrorRepr}: CleanUpExc')
1092 self.assertEqual(ordering, ['setUpModule', 'setUpClass',
1093 'tearDownModule', 'cleanup_exc'])
1094
1095 ordering = []
1096 module_blow_up = False
1097 class_blow_up = False
1098 method_blow_up = True
1099 result = runTests(TestableTest)
1100 self.assertEqual(result.errors[0][1].splitlines()[-1],
1101 f'{CustomErrorRepr}: MethodExc')
1102 self.assertEqual(result.errors[1][1].splitlines()[-1],
1103 f'{CustomErrorRepr}: CleanUpExc')
1104 self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'setUp',
1105 'tearDownClass', 'tearDownModule',
1106 'cleanup_exc'])
1107
1108 def test_module_cleanUp_with_multiple_classes(self):
1109 ordering =[]
1110 def cleanup1():
1111 ordering.append('cleanup1')
1112
1113 def cleanup2():
1114 ordering.append('cleanup2')
1115
1116 def cleanup3():
1117 ordering.append('cleanup3')
1118
1119 class ESC[4;38;5;81mModule(ESC[4;38;5;149mobject):
1120 @staticmethod
1121 def setUpModule():
1122 ordering.append('setUpModule')
1123 unittest.addModuleCleanup(cleanup1)
1124 @staticmethod
1125 def tearDownModule():
1126 ordering.append('tearDownModule')
1127
1128 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1129 def setUp(self):
1130 ordering.append('setUp')
1131 self.addCleanup(cleanup2)
1132 def testNothing(self):
1133 ordering.append('test')
1134 def tearDown(self):
1135 ordering.append('tearDown')
1136
1137 class ESC[4;38;5;81mOtherTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1138 def setUp(self):
1139 ordering.append('setUp2')
1140 self.addCleanup(cleanup3)
1141 def testNothing(self):
1142 ordering.append('test2')
1143 def tearDown(self):
1144 ordering.append('tearDown2')
1145
1146 TestableTest.__module__ = 'Module'
1147 OtherTestableTest.__module__ = 'Module'
1148 sys.modules['Module'] = Module
1149 runTests(TestableTest, OtherTestableTest)
1150 self.assertEqual(ordering,
1151 ['setUpModule', 'setUp', 'test', 'tearDown',
1152 'cleanup2', 'setUp2', 'test2', 'tearDown2',
1153 'cleanup3', 'tearDownModule', 'cleanup1'])
1154
1155 def test_enterModuleContext(self):
1156 cleanups = []
1157
1158 unittest.addModuleCleanup(cleanups.append, 'cleanup1')
1159 cm = TestCM(cleanups, 42)
1160 self.assertEqual(unittest.enterModuleContext(cm), 42)
1161 unittest.addModuleCleanup(cleanups.append, 'cleanup2')
1162
1163 unittest.case.doModuleCleanups()
1164 self.assertEqual(cleanups, ['enter', 'cleanup2', 'exit', 'cleanup1'])
1165
1166 def test_enterModuleContext_arg_errors(self):
1167 class ESC[4;38;5;81mTestableTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1168 def testNothing(self):
1169 pass
1170
1171 with self.assertRaisesRegex(TypeError, 'the context manager'):
1172 unittest.enterModuleContext(LacksEnterAndExit())
1173 with self.assertRaisesRegex(TypeError, 'the context manager'):
1174 unittest.enterModuleContext(LacksEnter())
1175 with self.assertRaisesRegex(TypeError, 'the context manager'):
1176 unittest.enterModuleContext(LacksExit())
1177
1178 self.assertEqual(unittest.case._module_cleanups, [])
1179
1180
1181 class ESC[4;38;5;81mTest_TextTestRunner(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1182 """Tests for TextTestRunner."""
1183
1184 def setUp(self):
1185 # clean the environment from pre-existing PYTHONWARNINGS to make
1186 # test_warnings results consistent
1187 self.pythonwarnings = os.environ.get('PYTHONWARNINGS')
1188 if self.pythonwarnings:
1189 del os.environ['PYTHONWARNINGS']
1190
1191 def tearDown(self):
1192 # bring back pre-existing PYTHONWARNINGS if present
1193 if self.pythonwarnings:
1194 os.environ['PYTHONWARNINGS'] = self.pythonwarnings
1195
1196 def test_init(self):
1197 runner = unittest.TextTestRunner()
1198 self.assertFalse(runner.failfast)
1199 self.assertFalse(runner.buffer)
1200 self.assertEqual(runner.verbosity, 1)
1201 self.assertEqual(runner.warnings, None)
1202 self.assertTrue(runner.descriptions)
1203 self.assertEqual(runner.resultclass, unittest.TextTestResult)
1204 self.assertFalse(runner.tb_locals)
1205 self.assertIsNone(runner.durations)
1206
1207 def test_multiple_inheritance(self):
1208 class ESC[4;38;5;81mAResult(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestResult):
1209 def __init__(self, stream, descriptions, verbosity):
1210 super(AResult, self).__init__(stream, descriptions, verbosity)
1211
1212 class ESC[4;38;5;81mATextResult(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTextTestResult, ESC[4;38;5;149mAResult):
1213 pass
1214
1215 # This used to raise an exception due to TextTestResult not passing
1216 # on arguments in its __init__ super call
1217 ATextResult(None, None, 1)
1218
1219 def testBufferAndFailfast(self):
1220 class ESC[4;38;5;81mTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1221 def testFoo(self):
1222 pass
1223 result = unittest.TestResult()
1224 runner = unittest.TextTestRunner(stream=io.StringIO(), failfast=True,
1225 buffer=True)
1226 # Use our result object
1227 runner._makeResult = lambda: result
1228 runner.run(Test('testFoo'))
1229
1230 self.assertTrue(result.failfast)
1231 self.assertTrue(result.buffer)
1232
1233 def test_locals(self):
1234 runner = unittest.TextTestRunner(stream=io.StringIO(), tb_locals=True)
1235 result = runner.run(unittest.TestSuite())
1236 self.assertEqual(True, result.tb_locals)
1237
1238 def testRunnerRegistersResult(self):
1239 class ESC[4;38;5;81mTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1240 def testFoo(self):
1241 pass
1242 originalRegisterResult = unittest.runner.registerResult
1243 def cleanup():
1244 unittest.runner.registerResult = originalRegisterResult
1245 self.addCleanup(cleanup)
1246
1247 result = unittest.TestResult()
1248 runner = unittest.TextTestRunner(stream=io.StringIO())
1249 # Use our result object
1250 runner._makeResult = lambda: result
1251
1252 self.wasRegistered = 0
1253 def fakeRegisterResult(thisResult):
1254 self.wasRegistered += 1
1255 self.assertEqual(thisResult, result)
1256 unittest.runner.registerResult = fakeRegisterResult
1257
1258 runner.run(unittest.TestSuite())
1259 self.assertEqual(self.wasRegistered, 1)
1260
1261 def test_works_with_result_without_startTestRun_stopTestRun(self):
1262 class ESC[4;38;5;81mOldTextResult(ESC[4;38;5;149mResultWithNoStartTestRunStopTestRun):
1263 separator2 = ''
1264 def printErrors(self):
1265 pass
1266
1267 class ESC[4;38;5;81mRunner(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTextTestRunner):
1268 def __init__(self):
1269 super(Runner, self).__init__(io.StringIO())
1270
1271 def _makeResult(self):
1272 return OldTextResult()
1273
1274 runner = Runner()
1275 runner.run(unittest.TestSuite())
1276
1277 def test_startTestRun_stopTestRun_called(self):
1278 class ESC[4;38;5;81mLoggingTextResult(ESC[4;38;5;149mLoggingResult):
1279 separator2 = ''
1280 def printErrors(self):
1281 pass
1282
1283 class ESC[4;38;5;81mLoggingRunner(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTextTestRunner):
1284 def __init__(self, events):
1285 super(LoggingRunner, self).__init__(io.StringIO())
1286 self._events = events
1287
1288 def _makeResult(self):
1289 return LoggingTextResult(self._events)
1290
1291 events = []
1292 runner = LoggingRunner(events)
1293 runner.run(unittest.TestSuite())
1294 expected = ['startTestRun', 'stopTestRun']
1295 self.assertEqual(events, expected)
1296
1297 def test_pickle_unpickle(self):
1298 # Issue #7197: a TextTestRunner should be (un)pickleable. This is
1299 # required by test_multiprocessing under Windows (in verbose mode).
1300 stream = io.StringIO("foo")
1301 runner = unittest.TextTestRunner(stream)
1302 for protocol in range(2, pickle.HIGHEST_PROTOCOL + 1):
1303 s = pickle.dumps(runner, protocol)
1304 obj = pickle.loads(s)
1305 # StringIO objects never compare equal, a cheap test instead.
1306 self.assertEqual(obj.stream.getvalue(), stream.getvalue())
1307
1308 def test_resultclass(self):
1309 def MockResultClass(*args):
1310 return args
1311 STREAM = object()
1312 DESCRIPTIONS = object()
1313 VERBOSITY = object()
1314 runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,
1315 resultclass=MockResultClass)
1316 self.assertEqual(runner.resultclass, MockResultClass)
1317
1318 expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
1319 self.assertEqual(runner._makeResult(), expectedresult)
1320
1321 @support.requires_subprocess()
1322 def test_warnings(self):
1323 """
1324 Check that warnings argument of TextTestRunner correctly affects the
1325 behavior of the warnings.
1326 """
1327 # see #10535 and the _test_warnings file for more information
1328
1329 def get_parse_out_err(p):
1330 return [b.splitlines() for b in p.communicate()]
1331 opts = dict(stdout=subprocess.PIPE, stderr=subprocess.PIPE,
1332 cwd=os.path.dirname(__file__))
1333
1334 # no args -> all the warnings are printed, unittest warnings only once
1335 p = subprocess.Popen([sys.executable, '-E', '_test_warnings.py'], **opts)
1336 with p:
1337 out, err = get_parse_out_err(p)
1338 self.assertIn(b'OK', err)
1339 # check that the total number of warnings in the output is correct
1340 self.assertEqual(len(out), 10)
1341 # check that the numbers of the different kind of warnings is correct
1342 for msg in [b'dw', b'iw', b'uw']:
1343 self.assertEqual(out.count(msg), 3)
1344 for msg in [b'rw']:
1345 self.assertEqual(out.count(msg), 1)
1346
1347 args_list = (
1348 # passing 'ignore' as warnings arg -> no warnings
1349 [sys.executable, '_test_warnings.py', 'ignore'],
1350 # -W doesn't affect the result if the arg is passed
1351 [sys.executable, '-Wa', '_test_warnings.py', 'ignore'],
1352 # -W affects the result if the arg is not passed
1353 [sys.executable, '-Wi', '_test_warnings.py']
1354 )
1355 # in all these cases no warnings are printed
1356 for args in args_list:
1357 p = subprocess.Popen(args, **opts)
1358 with p:
1359 out, err = get_parse_out_err(p)
1360 self.assertIn(b'OK', err)
1361 self.assertEqual(len(out), 0)
1362
1363
1364 # passing 'always' as warnings arg -> all the warnings printed,
1365 # unittest warnings only once
1366 p = subprocess.Popen([sys.executable, '_test_warnings.py', 'always'],
1367 **opts)
1368 with p:
1369 out, err = get_parse_out_err(p)
1370 self.assertIn(b'OK', err)
1371 self.assertEqual(len(out), 12)
1372 for msg in [b'dw', b'iw', b'uw', b'rw']:
1373 self.assertEqual(out.count(msg), 3)
1374
1375 def testStdErrLookedUpAtInstantiationTime(self):
1376 # see issue 10786
1377 old_stderr = sys.stderr
1378 f = io.StringIO()
1379 sys.stderr = f
1380 try:
1381 runner = unittest.TextTestRunner()
1382 self.assertTrue(runner.stream.stream is f)
1383 finally:
1384 sys.stderr = old_stderr
1385
1386 def testSpecifiedStreamUsed(self):
1387 # see issue 10786
1388 f = io.StringIO()
1389 runner = unittest.TextTestRunner(f)
1390 self.assertTrue(runner.stream.stream is f)
1391
1392 def test_durations(self):
1393 def run(test, *, expect_durations=True):
1394 stream = BufferedWriter()
1395 runner = unittest.TextTestRunner(stream=stream, durations=5, verbosity=2)
1396 result = runner.run(test)
1397 self.assertEqual(result.durations, 5)
1398 stream.flush()
1399 text = stream.getvalue()
1400 regex = r"\n\d+.\d\d\ds"
1401 if expect_durations:
1402 self.assertEqual(len(result.collectedDurations), 1)
1403 self.assertIn('Slowest test durations', text)
1404 self.assertRegex(text, regex)
1405 else:
1406 self.assertEqual(len(result.collectedDurations), 0)
1407 self.assertNotIn('Slowest test durations', text)
1408 self.assertNotRegex(text, regex)
1409
1410 # success
1411 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1412 def test_1(self):
1413 pass
1414
1415 run(Foo('test_1'), expect_durations=True)
1416
1417 # failure
1418 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1419 def test_1(self):
1420 self.assertEqual(0, 1)
1421
1422 run(Foo('test_1'), expect_durations=True)
1423
1424 # error
1425 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1426 def test_1(self):
1427 1 / 0
1428
1429 run(Foo('test_1'), expect_durations=True)
1430
1431
1432 # error in setUp and tearDown
1433 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1434 def setUp(self):
1435 1 / 0
1436 tearDown = setUp
1437 def test_1(self):
1438 pass
1439
1440 run(Foo('test_1'), expect_durations=True)
1441
1442 # skip (expect no durations)
1443 class ESC[4;38;5;81mFoo(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
1444 @unittest.skip("reason")
1445 def test_1(self):
1446 pass
1447
1448 run(Foo('test_1'), expect_durations=False)
1449
1450
1451
1452 if __name__ == "__main__":
1453 unittest.main()
Browse
Usage
Versions