1 #!/usr/bin/env python 2 # Copyright 2013 The Chromium Authors. All rights reserved. 3 # Use of this source code is governed by a BSD-style license that can be 4 # found in the LICENSE file. 5 6 import traceback 7 import unittest 8 9 10 from future import All, Future, Race 11 from mock_function import MockFunction 12 13 14 class FutureTest(unittest.TestCase): 15 def testNoValueOrDelegate(self): 16 self.assertRaises(ValueError, Future) 17 18 def testValue(self): 19 future = Future(value=42) 20 self.assertEqual(42, future.Get()) 21 self.assertEqual(42, future.Get()) 22 23 def testDelegateValue(self): 24 called = [False,] 25 def callback(): 26 self.assertFalse(called[0]) 27 called[0] = True 28 return 42 29 future = Future(callback=callback) 30 self.assertEqual(42, future.Get()) 31 self.assertEqual(42, future.Get()) 32 33 def testErrorThrowingDelegate(self): 34 class FunkyException(Exception): 35 pass 36 37 # Set up a chain of functions to test the stack trace. 38 def qux(): 39 raise FunkyException() 40 def baz(): 41 return qux() 42 def bar(): 43 return baz() 44 def foo(): 45 return bar() 46 chain = [foo, bar, baz, qux] 47 48 called = [False,] 49 def callback(): 50 self.assertFalse(called[0]) 51 called[0] = True 52 return foo() 53 54 fail = self.fail 55 assertTrue = self.assertTrue 56 def assert_raises_full_stack(future, err): 57 try: 58 future.Get() 59 fail('Did not raise %s' % err) 60 except Exception as e: 61 assertTrue(isinstance(e, err)) 62 stack = traceback.format_exc() 63 assertTrue(all(stack.find(fn.__name__) != -1 for fn in chain)) 64 65 future = Future(callback=callback) 66 assert_raises_full_stack(future, FunkyException) 67 assert_raises_full_stack(future, FunkyException) 68 69 def testAll(self): 70 def callback_with_value(value): 71 return MockFunction(lambda: value) 72 73 # Test a single value. 74 callback = callback_with_value(42) 75 future = All((Future(callback=callback),)) 76 self.assertTrue(*callback.CheckAndReset(0)) 77 self.assertEqual([42], future.Get()) 78 self.assertTrue(*callback.CheckAndReset(1)) 79 80 # Test multiple callbacks. 81 callbacks = (callback_with_value(1), 82 callback_with_value(2), 83 callback_with_value(3)) 84 future = All(Future(callback=callback) for callback in callbacks) 85 for callback in callbacks: 86 self.assertTrue(*callback.CheckAndReset(0)) 87 self.assertEqual([1, 2, 3], future.Get()) 88 for callback in callbacks: 89 self.assertTrue(*callback.CheckAndReset(1)) 90 91 # Test throwing an error. 92 def throws_error(): 93 raise ValueError() 94 callbacks = (callback_with_value(1), 95 callback_with_value(2), 96 MockFunction(throws_error)) 97 98 future = All(Future(callback=callback) for callback in callbacks) 99 for callback in callbacks: 100 self.assertTrue(*callback.CheckAndReset(0)) 101 self.assertRaises(ValueError, future.Get) 102 for callback in callbacks: 103 # Can't check that the callbacks were actually run because in theory the 104 # Futures can be resolved in any order. 105 callback.CheckAndReset(0) 106 107 # Test throwing an error with except_pass. 108 future = All((Future(callback=callback) for callback in callbacks), 109 except_pass=ValueError) 110 for callback in callbacks: 111 self.assertTrue(*callback.CheckAndReset(0)) 112 self.assertEqual([1, 2, None], future.Get()) 113 114 def testRaceSuccess(self): 115 callback = MockFunction(lambda: 42) 116 117 # Test a single value. 118 race = Race((Future(callback=callback),)) 119 self.assertTrue(*callback.CheckAndReset(0)) 120 self.assertEqual(42, race.Get()) 121 self.assertTrue(*callback.CheckAndReset(1)) 122 123 # Test multiple success values. Note that we could test different values 124 # and check that the first returned, but this is just an implementation 125 # detail of Race. When we have parallel Futures this might not always hold. 126 race = Race((Future(callback=callback), 127 Future(callback=callback), 128 Future(callback=callback))) 129 self.assertTrue(*callback.CheckAndReset(0)) 130 self.assertEqual(42, race.Get()) 131 # Can't assert the actual count here for the same reason as above. 132 callback.CheckAndReset(99) 133 134 # Test values with except_pass. 135 def throws_error(): 136 raise ValueError() 137 race = Race((Future(callback=callback), 138 Future(callback=throws_error)), 139 except_pass=(ValueError,)) 140 self.assertTrue(*callback.CheckAndReset(0)) 141 self.assertEqual(42, race.Get()) 142 self.assertTrue(*callback.CheckAndReset(1)) 143 144 def testRaceErrors(self): 145 def throws_error(): 146 raise ValueError() 147 148 # Test a single error. 149 race = Race((Future(callback=throws_error),)) 150 self.assertRaises(ValueError, race.Get) 151 152 # Test multiple errors. Can't use different error types for the same reason 153 # as described in testRaceSuccess. 154 race = Race((Future(callback=throws_error), 155 Future(callback=throws_error), 156 Future(callback=throws_error))) 157 self.assertRaises(ValueError, race.Get) 158 159 # Test values with except_pass. 160 def throws_except_error(): 161 raise NotImplementedError() 162 race = Race((Future(callback=throws_error), 163 Future(callback=throws_except_error)), 164 except_pass=(NotImplementedError,)) 165 self.assertRaises(ValueError, race.Get) 166 167 race = Race((Future(callback=throws_error), 168 Future(callback=throws_error)), 169 except_pass=(ValueError,)) 170 self.assertRaises(ValueError, race.Get) 171 172 # Test except_pass with default values. 173 race = Race((Future(callback=throws_error), 174 Future(callback=throws_except_error)), 175 except_pass=(NotImplementedError,), 176 default=42) 177 self.assertRaises(ValueError, race.Get) 178 179 race = Race((Future(callback=throws_error), 180 Future(callback=throws_error)), 181 except_pass=(ValueError,), 182 default=42) 183 self.assertEqual(42, race.Get()) 184 185 def testThen(self): 186 def assertIs42(val): 187 self.assertEqual(val, 42) 188 return val 189 190 then = Future(value=42).Then(assertIs42) 191 # Shouldn't raise an error. 192 self.assertEqual(42, then.Get()) 193 194 # Test raising an error. 195 then = Future(value=41).Then(assertIs42) 196 self.assertRaises(AssertionError, then.Get) 197 198 # Test setting up an error handler. 199 def handle(error): 200 if isinstance(error, ValueError): 201 return 'Caught' 202 raise error 203 204 def raiseValueError(): 205 raise ValueError 206 207 def raiseException(): 208 raise Exception 209 210 then = Future(callback=raiseValueError).Then(assertIs42, handle) 211 self.assertEqual('Caught', then.Get()) 212 then = Future(callback=raiseException).Then(assertIs42, handle) 213 self.assertRaises(Exception, then.Get) 214 215 # Test chains of thens. 216 addOne = lambda val: val + 1 217 then = Future(value=40).Then(addOne).Then(addOne).Then(assertIs42) 218 # Shouldn't raise an error. 219 self.assertEqual(42, then.Get()) 220 221 # Test error in chain. 222 then = Future(value=40).Then(addOne).Then(assertIs42).Then(addOne) 223 self.assertRaises(AssertionError, then.Get) 224 225 # Test handle error in chain. 226 def raiseValueErrorWithVal(val): 227 raise ValueError 228 229 then = Future(value=40).Then(addOne).Then(raiseValueErrorWithVal).Then( 230 addOne, handle).Then(lambda val: val + ' me') 231 self.assertEquals(then.Get(), 'Caught me') 232 233 # Test multiple handlers. 234 def myHandle(error): 235 if isinstance(error, AssertionError): 236 return 10 237 raise error 238 239 then = Future(value=40).Then(assertIs42).Then(addOne, handle).Then(addOne, 240 myHandle) 241 self.assertEquals(then.Get(), 10) 242 243 def testThenResolvesReturnedFutures(self): 244 def returnsFortyTwo(): 245 return Future(value=42) 246 def inc(x): 247 return x + 1 248 def incFuture(x): 249 return Future(value=x + 1) 250 251 self.assertEqual(43, returnsFortyTwo().Then(inc).Get()) 252 self.assertEqual(43, returnsFortyTwo().Then(incFuture).Get()) 253 self.assertEqual(44, returnsFortyTwo().Then(inc).Then(inc).Get()) 254 self.assertEqual(44, returnsFortyTwo().Then(inc).Then(incFuture).Get()) 255 self.assertEqual(44, returnsFortyTwo().Then(incFuture).Then(inc).Get()) 256 self.assertEqual( 257 44, returnsFortyTwo().Then(incFuture).Then(incFuture).Get()) 258 259 # The same behaviour should apply to error handlers. 260 def raisesSomething(): 261 def boom(): raise ValueError 262 return Future(callback=boom) 263 def shouldNotHappen(_): 264 raise AssertionError() 265 def oops(error): 266 return 'oops' 267 def oopsFuture(error): 268 return Future(value='oops') 269 270 self.assertEqual( 271 'oops', raisesSomething().Then(shouldNotHappen, oops).Get()) 272 self.assertEqual( 273 'oops', raisesSomething().Then(shouldNotHappen, oopsFuture).Get()) 274 self.assertEqual( 275 'oops', 276 raisesSomething().Then(shouldNotHappen, raisesSomething) 277 .Then(shouldNotHappen, oops).Get()) 278 self.assertEqual( 279 'oops', 280 raisesSomething().Then(shouldNotHappen, raisesSomething) 281 .Then(shouldNotHappen, oopsFuture).Get()) 282 283 284 if __name__ == '__main__': 285 unittest.main() 286
