1 import unittest 2 3 from cStringIO import StringIO 4 import pickle 5 6 from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun 7 8 9 class TestCleanUp(unittest.TestCase): 10 11 def testCleanUp(self): 12 class TestableTest(unittest.TestCase): 13 def testNothing(self): 14 pass 15 16 test = TestableTest('testNothing') 17 self.assertEqual(test._cleanups, []) 18 19 cleanups = [] 20 21 def cleanup1(*args, **kwargs): 22 cleanups.append((1, args, kwargs)) 23 24 def cleanup2(*args, **kwargs): 25 cleanups.append((2, args, kwargs)) 26 27 test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye') 28 test.addCleanup(cleanup2) 29 30 self.assertEqual(test._cleanups, 31 [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')), 32 (cleanup2, (), {})]) 33 34 result = test.doCleanups() 35 self.assertTrue(result) 36 37 self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), 38 dict(four='hello', five='goodbye'))]) 39 40 def testCleanUpWithErrors(self): 41 class TestableTest(unittest.TestCase): 42 def testNothing(self): 43 pass 44 45 class MockResult(object): 46 errors = [] 47 def addError(self, test, exc_info): 48 self.errors.append((test, exc_info)) 49 50 result = MockResult() 51 test = TestableTest('testNothing') 52 test._resultForDoCleanups = result 53 54 exc1 = Exception('foo') 55 exc2 = Exception('bar') 56 def cleanup1(): 57 raise exc1 58 59 def cleanup2(): 60 raise exc2 61 62 test.addCleanup(cleanup1) 63 test.addCleanup(cleanup2) 64 65 self.assertFalse(test.doCleanups()) 66 67 (test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors) 68 self.assertEqual((test1, Type1, instance1), (test, Exception, exc1)) 69 self.assertEqual((test2, Type2, instance2), (test, Exception, exc2)) 70 71 def testCleanupInRun(self): 72 blowUp = False 73 ordering = [] 74 75 class TestableTest(unittest.TestCase): 76 def setUp(self): 77 ordering.append('setUp') 78 if blowUp: 79 raise Exception('foo') 80 81 def testNothing(self): 82 ordering.append('test') 83 84 def tearDown(self): 85 ordering.append('tearDown') 86 87 test = TestableTest('testNothing') 88 89 def cleanup1(): 90 ordering.append('cleanup1') 91 def cleanup2(): 92 ordering.append('cleanup2') 93 test.addCleanup(cleanup1) 94 test.addCleanup(cleanup2) 95 96 def success(some_test): 97 self.assertEqual(some_test, test) 98 ordering.append('success') 99 100 result = unittest.TestResult() 101 result.addSuccess = success 102 103 test.run(result) 104 self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 105 'cleanup2', 'cleanup1', 'success']) 106 107 blowUp = True 108 ordering = [] 109 test = TestableTest('testNothing') 110 test.addCleanup(cleanup1) 111 test.run(result) 112 self.assertEqual(ordering, ['setUp', 'cleanup1']) 113 114 def testTestCaseDebugExecutesCleanups(self): 115 ordering = [] 116 117 class TestableTest(unittest.TestCase): 118 def setUp(self): 119 ordering.append('setUp') 120 self.addCleanup(cleanup1) 121 122 def testNothing(self): 123 ordering.append('test') 124 125 def tearDown(self): 126 ordering.append('tearDown') 127 128 test = TestableTest('testNothing') 129 130 def cleanup1(): 131 ordering.append('cleanup1') 132 test.addCleanup(cleanup2) 133 def cleanup2(): 134 ordering.append('cleanup2') 135 136 test.debug() 137 self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2']) 138 139 140 class Test_TextTestRunner(unittest.TestCase): 141 """Tests for TextTestRunner.""" 142 143 def test_init(self): 144 runner = unittest.TextTestRunner() 145 self.assertFalse(runner.failfast) 146 self.assertFalse(runner.buffer) 147 self.assertEqual(runner.verbosity, 1) 148 self.assertTrue(runner.descriptions) 149 self.assertEqual(runner.resultclass, unittest.TextTestResult) 150 151 152 def testBufferAndFailfast(self): 153 class Test(unittest.TestCase): 154 def testFoo(self): 155 pass 156 result = unittest.TestResult() 157 runner = unittest.TextTestRunner(stream=StringIO(), failfast=True, 158 buffer=True) 159 # Use our result object 160 runner._makeResult = lambda: result 161 runner.run(Test('testFoo')) 162 163 self.assertTrue(result.failfast) 164 self.assertTrue(result.buffer) 165 166 def testRunnerRegistersResult(self): 167 class Test(unittest.TestCase): 168 def testFoo(self): 169 pass 170 originalRegisterResult = unittest.runner.registerResult 171 def cleanup(): 172 unittest.runner.registerResult = originalRegisterResult 173 self.addCleanup(cleanup) 174 175 result = unittest.TestResult() 176 runner = unittest.TextTestRunner(stream=StringIO()) 177 # Use our result object 178 runner._makeResult = lambda: result 179 180 self.wasRegistered = 0 181 def fakeRegisterResult(thisResult): 182 self.wasRegistered += 1 183 self.assertEqual(thisResult, result) 184 unittest.runner.registerResult = fakeRegisterResult 185 186 runner.run(unittest.TestSuite()) 187 self.assertEqual(self.wasRegistered, 1) 188 189 def test_works_with_result_without_startTestRun_stopTestRun(self): 190 class OldTextResult(ResultWithNoStartTestRunStopTestRun): 191 separator2 = '' 192 def printErrors(self): 193 pass 194 195 class Runner(unittest.TextTestRunner): 196 def __init__(self): 197 super(Runner, self).__init__(StringIO()) 198 199 def _makeResult(self): 200 return OldTextResult() 201 202 runner = Runner() 203 runner.run(unittest.TestSuite()) 204 205 def test_startTestRun_stopTestRun_called(self): 206 class LoggingTextResult(LoggingResult): 207 separator2 = '' 208 def printErrors(self): 209 pass 210 211 class LoggingRunner(unittest.TextTestRunner): 212 def __init__(self, events): 213 super(LoggingRunner, self).__init__(StringIO()) 214 self._events = events 215 216 def _makeResult(self): 217 return LoggingTextResult(self._events) 218 219 events = [] 220 runner = LoggingRunner(events) 221 runner.run(unittest.TestSuite()) 222 expected = ['startTestRun', 'stopTestRun'] 223 self.assertEqual(events, expected) 224 225 def test_pickle_unpickle(self): 226 # Issue #7197: a TextTestRunner should be (un)pickleable. This is 227 # required by test_multiprocessing under Windows (in verbose mode). 228 from StringIO import StringIO as PickleableIO 229 # cStringIO objects are not pickleable, but StringIO objects are. 230 stream = PickleableIO("foo") 231 runner = unittest.TextTestRunner(stream) 232 for protocol in range(pickle.HIGHEST_PROTOCOL + 1): 233 s = pickle.dumps(runner, protocol=protocol) 234 obj = pickle.loads(s) 235 # StringIO objects never compare equal, a cheap test instead. 236 self.assertEqual(obj.stream.getvalue(), stream.getvalue()) 237 238 def test_resultclass(self): 239 def MockResultClass(*args): 240 return args 241 STREAM = object() 242 DESCRIPTIONS = object() 243 VERBOSITY = object() 244 runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, 245 resultclass=MockResultClass) 246 self.assertEqual(runner.resultclass, MockResultClass) 247 248 expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) 249 self.assertEqual(runner._makeResult(), expectedresult) 250 251 252 if __name__ == '__main__': 253 unittest.main() 254
