| import unittest | |
| from unittest.test.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() |