Michael Foord | 2560e5c | 2010-03-27 12:34:21 +0000 | [diff] [blame] | 1 | import unittest |
| 2 | |
| 3 | from .support import LoggingResult |
| 4 | |
| 5 | |
| 6 | class Test_TestSkipping(unittest.TestCase): |
| 7 | |
| 8 | def test_skipping(self): |
| 9 | class Foo(unittest.TestCase): |
| 10 | def test_skip_me(self): |
| 11 | self.skipTest("skip") |
| 12 | events = [] |
| 13 | result = LoggingResult(events) |
| 14 | test = Foo("test_skip_me") |
| 15 | test.run(result) |
| 16 | self.assertEqual(events, ['startTest', 'addSkip', 'stopTest']) |
| 17 | self.assertEqual(result.skipped, [(test, "skip")]) |
| 18 | |
| 19 | # Try letting setUp skip the test now. |
| 20 | class Foo(unittest.TestCase): |
| 21 | def setUp(self): |
| 22 | self.skipTest("testing") |
| 23 | def test_nothing(self): pass |
| 24 | events = [] |
| 25 | result = LoggingResult(events) |
| 26 | test = Foo("test_nothing") |
| 27 | test.run(result) |
| 28 | self.assertEqual(events, ['startTest', 'addSkip', 'stopTest']) |
| 29 | self.assertEqual(result.skipped, [(test, "testing")]) |
| 30 | self.assertEqual(result.testsRun, 1) |
| 31 | |
Antoine Pitrou | c9b3ef2 | 2013-03-20 20:16:47 +0100 | [diff] [blame] | 32 | def test_skipping_subtests(self): |
| 33 | class Foo(unittest.TestCase): |
| 34 | def test_skip_me(self): |
| 35 | with self.subTest(a=1): |
| 36 | with self.subTest(b=2): |
| 37 | self.skipTest("skip 1") |
| 38 | self.skipTest("skip 2") |
| 39 | self.skipTest("skip 3") |
| 40 | events = [] |
| 41 | result = LoggingResult(events) |
| 42 | test = Foo("test_skip_me") |
| 43 | test.run(result) |
| 44 | self.assertEqual(events, ['startTest', 'addSkip', 'addSkip', |
| 45 | 'addSkip', 'stopTest']) |
| 46 | self.assertEqual(len(result.skipped), 3) |
| 47 | subtest, msg = result.skipped[0] |
| 48 | self.assertEqual(msg, "skip 1") |
| 49 | self.assertIsInstance(subtest, unittest.TestCase) |
| 50 | self.assertIsNot(subtest, test) |
| 51 | subtest, msg = result.skipped[1] |
| 52 | self.assertEqual(msg, "skip 2") |
| 53 | self.assertIsInstance(subtest, unittest.TestCase) |
| 54 | self.assertIsNot(subtest, test) |
| 55 | self.assertEqual(result.skipped[2], (test, "skip 3")) |
| 56 | |
Michael Foord | 2560e5c | 2010-03-27 12:34:21 +0000 | [diff] [blame] | 57 | def test_skipping_decorators(self): |
| 58 | op_table = ((unittest.skipUnless, False, True), |
| 59 | (unittest.skipIf, True, False)) |
| 60 | for deco, do_skip, dont_skip in op_table: |
| 61 | class Foo(unittest.TestCase): |
| 62 | @deco(do_skip, "testing") |
| 63 | def test_skip(self): pass |
| 64 | |
| 65 | @deco(dont_skip, "testing") |
| 66 | def test_dont_skip(self): pass |
| 67 | test_do_skip = Foo("test_skip") |
| 68 | test_dont_skip = Foo("test_dont_skip") |
| 69 | suite = unittest.TestSuite([test_do_skip, test_dont_skip]) |
| 70 | events = [] |
| 71 | result = LoggingResult(events) |
| 72 | suite.run(result) |
| 73 | self.assertEqual(len(result.skipped), 1) |
| 74 | expected = ['startTest', 'addSkip', 'stopTest', |
| 75 | 'startTest', 'addSuccess', 'stopTest'] |
| 76 | self.assertEqual(events, expected) |
| 77 | self.assertEqual(result.testsRun, 2) |
| 78 | self.assertEqual(result.skipped, [(test_do_skip, "testing")]) |
| 79 | self.assertTrue(result.wasSuccessful()) |
| 80 | |
| 81 | def test_skip_class(self): |
| 82 | @unittest.skip("testing") |
| 83 | class Foo(unittest.TestCase): |
| 84 | def test_1(self): |
| 85 | record.append(1) |
| 86 | record = [] |
| 87 | result = unittest.TestResult() |
| 88 | test = Foo("test_1") |
| 89 | suite = unittest.TestSuite([test]) |
| 90 | suite.run(result) |
| 91 | self.assertEqual(result.skipped, [(test, "testing")]) |
| 92 | self.assertEqual(record, []) |
| 93 | |
Antoine Pitrou | b05ac86 | 2012-04-25 14:56:46 +0200 | [diff] [blame] | 94 | def test_skip_non_unittest_class(self): |
| 95 | @unittest.skip("testing") |
| 96 | class Mixin: |
| 97 | def test_1(self): |
| 98 | record.append(1) |
| 99 | class Foo(Mixin, unittest.TestCase): |
| 100 | pass |
| 101 | record = [] |
| 102 | result = unittest.TestResult() |
| 103 | test = Foo("test_1") |
| 104 | suite = unittest.TestSuite([test]) |
| 105 | suite.run(result) |
| 106 | self.assertEqual(result.skipped, [(test, "testing")]) |
| 107 | self.assertEqual(record, []) |
| 108 | |
Michael Foord | 2560e5c | 2010-03-27 12:34:21 +0000 | [diff] [blame] | 109 | def test_expected_failure(self): |
| 110 | class Foo(unittest.TestCase): |
| 111 | @unittest.expectedFailure |
| 112 | def test_die(self): |
| 113 | self.fail("help me!") |
| 114 | events = [] |
| 115 | result = LoggingResult(events) |
| 116 | test = Foo("test_die") |
| 117 | test.run(result) |
| 118 | self.assertEqual(events, |
| 119 | ['startTest', 'addExpectedFailure', 'stopTest']) |
| 120 | self.assertEqual(result.expectedFailures[0][0], test) |
| 121 | self.assertTrue(result.wasSuccessful()) |
| 122 | |
Antoine Pitrou | c9b3ef2 | 2013-03-20 20:16:47 +0100 | [diff] [blame] | 123 | def test_expected_failure_subtests(self): |
| 124 | # A failure in any subtest counts as the expected failure of the |
| 125 | # whole test. |
| 126 | class Foo(unittest.TestCase): |
| 127 | @unittest.expectedFailure |
| 128 | def test_die(self): |
| 129 | with self.subTest(): |
| 130 | # This one succeeds |
| 131 | pass |
| 132 | with self.subTest(): |
| 133 | self.fail("help me!") |
| 134 | with self.subTest(): |
| 135 | # This one doesn't get executed |
| 136 | self.fail("shouldn't come here") |
| 137 | events = [] |
| 138 | result = LoggingResult(events) |
| 139 | test = Foo("test_die") |
| 140 | test.run(result) |
| 141 | self.assertEqual(events, |
| 142 | ['startTest', 'addSubTestSuccess', |
| 143 | 'addExpectedFailure', 'stopTest']) |
| 144 | self.assertEqual(len(result.expectedFailures), 1) |
| 145 | self.assertIs(result.expectedFailures[0][0], test) |
| 146 | self.assertTrue(result.wasSuccessful()) |
| 147 | |
Michael Foord | 2560e5c | 2010-03-27 12:34:21 +0000 | [diff] [blame] | 148 | def test_unexpected_success(self): |
| 149 | class Foo(unittest.TestCase): |
| 150 | @unittest.expectedFailure |
| 151 | def test_die(self): |
| 152 | pass |
| 153 | events = [] |
| 154 | result = LoggingResult(events) |
| 155 | test = Foo("test_die") |
| 156 | test.run(result) |
| 157 | self.assertEqual(events, |
| 158 | ['startTest', 'addUnexpectedSuccess', 'stopTest']) |
| 159 | self.assertFalse(result.failures) |
| 160 | self.assertEqual(result.unexpectedSuccesses, [test]) |
| 161 | self.assertTrue(result.wasSuccessful()) |
| 162 | |
Antoine Pitrou | c9b3ef2 | 2013-03-20 20:16:47 +0100 | [diff] [blame] | 163 | def test_unexpected_success_subtests(self): |
| 164 | # Success in all subtests counts as the unexpected success of |
| 165 | # the whole test. |
| 166 | class Foo(unittest.TestCase): |
| 167 | @unittest.expectedFailure |
| 168 | def test_die(self): |
| 169 | with self.subTest(): |
| 170 | # This one succeeds |
| 171 | pass |
| 172 | with self.subTest(): |
| 173 | # So does this one |
| 174 | pass |
| 175 | events = [] |
| 176 | result = LoggingResult(events) |
| 177 | test = Foo("test_die") |
| 178 | test.run(result) |
| 179 | self.assertEqual(events, |
| 180 | ['startTest', |
| 181 | 'addSubTestSuccess', 'addSubTestSuccess', |
| 182 | 'addUnexpectedSuccess', 'stopTest']) |
| 183 | self.assertFalse(result.failures) |
| 184 | self.assertEqual(result.unexpectedSuccesses, [test]) |
| 185 | self.assertTrue(result.wasSuccessful()) |
| 186 | |
Michael Foord | 2560e5c | 2010-03-27 12:34:21 +0000 | [diff] [blame] | 187 | def test_skip_doesnt_run_setup(self): |
| 188 | class Foo(unittest.TestCase): |
| 189 | wasSetUp = False |
| 190 | wasTornDown = False |
| 191 | def setUp(self): |
| 192 | Foo.wasSetUp = True |
| 193 | def tornDown(self): |
| 194 | Foo.wasTornDown = True |
| 195 | @unittest.skip('testing') |
| 196 | def test_1(self): |
| 197 | pass |
| 198 | |
| 199 | result = unittest.TestResult() |
| 200 | test = Foo("test_1") |
| 201 | suite = unittest.TestSuite([test]) |
| 202 | suite.run(result) |
| 203 | self.assertEqual(result.skipped, [(test, "testing")]) |
| 204 | self.assertFalse(Foo.wasSetUp) |
| 205 | self.assertFalse(Foo.wasTornDown) |
| 206 | |
| 207 | def test_decorated_skip(self): |
| 208 | def decorator(func): |
| 209 | def inner(*a): |
| 210 | return func(*a) |
| 211 | return inner |
| 212 | |
| 213 | class Foo(unittest.TestCase): |
| 214 | @decorator |
| 215 | @unittest.skip('testing') |
| 216 | def test_1(self): |
| 217 | pass |
| 218 | |
| 219 | result = unittest.TestResult() |
| 220 | test = Foo("test_1") |
| 221 | suite = unittest.TestSuite([test]) |
| 222 | suite.run(result) |
| 223 | self.assertEqual(result.skipped, [(test, "testing")]) |