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()