1import pickle 2 3from cStringIO import StringIO 4from unittest2.test.support import LoggingResult, OldTestResult 5 6import unittest2 7 8 9class Test_TextTestRunner(unittest2.TestCase): 10 """Tests for TextTestRunner.""" 11 12 def test_init(self): 13 runner = unittest2.TextTestRunner() 14 self.assertFalse(runner.failfast) 15 self.assertFalse(runner.buffer) 16 self.assertEqual(runner.verbosity, 1) 17 self.assertTrue(runner.descriptions) 18 self.assertEqual(runner.resultclass, unittest2.TextTestResult) 19 20 def testBufferAndFailfast(self): 21 class Test(unittest2.TestCase): 22 23 def testFoo(self): 24 pass 25 result = unittest2.TestResult() 26 runner = unittest2.TextTestRunner(stream=StringIO(), failfast=True, 27 buffer=True) 28 # Use our result object 29 runner._makeResult = lambda: result 30 runner.run(Test('testFoo')) 31 32 self.assertTrue(result.failfast) 33 self.assertTrue(result.buffer) 34 35 def testRunnerRegistersResult(self): 36 class Test(unittest2.TestCase): 37 38 def testFoo(self): 39 pass 40 originalRegisterResult = unittest2.runner.registerResult 41 42 def cleanup(): 43 unittest2.runner.registerResult = originalRegisterResult 44 self.addCleanup(cleanup) 45 46 result = unittest2.TestResult() 47 runner = unittest2.TextTestRunner(stream=StringIO()) 48 # Use our result object 49 runner._makeResult = lambda: result 50 51 self.wasRegistered = 0 52 53 def fakeRegisterResult(thisResult): 54 self.wasRegistered += 1 55 self.assertEqual(thisResult, result) 56 unittest2.runner.registerResult = fakeRegisterResult 57 58 runner.run(unittest2.TestSuite()) 59 self.assertEqual(self.wasRegistered, 1) 60 61 def test_works_with_result_without_startTestRun_stopTestRun(self): 62 class OldTextResult(OldTestResult): 63 64 def __init__(self, *_): 65 super(OldTextResult, self).__init__() 66 separator2 = '' 67 68 def printErrors(self): 69 pass 70 71 runner = unittest2.TextTestRunner(stream=StringIO(), 72 resultclass=OldTextResult) 73 runner.run(unittest2.TestSuite()) 74 75 def test_startTestRun_stopTestRun_called(self): 76 class LoggingTextResult(LoggingResult): 77 separator2 = '' 78 79 def printErrors(self): 80 pass 81 82 class LoggingRunner(unittest2.TextTestRunner): 83 84 def __init__(self, events): 85 super(LoggingRunner, self).__init__(StringIO()) 86 self._events = events 87 88 def _makeResult(self): 89 return LoggingTextResult(self._events) 90 91 events = [] 92 runner = LoggingRunner(events) 93 runner.run(unittest2.TestSuite()) 94 expected = ['startTestRun', 'stopTestRun'] 95 self.assertEqual(events, expected) 96 97 def test_pickle_unpickle(self): 98 # Issue #7197: a TextTestRunner should be (un)pickleable. This is 99 # required by test_multiprocessing under Windows (in verbose mode). 100 import StringIO 101 # cStringIO objects are not pickleable, but StringIO objects are. 102 stream = StringIO.StringIO("foo") 103 runner = unittest2.TextTestRunner(stream) 104 for protocol in range(pickle.HIGHEST_PROTOCOL + 1): 105 s = pickle.dumps(runner, protocol=protocol) 106 obj = pickle.loads(s) 107 # StringIO objects never compare equal, a cheap test instead. 108 self.assertEqual(obj.stream.getvalue(), stream.getvalue()) 109 110 def test_resultclass(self): 111 def MockResultClass(*args): 112 return args 113 STREAM = object() 114 DESCRIPTIONS = object() 115 VERBOSITY = object() 116 runner = unittest2.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, 117 resultclass=MockResultClass) 118 self.assertEqual(runner.resultclass, MockResultClass) 119 120 expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) 121 self.assertEqual(runner._makeResult(), expectedresult) 122 123 def test_oldresult(self): 124 class Test(unittest2.TestCase): 125 126 def testFoo(self): 127 pass 128 runner = unittest2.TextTestRunner(resultclass=OldTestResult, 129 stream=StringIO()) 130 # This will raise an exception if TextTestRunner can't handle old 131 # test result objects 132 runner.run(Test('testFoo')) 133 134 135if __name__ == '__main__': 136 unittest2.main() 137