summaryrefslogtreecommitdiffstats
path: root/Lib/test/test_unittest/test_skipping.py
diff options
context:
space:
mode:
Diffstat (limited to 'Lib/test/test_unittest/test_skipping.py')
-rw-r--r--Lib/test/test_unittest/test_skipping.py530
1 files changed, 530 insertions, 0 deletions
diff --git a/Lib/test/test_unittest/test_skipping.py b/Lib/test/test_unittest/test_skipping.py
new file mode 100644
index 0000000..f146dca
--- /dev/null
+++ b/Lib/test/test_unittest/test_skipping.py
@@ -0,0 +1,530 @@
+import unittest
+
+from test.test_unittest.support import LoggingResult
+
+
+class Test_TestSkipping(unittest.TestCase):
+
+ def test_skipping(self):
+ class Foo(unittest.TestCase):
+ def defaultTestResult(self):
+ return LoggingResult(events)
+ def test_skip_me(self):
+ self.skipTest("skip")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+
+ events = []
+ result = test.run()
+ self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
+ 'stopTest', 'stopTestRun'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+ self.assertEqual(result.testsRun, 1)
+
+ # Try letting setUp skip the test now.
+ class Foo(unittest.TestCase):
+ def defaultTestResult(self):
+ return LoggingResult(events)
+ def setUp(self):
+ self.skipTest("testing")
+ def test_nothing(self): pass
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_nothing")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertEqual(result.testsRun, 1)
+
+ events = []
+ result = test.run()
+ self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
+ 'stopTest', 'stopTestRun'])
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertEqual(result.testsRun, 1)
+
+ def test_skipping_subtests(self):
+ class Foo(unittest.TestCase):
+ def defaultTestResult(self):
+ return LoggingResult(events)
+ def test_skip_me(self):
+ with self.subTest(a=1):
+ with self.subTest(b=2):
+ self.skipTest("skip 1")
+ self.skipTest("skip 2")
+ self.skipTest("skip 3")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'addSkip',
+ 'addSkip', 'stopTest'])
+ self.assertEqual(len(result.skipped), 3)
+ subtest, msg = result.skipped[0]
+ self.assertEqual(msg, "skip 1")
+ self.assertIsInstance(subtest, unittest.TestCase)
+ self.assertIsNot(subtest, test)
+ subtest, msg = result.skipped[1]
+ self.assertEqual(msg, "skip 2")
+ self.assertIsInstance(subtest, unittest.TestCase)
+ self.assertIsNot(subtest, test)
+ self.assertEqual(result.skipped[2], (test, "skip 3"))
+
+ events = []
+ result = test.run()
+ self.assertEqual(events,
+ ['startTestRun', 'startTest', 'addSkip', 'addSkip',
+ 'addSkip', 'stopTest', 'stopTestRun'])
+ self.assertEqual([msg for subtest, msg in result.skipped],
+ ['skip 1', 'skip 2', 'skip 3'])
+
+ def test_skipping_decorators(self):
+ op_table = ((unittest.skipUnless, False, True),
+ (unittest.skipIf, True, False))
+ for deco, do_skip, dont_skip in op_table:
+ class Foo(unittest.TestCase):
+ def defaultTestResult(self):
+ return LoggingResult(events)
+
+ @deco(do_skip, "testing")
+ def test_skip(self): pass
+
+ @deco(dont_skip, "testing")
+ def test_dont_skip(self): pass
+ test_do_skip = Foo("test_skip")
+ test_dont_skip = Foo("test_dont_skip")
+
+ suite = unittest.TestSuite([test_do_skip, test_dont_skip])
+ events = []
+ result = LoggingResult(events)
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(len(result.skipped), 1)
+ expected = ['startTest', 'addSkip', 'stopTest',
+ 'startTest', 'addSuccess', 'stopTest']
+ self.assertEqual(events, expected)
+ self.assertEqual(result.testsRun, 2)
+ self.assertEqual(result.skipped, [(test_do_skip, "testing")])
+ self.assertTrue(result.wasSuccessful())
+
+ events = []
+ result = test_do_skip.run()
+ self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
+ 'stopTest', 'stopTestRun'])
+ self.assertEqual(result.skipped, [(test_do_skip, "testing")])
+
+ events = []
+ result = test_dont_skip.run()
+ self.assertEqual(events, ['startTestRun', 'startTest', 'addSuccess',
+ 'stopTest', 'stopTestRun'])
+ self.assertEqual(result.skipped, [])
+
+ def test_skip_class(self):
+ @unittest.skip("testing")
+ class Foo(unittest.TestCase):
+ def defaultTestResult(self):
+ return LoggingResult(events)
+ def test_1(self):
+ record.append(1)
+ events = []
+ record = []
+ result = LoggingResult(events)
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertEqual(record, [])
+
+ events = []
+ result = test.run()
+ self.assertEqual(events, ['startTestRun', 'startTest', 'addSkip',
+ 'stopTest', 'stopTestRun'])
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertEqual(record, [])
+
+ def test_skip_non_unittest_class(self):
+ @unittest.skip("testing")
+ class Mixin:
+ def test_1(self):
+ record.append(1)
+ class Foo(Mixin, unittest.TestCase):
+ pass
+ record = []
+ result = unittest.TestResult()
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertEqual(record, [])
+
+ def test_skip_in_setup(self):
+ class Foo(unittest.TestCase):
+ def setUp(self):
+ self.skipTest("skip")
+ def test_skip_me(self):
+ self.fail("shouldn't come here")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+
+ def test_skip_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ def test_skip_me(self):
+ pass
+ def tearDown(self):
+ self.skipTest("skip")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+
+ def test_failure_and_skip_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ def test_skip_me(self):
+ self.fail("fail")
+ def tearDown(self):
+ self.skipTest("skip")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addFailure', 'addSkip', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+
+ def test_skipping_and_fail_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ def test_skip_me(self):
+ self.skipTest("skip")
+ def tearDown(self):
+ self.fail("fail")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_skip_me")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events, ['startTest', 'addSkip', 'addFailure', 'stopTest'])
+ self.assertEqual(result.skipped, [(test, "skip")])
+
+ def test_expected_failure(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ self.fail("help me!")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addExpectedFailure', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertEqual(result.expectedFailures[0][0], test)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertTrue(result.wasSuccessful())
+
+ def test_expected_failure_with_wrapped_class(self):
+ @unittest.expectedFailure
+ class Foo(unittest.TestCase):
+ def test_1(self):
+ self.assertTrue(False)
+
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_1")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addExpectedFailure', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertEqual(result.expectedFailures[0][0], test)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertTrue(result.wasSuccessful())
+
+ def test_expected_failure_with_wrapped_subclass(self):
+ class Foo(unittest.TestCase):
+ def test_1(self):
+ self.assertTrue(False)
+
+ @unittest.expectedFailure
+ class Bar(Foo):
+ pass
+
+ events = []
+ result = LoggingResult(events)
+ test = Bar("test_1")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addExpectedFailure', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertEqual(result.expectedFailures[0][0], test)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertTrue(result.wasSuccessful())
+
+ def test_expected_failure_subtests(self):
+ # A failure in any subtest counts as the expected failure of the
+ # whole test.
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ with self.subTest():
+ # This one succeeds
+ pass
+ with self.subTest():
+ self.fail("help me!")
+ with self.subTest():
+ # This one doesn't get executed
+ self.fail("shouldn't come here")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addSubTestSuccess',
+ 'addExpectedFailure', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertEqual(len(result.expectedFailures), 1)
+ self.assertIs(result.expectedFailures[0][0], test)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertTrue(result.wasSuccessful())
+
+ def test_expected_failure_and_fail_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ self.fail("help me!")
+ def tearDown(self):
+ self.fail("bad tearDown")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addFailure', 'stopTest'])
+ self.assertEqual(len(result.failures), 1)
+ self.assertIn('AssertionError: bad tearDown', result.failures[0][1])
+ self.assertFalse(result.expectedFailures)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertFalse(result.wasSuccessful())
+
+ def test_expected_failure_and_skip_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ self.fail("help me!")
+ def tearDown(self):
+ self.skipTest("skip")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addSkip', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertFalse(result.expectedFailures)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertEqual(result.skipped, [(test, "skip")])
+ self.assertTrue(result.wasSuccessful())
+
+ def test_unexpected_success(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ pass
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addUnexpectedSuccess', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertFalse(result.expectedFailures)
+ self.assertEqual(result.unexpectedSuccesses, [test])
+ self.assertFalse(result.wasSuccessful())
+
+ def test_unexpected_success_subtests(self):
+ # Success in all subtests counts as the unexpected success of
+ # the whole test.
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ with self.subTest():
+ # This one succeeds
+ pass
+ with self.subTest():
+ # So does this one
+ pass
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest',
+ 'addSubTestSuccess', 'addSubTestSuccess',
+ 'addUnexpectedSuccess', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertFalse(result.expectedFailures)
+ self.assertEqual(result.unexpectedSuccesses, [test])
+ self.assertFalse(result.wasSuccessful())
+
+ def test_unexpected_success_and_fail_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ pass
+ def tearDown(self):
+ self.fail("bad tearDown")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addFailure', 'stopTest'])
+ self.assertEqual(len(result.failures), 1)
+ self.assertIn('AssertionError: bad tearDown', result.failures[0][1])
+ self.assertFalse(result.expectedFailures)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertFalse(result.wasSuccessful())
+
+ def test_unexpected_success_and_skip_in_cleanup(self):
+ class Foo(unittest.TestCase):
+ @unittest.expectedFailure
+ def test_die(self):
+ pass
+ def tearDown(self):
+ self.skipTest("skip")
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test_die")
+ self.assertIs(test.run(result), result)
+ self.assertEqual(events,
+ ['startTest', 'addSkip', 'stopTest'])
+ self.assertFalse(result.failures)
+ self.assertFalse(result.expectedFailures)
+ self.assertFalse(result.unexpectedSuccesses)
+ self.assertEqual(result.skipped, [(test, "skip")])
+ self.assertTrue(result.wasSuccessful())
+
+ def test_skip_doesnt_run_setup(self):
+ class Foo(unittest.TestCase):
+ wasSetUp = False
+ wasTornDown = False
+ def setUp(self):
+ Foo.wasSetUp = True
+ def tornDown(self):
+ Foo.wasTornDown = True
+ @unittest.skip('testing')
+ def test_1(self):
+ pass
+
+ result = unittest.TestResult()
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(result.skipped, [(test, "testing")])
+ self.assertFalse(Foo.wasSetUp)
+ self.assertFalse(Foo.wasTornDown)
+
+ def test_decorated_skip(self):
+ def decorator(func):
+ def inner(*a):
+ return func(*a)
+ return inner
+
+ class Foo(unittest.TestCase):
+ @decorator
+ @unittest.skip('testing')
+ def test_1(self):
+ pass
+
+ result = unittest.TestResult()
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(result.skipped, [(test, "testing")])
+
+ def test_skip_without_reason(self):
+ class Foo(unittest.TestCase):
+ @unittest.skip
+ def test_1(self):
+ pass
+
+ result = unittest.TestResult()
+ test = Foo("test_1")
+ suite = unittest.TestSuite([test])
+ self.assertIs(suite.run(result), result)
+ self.assertEqual(result.skipped, [(test, "")])
+
+ def test_debug_skipping(self):
+ class Foo(unittest.TestCase):
+ def setUp(self):
+ events.append("setUp")
+ def tearDown(self):
+ events.append("tearDown")
+ def test1(self):
+ self.skipTest('skipping exception')
+ events.append("test1")
+ @unittest.skip("skipping decorator")
+ def test2(self):
+ events.append("test2")
+
+ events = []
+ test = Foo("test1")
+ with self.assertRaises(unittest.SkipTest) as cm:
+ test.debug()
+ self.assertIn("skipping exception", str(cm.exception))
+ self.assertEqual(events, ["setUp"])
+
+ events = []
+ test = Foo("test2")
+ with self.assertRaises(unittest.SkipTest) as cm:
+ test.debug()
+ self.assertIn("skipping decorator", str(cm.exception))
+ self.assertEqual(events, [])
+
+ def test_debug_skipping_class(self):
+ @unittest.skip("testing")
+ class Foo(unittest.TestCase):
+ def setUp(self):
+ events.append("setUp")
+ def tearDown(self):
+ events.append("tearDown")
+ def test(self):
+ events.append("test")
+
+ events = []
+ test = Foo("test")
+ with self.assertRaises(unittest.SkipTest) as cm:
+ test.debug()
+ self.assertIn("testing", str(cm.exception))
+ self.assertEqual(events, [])
+
+ def test_debug_skipping_subtests(self):
+ class Foo(unittest.TestCase):
+ def setUp(self):
+ events.append("setUp")
+ def tearDown(self):
+ events.append("tearDown")
+ def test(self):
+ with self.subTest(a=1):
+ events.append('subtest')
+ self.skipTest("skip subtest")
+ events.append('end subtest')
+ events.append('end test')
+
+ events = []
+ result = LoggingResult(events)
+ test = Foo("test")
+ with self.assertRaises(unittest.SkipTest) as cm:
+ test.debug()
+ self.assertIn("skip subtest", str(cm.exception))
+ self.assertEqual(events, ['setUp', 'subtest'])
+
+
+if __name__ == "__main__":
+ unittest.main()
generated by cgit v0.12 at 2025-11-25 23:31:08 (GMT)