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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
#!/usr/bin/env python
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import traceback
import unittest
from future import All, Future, Race
from mock_function import MockFunction
class FutureTest(unittest.TestCase):
def testNoValueOrDelegate(self):
self.assertRaises(ValueError, Future)
def testValue(self):
future = Future(value=42)
self.assertEqual(42, future.Get())
self.assertEqual(42, future.Get())
def testDelegateValue(self):
called = [False,]
def callback():
self.assertFalse(called[0])
called[0] = True
return 42
future = Future(callback=callback)
self.assertEqual(42, future.Get())
self.assertEqual(42, future.Get())
def testErrorThrowingDelegate(self):
class FunkyException(Exception):
pass
# Set up a chain of functions to test the stack trace.
def qux():
raise FunkyException()
def baz():
return qux()
def bar():
return baz()
def foo():
return bar()
chain = [foo, bar, baz, qux]
called = [False,]
def callback():
self.assertFalse(called[0])
called[0] = True
return foo()
fail = self.fail
assertTrue = self.assertTrue
def assert_raises_full_stack(future, err):
try:
future.Get()
fail('Did not raise %s' % err)
except Exception as e:
assertTrue(isinstance(e, err))
stack = traceback.format_exc()
assertTrue(all(stack.find(fn.__name__) != -1 for fn in chain))
future = Future(callback=callback)
assert_raises_full_stack(future, FunkyException)
assert_raises_full_stack(future, FunkyException)
def testAll(self):
def callback_with_value(value):
return MockFunction(lambda: value)
# Test a single value.
callback = callback_with_value(42)
future = All((Future(callback=callback),))
self.assertTrue(*callback.CheckAndReset(0))
self.assertEqual([42], future.Get())
self.assertTrue(*callback.CheckAndReset(1))
# Test multiple callbacks.
callbacks = (callback_with_value(1),
callback_with_value(2),
callback_with_value(3))
future = All(Future(callback=callback) for callback in callbacks)
for callback in callbacks:
self.assertTrue(*callback.CheckAndReset(0))
self.assertEqual([1, 2, 3], future.Get())
for callback in callbacks:
self.assertTrue(*callback.CheckAndReset(1))
# Test throwing an error.
def throws_error():
raise ValueError()
callbacks = (callback_with_value(1),
callback_with_value(2),
MockFunction(throws_error))
future = All(Future(callback=callback) for callback in callbacks)
for callback in callbacks:
self.assertTrue(*callback.CheckAndReset(0))
# Can't check that the callbacks were actually run because in theory the
# Futures can be resolved in any order.
self.assertRaises(ValueError, future.Get)
def testRaceSuccess(self):
callback = MockFunction(lambda: 42)
# Test a single value.
race = Race((Future(callback=callback),))
self.assertTrue(*callback.CheckAndReset(0))
self.assertEqual(42, race.Get())
self.assertTrue(*callback.CheckAndReset(1))
# Test multiple success values. Note that we could test different values
# and check that the first returned, but this is just an implementation
# detail of Race. When we have parallel Futures this might not always hold.
race = Race((Future(callback=callback),
Future(callback=callback),
Future(callback=callback)))
self.assertTrue(*callback.CheckAndReset(0))
self.assertEqual(42, race.Get())
# Can't assert the actual count here for the same reason as above.
callback.CheckAndReset(99)
# Test values with except_pass.
def throws_error():
raise ValueError()
race = Race((Future(callback=callback),
Future(callback=throws_error)),
except_pass=(ValueError,))
self.assertTrue(*callback.CheckAndReset(0))
self.assertEqual(42, race.Get())
self.assertTrue(*callback.CheckAndReset(1))
def testRaceErrors(self):
def throws_error():
raise ValueError()
# Test a single error.
race = Race((Future(callback=throws_error),))
self.assertRaises(ValueError, race.Get)
# Test multiple errors. Can't use different error types for the same reason
# as described in testRaceSuccess.
race = Race((Future(callback=throws_error),
Future(callback=throws_error),
Future(callback=throws_error)))
self.assertRaises(ValueError, race.Get)
# Test values with except_pass.
def throws_except_error():
raise NotImplementedError()
race = Race((Future(callback=throws_error),
Future(callback=throws_except_error)),
except_pass=(NotImplementedError,))
self.assertRaises(ValueError, race.Get)
race = Race((Future(callback=throws_error),
Future(callback=throws_error)),
except_pass=(ValueError,))
self.assertRaises(ValueError, race.Get)
def testThen(self):
def assertIs42(val):
self.assertEqual(val, 42)
return val
then = Future(value=42).Then(assertIs42)
# Shouldn't raise an error.
self.assertEqual(42, then.Get())
# Test raising an error.
then = Future(value=41).Then(assertIs42)
self.assertRaises(AssertionError, then.Get)
# Test setting up an error handler.
def handle(error):
if isinstance(error, ValueError):
return 'Caught'
raise error
def raiseValueError():
raise ValueError
def raiseException():
raise Exception
then = Future(callback=raiseValueError).Then(assertIs42, handle)
self.assertEqual('Caught', then.Get())
then = Future(callback=raiseException).Then(assertIs42, handle)
self.assertRaises(Exception, then.Get)
# Test chains of thens.
addOne = lambda val: val + 1
then = Future(value=40).Then(addOne).Then(addOne).Then(assertIs42)
# Shouldn't raise an error.
self.assertEqual(42, then.Get())
# Test error in chain.
then = Future(value=40).Then(addOne).Then(assertIs42).Then(addOne)
self.assertRaises(AssertionError, then.Get)
# Test handle error in chain.
def raiseValueErrorWithVal(val):
raise ValueError
then = Future(value=40).Then(addOne).Then(raiseValueErrorWithVal).Then(
addOne, handle).Then(lambda val: val + ' me')
self.assertEquals(then.Get(), 'Caught me')
# Test multiple handlers.
def myHandle(error):
if isinstance(error, AssertionError):
return 10
raise error
then = Future(value=40).Then(assertIs42).Then(addOne, handle).Then(addOne,
myHandle)
self.assertEquals(then.Get(), 10)
def testThenResolvesReturnedFutures(self):
def returnsFortyTwo():
return Future(value=42)
def inc(x):
return x + 1
def incFuture(x):
return Future(value=x + 1)
self.assertEqual(43, returnsFortyTwo().Then(inc).Get())
self.assertEqual(43, returnsFortyTwo().Then(incFuture).Get())
self.assertEqual(44, returnsFortyTwo().Then(inc).Then(inc).Get())
self.assertEqual(44, returnsFortyTwo().Then(inc).Then(incFuture).Get())
self.assertEqual(44, returnsFortyTwo().Then(incFuture).Then(inc).Get())
self.assertEqual(
44, returnsFortyTwo().Then(incFuture).Then(incFuture).Get())
# The same behaviour should apply to error handlers.
def raisesSomething():
def boom(): raise ValueError
return Future(callback=boom)
def shouldNotHappen(_):
raise AssertionError()
def oops(error):
return 'oops'
def oopsFuture(error):
return Future(value='oops')
self.assertEqual(
'oops', raisesSomething().Then(shouldNotHappen, oops).Get())
self.assertEqual(
'oops', raisesSomething().Then(shouldNotHappen, oopsFuture).Get())
self.assertEqual(
'oops',
raisesSomething().Then(shouldNotHappen, raisesSomething)
.Then(shouldNotHappen, oops).Get())
self.assertEqual(
'oops',
raisesSomething().Then(shouldNotHappen, raisesSomething)
.Then(shouldNotHappen, oopsFuture).Get())
if __name__ == '__main__':
unittest.main()
|
