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 21 def testBufferAndFailfast(self): 22 class Test(unittest2.TestCase): 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 def testFoo(self): 38 pass 39 originalRegisterResult = unittest2.runner.registerResult 40 def cleanup(): 41 unittest2.runner.registerResult = originalRegisterResult 42 self.addCleanup(cleanup) 43 44 result = unittest2.TestResult() 45 runner = unittest2.TextTestRunner(stream=StringIO()) 46 # Use our result object 47 runner._makeResult = lambda: result 48 49 self.wasRegistered = 0 50 def fakeRegisterResult(thisResult): 51 self.wasRegistered += 1 52 self.assertEqual(thisResult, result) 53 unittest2.runner.registerResult = fakeRegisterResult 54 55 runner.run(unittest2.TestSuite()) 56 self.assertEqual(self.wasRegistered, 1) 57 58 def test_works_with_result_without_startTestRun_stopTestRun(self): 59 class OldTextResult(OldTestResult): 60 def __init__(self, *_): 61 super(OldTextResult, self).__init__() 62 separator2 = '' 63 def printErrors(self): 64 pass 65 66 runner = unittest2.TextTestRunner(stream=StringIO(), 67 resultclass=OldTextResult) 68 runner.run(unittest2.TestSuite()) 69 70 def test_startTestRun_stopTestRun_called(self): 71 class LoggingTextResult(LoggingResult): 72 separator2 = '' 73 def printErrors(self): 74 pass 75 76 class LoggingRunner(unittest2.TextTestRunner): 77 def __init__(self, events): 78 super(LoggingRunner, self).__init__(StringIO()) 79 self._events = events 80 81 def _makeResult(self): 82 return LoggingTextResult(self._events) 83 84 events = [] 85 runner = LoggingRunner(events) 86 runner.run(unittest2.TestSuite()) 87 expected = ['startTestRun', 'stopTestRun'] 88 self.assertEqual(events, expected) 89 90 def test_pickle_unpickle(self): 91 # Issue #7197: a TextTestRunner should be (un)pickleable. This is 92 # required by test_multiprocessing under Windows (in verbose mode). 93 import StringIO 94 # cStringIO objects are not pickleable, but StringIO objects are. 95 stream = StringIO.StringIO("foo") 96 runner = unittest2.TextTestRunner(stream) 97 for protocol in range(pickle.HIGHEST_PROTOCOL + 1): 98 s = pickle.dumps(runner, protocol=protocol) 99 obj = pickle.loads(s) 100 # StringIO objects never compare equal, a cheap test instead. 101 self.assertEqual(obj.stream.getvalue(), stream.getvalue()) 102 103 def test_resultclass(self): 104 def MockResultClass(*args): 105 return args 106 STREAM = object() 107 DESCRIPTIONS = object() 108 VERBOSITY = object() 109 runner = unittest2.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, 110 resultclass=MockResultClass) 111 self.assertEqual(runner.resultclass, MockResultClass) 112 113 expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) 114 self.assertEqual(runner._makeResult(), expectedresult) 115 116 117 def test_oldresult(self): 118 class Test(unittest2.TestCase): 119 def testFoo(self): 120 pass 121 runner = unittest2.TextTestRunner(resultclass=OldTestResult, 122 stream=StringIO()) 123 # This will raise an exception if TextTestRunner can't handle old 124 # test result objects 125 runner.run(Test('testFoo')) 126 127 128if __name__ == '__main__': 129 unittest2.main()