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