Debian Codegraph @

Lib/test/test_unittest/test_skipping.py

raw
1 import unittest
2
3 from test.support import force_not_colorized
4 from test.test_unittest.support import LoggingResult
5
6
7 class Test_TestSkipping(unittest.TestCase):
8
9 def test_skipping(self):
10 class Foo(unittest.TestCase):
11 def defaultTestResult(self):
12 return LoggingResult(events)
13 def test_skip_me(self):
14 self.skipTest("skip")
15 events = []
16 result = LoggingResult(events)
17 test = Foo("test_skip_me")
18 self.assertIs(test.run(result), result)
19 self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
20 self.assertEqual(result.skipped, [(test, "skip")])
21
22 events = []
23 result = test.run()
24 self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
25 'stopTest', 'stopTestRun'])
26 self.assertEqual(result.skipped, [(test, "skip")])
27 self.assertEqual(result.testsRun, 1)
28
29 # Try letting setUp skip the test now.
30 class Foo(unittest.TestCase):
31 def defaultTestResult(self):
32 return LoggingResult(events)
33 def setUp(self):
34 self.skipTest("testing")
35 def test_nothing(self): pass
36 events = []
37 result = LoggingResult(events)
38 test = Foo("test_nothing")
39 self.assertIs(test.run(result), result)
40 self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
41 self.assertEqual(result.skipped, [(test, "testing")])
42 self.assertEqual(result.testsRun, 1)
43
44 events = []
45 result = test.run()
46 self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
47 'stopTest', 'stopTestRun'])
48 self.assertEqual(result.skipped, [(test, "testing")])
49 self.assertEqual(result.testsRun, 1)
50
51 def test_skipping_subtests(self):
52 class Foo(unittest.TestCase):
53 def defaultTestResult(self):
54 return LoggingResult(events)
55 def test_skip_me(self):
56 with self.subTest(a=1):
57 with self.subTest(b=2):
58 self.skipTest("skip 1")
59 self.skipTest("skip 2")
60 self.skipTest("skip 3")
61 events = []
62 result = LoggingResult(events)
63 test = Foo("test_skip_me")
64 self.assertIs(test.run(result), result)
65 self.assertEqual(events, ['startTest', 'addSkip', 'addSkip',
66 'addSkip', 'stopTest'])
67 self.assertEqual(len(result.skipped), 3)
68 subtest, msg = result.skipped[0]
69 self.assertEqual(msg, "skip 1")
70 self.assertIsInstance(subtest, unittest.TestCase)
71 self.assertIsNot(subtest, test)
72 subtest, msg = result.skipped[1]
73 self.assertEqual(msg, "skip 2")
74 self.assertIsInstance(subtest, unittest.TestCase)
75 self.assertIsNot(subtest, test)
76 self.assertEqual(result.skipped[2], (test, "skip 3"))
77
78 events = []
79 result = test.run()
80 self.assertEqual(events,
81 ['startTestRun', 'startTest', 'addSkip', 'addSkip',
82 'addSkip', 'stopTest', 'stopTestRun'])
83 self.assertEqual([msg for subtest, msg in result.skipped],
84 ['skip 1', 'skip 2', 'skip 3'])
85
86 def test_skipping_decorators(self):
87 op_table = ((unittest.skipUnless, False, True),
88 (unittest.skipIf, True, False))
89 for deco, do_skip, dont_skip in op_table:
90 class Foo(unittest.TestCase):
91 def defaultTestResult(self):
92 return LoggingResult(events)
93
94 @deco(do_skip, "testing")
95 def test_skip(self): pass
96
97 @deco(dont_skip, "testing")
98 def test_dont_skip(self): pass
99 test_do_skip = Foo("test_skip")
100 test_dont_skip = Foo("test_dont_skip")
101
102 suite = unittest.TestSuite([test_do_skip, test_dont_skip])
103 events = []
104 result = LoggingResult(events)
105 self.assertIs(suite.run(result), result)
106 self.assertEqual(len(result.skipped), 1)
107 expected = ['startTest', 'addSkip', 'stopTest',
108 'startTest', 'addSuccess', 'stopTest']
109 self.assertEqual(events, expected)
110 self.assertEqual(result.testsRun, 2)
111 self.assertEqual(result.skipped, [(test_do_skip, "testing")])
112 self.assertTrue(result.wasSuccessful())
113
114 events = []
115 result = test_do_skip.run()
116 self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
117 'stopTest', 'stopTestRun'])
118 self.assertEqual(result.skipped, [(test_do_skip, "testing")])
119
120 events = []
121 result = test_dont_skip.run()
122 self.assertEqual(events, ['startTestRun', 'startTest', 'addSuccess',
123 'stopTest', 'stopTestRun'])
124 self.assertEqual(result.skipped, [])
125
126 def test_skip_class(self):
127 @unittest.skip("testing")
128 class Foo(unittest.TestCase):
129 def defaultTestResult(self):
130 return LoggingResult(events)
131 def test_1(self):
132 record.append(1)
133 events = []
134 record = []
135 result = LoggingResult(events)
136 test = Foo("test_1")
137 suite = unittest.TestSuite([test])
138 self.assertIs(suite.run(result), result)
139 self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
140 self.assertEqual(result.skipped, [(test, "testing")])
141 self.assertEqual(record, [])
142
143 events = []
144 result = test.run()
145 self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
146 'stopTest', 'stopTestRun'])
147 self.assertEqual(result.skipped, [(test, "testing")])
148 self.assertEqual(record, [])
149
150 def test_skip_non_unittest_class(self):
151 @unittest.skip("testing")
152 class Mixin:
153 def test_1(self):
154 record.append(1)
155 class Foo(Mixin, unittest.TestCase):
156 pass
157 record = []
158 result = unittest.TestResult()
159 test = Foo("test_1")
160 suite = unittest.TestSuite([test])
161 self.assertIs(suite.run(result), result)
162 self.assertEqual(result.skipped, [(test, "testing")])
163 self.assertEqual(record, [])
164
165 def test_skip_in_setup(self):
166 class Foo(unittest.TestCase):
167 def setUp(self):
168 self.skipTest("skip")
169 def test_skip_me(self):
170 self.fail("shouldn't come here")
171 events = []
172 result = LoggingResult(events)
173 test = Foo("test_skip_me")
174 self.assertIs(test.run(result), result)
175 self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
176 self.assertEqual(result.skipped, [(test, "skip")])
177
178 def test_skip_in_cleanup(self):
179 class Foo(unittest.TestCase):
180 def test_skip_me(self):
181 pass
182 def tearDown(self):
183 self.skipTest("skip")
184 events = []
185 result = LoggingResult(events)
186 test = Foo("test_skip_me")
187 self.assertIs(test.run(result), result)
188 self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
189 self.assertEqual(result.skipped, [(test, "skip")])
190
191 def test_failure_and_skip_in_cleanup(self):
192 class Foo(unittest.TestCase):
193 def test_skip_me(self):
194 self.fail("fail")
195 def tearDown(self):
196 self.skipTest("skip")
197 events = []
198 result = LoggingResult(events)
199 test = Foo("test_skip_me")
200 self.assertIs(test.run(result), result)
201 self.assertEqual(events, ['startTest', 'addFailure', 'addSkip', 'stopTest'])
202 self.assertEqual(result.skipped, [(test, "skip")])
203
204 def test_skipping_and_fail_in_cleanup(self):
205 class Foo(unittest.TestCase):
206 def test_skip_me(self):
207 self.skipTest("skip")
208 def tearDown(self):
209 self.fail("fail")
210 events = []
211 result = LoggingResult(events)
212 test = Foo("test_skip_me")
213 self.assertIs(test.run(result), result)
214 self.assertEqual(events, ['startTest', 'addSkip', 'addFailure', 'stopTest'])
215 self.assertEqual(result.skipped, [(test, "skip")])
216
217 def test_expected_failure(self):
218 class Foo(unittest.TestCase):
219 @unittest.expectedFailure
220 def test_die(self):
221 self.fail("help me!")
222 events = []
223 result = LoggingResult(events)
224 test = Foo("test_die")
225 self.assertIs(test.run(result), result)
226 self.assertEqual(events,
227 ['startTest', 'addExpectedFailure', 'stopTest'])
228 self.assertFalse(result.failures)
229 self.assertEqual(result.expectedFailures[0][0], test)
230 self.assertFalse(result.unexpectedSuccesses)
231 self.assertTrue(result.wasSuccessful())
232
233 def test_expected_failure_with_wrapped_class(self):
234 @unittest.expectedFailure
235 class Foo(unittest.TestCase):
236 def test_1(self):
237 self.assertTrue(False)
238
239 events = []
240 result = LoggingResult(events)
241 test = Foo("test_1")
242 self.assertIs(test.run(result), result)
243 self.assertEqual(events,
244 ['startTest', 'addExpectedFailure', 'stopTest'])
245 self.assertFalse(result.failures)
246 self.assertEqual(result.expectedFailures[0][0], test)
247 self.assertFalse(result.unexpectedSuccesses)
248 self.assertTrue(result.wasSuccessful())
249
250 def test_expected_failure_with_wrapped_subclass(self):
251 class Foo(unittest.TestCase):
252 def test_1(self):
253 self.assertTrue(False)
254
255 @unittest.expectedFailure
256 class Bar(Foo):
257 pass
258
259 events = []
260 result = LoggingResult(events)
261 test = Bar("test_1")
262 self.assertIs(test.run(result), result)
263 self.assertEqual(events,
264 ['startTest', 'addExpectedFailure', 'stopTest'])
265 self.assertFalse(result.failures)
266 self.assertEqual(result.expectedFailures[0][0], test)
267 self.assertFalse(result.unexpectedSuccesses)
268 self.assertTrue(result.wasSuccessful())
269
270 def test_expected_failure_subtests(self):
271 # A failure in any subtest counts as the expected failure of the
272 # whole test.
273 class Foo(unittest.TestCase):
274 @unittest.expectedFailure
275 def test_die(self):
276 with self.subTest():
277 # This one succeeds
278 pass
279 with self.subTest():
280 self.fail("help me!")
281 with self.subTest():
282 # This one doesn't get executed
283 self.fail("shouldn't come here")
284 events = []
285 result = LoggingResult(events)
286 test = Foo("test_die")
287 self.assertIs(test.run(result), result)
288 self.assertEqual(events,
289 ['startTest', 'addSubTestSuccess',
290 'addExpectedFailure', 'stopTest'])
291 self.assertFalse(result.failures)
292 self.assertEqual(len(result.expectedFailures), 1)
293 self.assertIs(result.expectedFailures[0][0], test)
294 self.assertFalse(result.unexpectedSuccesses)
295 self.assertTrue(result.wasSuccessful())
296
297 @force_not_colorized
298 def test_expected_failure_and_fail_in_cleanup(self):
299 class Foo(unittest.TestCase):
300 @unittest.expectedFailure
301 def test_die(self):
302 self.fail("help me!")
303 def tearDown(self):
304 self.fail("bad tearDown")
305 events = []
306 result = LoggingResult(events)
307 test = Foo("test_die")
308 self.assertIs(test.run(result), result)
309 self.assertEqual(events,
310 ['startTest', 'addFailure', 'stopTest'])
311 self.assertEqual(len(result.failures), 1)
312 self.assertIn('AssertionError: bad tearDown', result.failures[0][1])
313 self.assertFalse(result.expectedFailures)
314 self.assertFalse(result.unexpectedSuccesses)
315 self.assertFalse(result.wasSuccessful())
316
317 def test_expected_failure_and_skip_in_cleanup(self):
318 class Foo(unittest.TestCase):
319 @unittest.expectedFailure
320 def test_die(self):
321 self.fail("help me!")
322 def tearDown(self):
323 self.skipTest("skip")
324 events = []
325 result = LoggingResult(events)
326 test = Foo("test_die")
327 self.assertIs(test.run(result), result)
328 self.assertEqual(events,
329 ['startTest', 'addSkip', 'stopTest'])
330 self.assertFalse(result.failures)
331 self.assertFalse(result.expectedFailures)
332 self.assertFalse(result.unexpectedSuccesses)
333 self.assertEqual(result.skipped, [(test, "skip")])
334 self.assertTrue(result.wasSuccessful())
335
336 def test_unexpected_success(self):
337 class Foo(unittest.TestCase):
338 @unittest.expectedFailure
339 def test_die(self):
340 pass
341 events = []
342 result = LoggingResult(events)
343 test = Foo("test_die")
344 self.assertIs(test.run(result), result)
345 self.assertEqual(events,
346 ['startTest', 'addUnexpectedSuccess', 'stopTest'])
347 self.assertFalse(result.failures)
348 self.assertFalse(result.expectedFailures)
349 self.assertEqual(result.unexpectedSuccesses, [test])
350 self.assertFalse(result.wasSuccessful())
351
352 def test_unexpected_success_subtests(self):
353 # Success in all subtests counts as the unexpected success of
354 # the whole test.
355 class Foo(unittest.TestCase):
356 @unittest.expectedFailure
357 def test_die(self):
358 with self.subTest():
359 # This one succeeds
360 pass
361 with self.subTest():
362 # So does this one
363 pass
364 events = []
365 result = LoggingResult(events)
366 test = Foo("test_die")
367 self.assertIs(test.run(result), result)
368 self.assertEqual(events,
369 ['startTest',
370 'addSubTestSuccess', 'addSubTestSuccess',
371 'addUnexpectedSuccess', 'stopTest'])
372 self.assertFalse(result.failures)
373 self.assertFalse(result.expectedFailures)
374 self.assertEqual(result.unexpectedSuccesses, [test])
375 self.assertFalse(result.wasSuccessful())
376
377 @force_not_colorized
378 def test_unexpected_success_and_fail_in_cleanup(self):
379 class Foo(unittest.TestCase):
380 @unittest.expectedFailure
381 def test_die(self):
382 pass
383 def tearDown(self):
384 self.fail("bad tearDown")
385 events = []
386 result = LoggingResult(events)
387 test = Foo("test_die")
388 self.assertIs(test.run(result), result)
389 self.assertEqual(events,
390 ['startTest', 'addFailure', 'stopTest'])
391 self.assertEqual(len(result.failures), 1)
392 self.assertIn('AssertionError: bad tearDown', result.failures[0][1])
393 self.assertFalse(result.expectedFailures)
394 self.assertFalse(result.unexpectedSuccesses)
395 self.assertFalse(result.wasSuccessful())
396
397 def test_unexpected_success_and_skip_in_cleanup(self):
398 class Foo(unittest.TestCase):
399 @unittest.expectedFailure
400 def test_die(self):
401 pass
402 def tearDown(self):
403 self.skipTest("skip")
404 events = []
405 result = LoggingResult(events)
406 test = Foo("test_die")
407 self.assertIs(test.run(result), result)
408 self.assertEqual(events,
409 ['startTest', 'addSkip', 'stopTest'])
410 self.assertFalse(result.failures)
411 self.assertFalse(result.expectedFailures)
412 self.assertFalse(result.unexpectedSuccesses)
413 self.assertEqual(result.skipped, [(test, "skip")])
414 self.assertTrue(result.wasSuccessful())
415
416 def test_skip_doesnt_run_setup(self):
417 class Foo(unittest.TestCase):
418 wasSetUp = False
419 wasTornDown = False
420 def setUp(self):
421 Foo.wasSetUp = True
422 def tornDown(self):
423 Foo.wasTornDown = True
424 @unittest.skip('testing')
425 def test_1(self):
426 pass
427
428 result = unittest.TestResult()
429 test = Foo("test_1")
430 suite = unittest.TestSuite([test])
431 self.assertIs(suite.run(result), result)
432 self.assertEqual(result.skipped, [(test, "testing")])
433 self.assertFalse(Foo.wasSetUp)
434 self.assertFalse(Foo.wasTornDown)
435
436 def test_decorated_skip(self):
437 def decorator(func):
438 def inner(*a):
439 return func(*a)
440 return inner
441
442 class Foo(unittest.TestCase):
443 @decorator
444 @unittest.skip('testing')
445 def test_1(self):
446 pass
447
448 result = unittest.TestResult()
449 test = Foo("test_1")
450 suite = unittest.TestSuite([test])
451 self.assertIs(suite.run(result), result)
452 self.assertEqual(result.skipped, [(test, "testing")])
453
454 def test_skip_without_reason(self):
455 class Foo(unittest.TestCase):
456 @unittest.skip
457 def test_1(self):
458 pass
459
460 result = unittest.TestResult()
461 test = Foo("test_1")
462 suite = unittest.TestSuite([test])
463 self.assertIs(suite.run(result), result)
464 self.assertEqual(result.skipped, [(test, "")])
465
466 def test_debug_skipping(self):
467 class Foo(unittest.TestCase):
468 def setUp(self):
469 events.append("setUp")
470 def tearDown(self):
471 events.append("tearDown")
472 def test1(self):
473 self.skipTest('skipping exception')
474 events.append("test1")
475 @unittest.skip("skipping decorator")
476 def test2(self):
477 events.append("test2")
478
479 events = []
480 test = Foo("test1")
481 with self.assertRaises(unittest.SkipTest) as cm:
482 test.debug()
483 self.assertIn("skipping exception", str(cm.exception))
484 self.assertEqual(events, ["setUp"])
485
486 events = []
487 test = Foo("test2")
488 with self.assertRaises(unittest.SkipTest) as cm:
489 test.debug()
490 self.assertIn("skipping decorator", str(cm.exception))
491 self.assertEqual(events, [])
492
493 def test_debug_skipping_class(self):
494 @unittest.skip("testing")
495 class Foo(unittest.TestCase):
496 def setUp(self):
497 events.append("setUp")
498 def tearDown(self):
499 events.append("tearDown")
500 def test(self):
501 events.append("test")
502
503 events = []
504 test = Foo("test")
505 with self.assertRaises(unittest.SkipTest) as cm:
506 test.debug()
507 self.assertIn("testing", str(cm.exception))
508 self.assertEqual(events, [])
509
510 def test_debug_skipping_subtests(self):
511 class Foo(unittest.TestCase):
512 def setUp(self):
513 events.append("setUp")
514 def tearDown(self):
515 events.append("tearDown")
516 def test(self):
517 with self.subTest(a=1):
518 events.append('subtest')
519 self.skipTest("skip subtest")
520 events.append('end subtest')
521 events.append('end test')
522
523 events = []
524 result = LoggingResult(events)
525 test = Foo("test")
526 with self.assertRaises(unittest.SkipTest) as cm:
527 test.debug()
528 self.assertIn("skip subtest", str(cm.exception))
529 self.assertEqual(events, ['setUp', 'subtest'])
530
531
532 if __name__ == "__main__":
533 unittest.main()