1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
import sys
import unittest
from inspect import ismethod
from nose.config import Config
from nose.proxy import ResultProxyFactory, ResultProxy
from mock import RecordingPluginManager
class TestResultProxy(unittest.TestCase):
def test_proxy_has_basic_methods(self):
res = unittest.TestResult()
proxy = ResultProxy(res, test=None)
methods = [ 'addError', 'addFailure', 'addSuccess',
'startTest', 'stopTest', 'stop' ]
for method in methods:
m = getattr(proxy, method)
assert ismethod(m), "%s is not a method" % method
def test_proxy_has_nose_methods(self):
res = unittest.TestResult()
proxy = ResultProxy(res, test=None)
methods = [ 'beforeTest', 'afterTest' ]
for method in methods:
m = getattr(proxy, method)
assert ismethod(m), "%s is not a method" % method
def test_proxy_proxies(self):
from nose.case import Test
class Dummy:
def __init__(self):
self.__dict__['called'] = []
def __getattr__(self, attr):
c = self.__dict__['called']
c.append(attr)
def dummy(*arg, **kw):
pass
return dummy
class TC(unittest.TestCase):
def runTest(self):
pass
try:
raise Exception("exception")
except:
err = sys.exc_info()
test = TC()
case = Test(test)
res = Dummy()
proxy = ResultProxy(res, test=case)
proxy.addError(test, err)
proxy.addFailure(test, err)
proxy.addSuccess(test)
proxy.startTest(test)
proxy.stopTest(test)
proxy.beforeTest(test)
proxy.afterTest(test)
proxy.stop()
proxy.shouldStop = 'yes please'
for method in ['addError', 'addFailure', 'addSuccess',
'startTest', 'stopTest', 'beforeTest', 'afterTest',
'stop']:
assert method in res.called, "%s was not proxied"
self.assertEqual(res.shouldStop, 'yes please')
def test_attributes_are_proxied(self):
res = unittest.TestResult()
proxy = ResultProxy(res, test=None)
proxy.errors
proxy.failures
proxy.shouldStop
proxy.testsRun
def test_test_cases_can_access_result_attributes(self):
from nose.case import Test
class TC(unittest.TestCase):
def run(self, result):
unittest.TestCase.run(self, result)
print "errors", result.errors
print "failures", result.failures
def runTest(self):
pass
test = TC()
case = Test(test)
res = unittest.TestResult()
proxy = ResultProxy(res, test=case)
case(proxy)
def test_proxy_handles_missing_methods(self):
from nose.case import Test
class TC(unittest.TestCase):
def runTest(self):
pass
test = TC()
case = Test(test)
res = unittest.TestResult()
proxy = ResultProxy(res, case)
proxy.beforeTest(test)
proxy.afterTest(test)
def test_proxy_calls_plugins(self):
from nose.case import Test
res = unittest.TestResult()
class TC(unittest.TestCase):
def test_error(self):
print "So long"
raise TypeError("oops")
def test_fail(self):
print "Hello"
self.fail()
def test(self):
pass
plugs = RecordingPluginManager()
config = Config(plugins=plugs)
factory = ResultProxyFactory(config=config)
case_e = Test(TC('test_error'))
case_f = Test(TC('test_fail'))
case_t = Test(TC('test'))
pres_e = factory(res, case_e)
case_e(pres_e)
assert 'beforeTest' in plugs.called
assert 'startTest' in plugs.called
assert 'addError' in plugs.called
assert 'stopTest' in plugs.called
assert 'afterTest' in plugs.called
plugs.reset()
pres_f = factory(res, case_f)
case_f(pres_f)
assert 'beforeTest' in plugs.called
assert 'startTest' in plugs.called
assert 'addFailure' in plugs.called
assert 'stopTest' in plugs.called
assert 'afterTest' in plugs.called
plugs.reset()
pres_t = factory(res, case_t)
case_t(pres_t)
assert 'beforeTest' in plugs.called
assert 'startTest' in plugs.called
assert 'addSuccess' in plugs.called
assert 'stopTest' in plugs.called
assert 'afterTest' in plugs.called
plugs.reset()
def test_stop_on_error(self):
from nose.case import Test
class TC(unittest.TestCase):
def runTest(self):
raise Exception("Enough!")
conf = Config(stopOnError=True)
test = TC()
case = Test(test)
res = unittest.TestResult()
proxy = ResultProxy(res, case, config=conf)
case(proxy)
assert proxy.shouldStop
assert res.shouldStop
def test_coercion_of_custom_exception(self):
from nose.case import Test
class CustomException(Exception):
def __init__(self, message, two, three):
Exception.__init__(self, message)
class TC(unittest.TestCase):
def runTest(self):
pass
test = TC()
case = Test(test)
res = unittest.TestResult()
try:
raise CustomException("the error", 2, 3)
except:
etype, val, tb = sys.exc_info()
val = str(val) # simulate plugin shenanigans
proxy = ResultProxy(res, test=case)
# Python 3 coercion should happen here without error
proxy.addError(test, (etype, val, tb))
proxy.addFailure(test, (etype, val, tb))
if __name__ == '__main__':
unittest.main()
|
