def testChainFutures(self):
from chorde.clients.async import Defer, Future
ev = threading.Event()
ev2 = threading.Event()
def sleepit():
ev.wait()
return 2
def sleepit2():
ev2.wait()
return 3
d1 = Defer(sleepit)
d2 = Defer(sleepit2)
d1.future = Future()
d2.future = Future()
self.addCleanup(ev.set)
self.addCleanup(ev2.set)
self.client.put(1, sleepit, 120) # Delay the pool
self.client.put(3, d1, 120)
self.client.put(3, d2, 120)
self.assertTrue(self.client.contains(3))
ev.set()
self.assertEquals(d1.future.result(1), 2)
self.assertEquals(d2.future.result(1), 2)
self.assertTrue(self.client.contains(3))
self.assertEquals(self.client.get(3), 2)
def testFutures(self):
from chorde.clients.async import Defer, Future
frv = Future()
def sleepit():
return 1
d = Defer(sleepit)
d.future = frv
self.client.put(2, d, 120)
self.assertTrue(self.client.contains(2))
self.assertEquals(frv.result(1), 1)
self.assertTrue(self.client.contains(2))
self.assertEquals(self.client.get(2), 1)
self.assertTrue(frv.done())
def testAnyOnce(self):
from chorde.clients.async import Future
rv = []
def exc(exc):
rv.append("exc")
def value(val):
rv.append("val")
def miss():
rv.append("miss")
def badcall():
rv.append("bad")
f = Future()
f.on_any_once(value,miss,exc)
f.on_any_once(badcall,badcall,badcall)
f.set(3)
self.assertEquals(["val"], rv)
def testReentrantChainFutures(self):
from chorde.clients.async import Defer, Future
ev = threading.Event()
ev2 = threading.Event()
ev3 = threading.Event()
def sleepit():
ev3.set()
ev.wait()
return 2
def sleepit2():
return 3
d1 = Defer(sleepit)
d2 = Defer(sleepit2)
d1.future = Future()
d2.future = Future()
self.addCleanup(ev.set)
self.addCleanup(ev2.set)
client = self.client
def putit():
# Delay reentrant call until d1 was queued
ev2.wait()
client.put(4, d2, 120)
return 4
d3 = Defer(putit)
d3.future = Future()
self.client.put(3, d3, 120)
self.client.put(4, d1, 120)
ev2.set() # Unblock reentrant call now
self.assertTrue(self.client.contains(3))
self.assertEquals(d3.future.result(1), 4)
ev3.wait(1) # Avoid catching 4 in the blind spot between queuing and execution
self.assertTrue(self.client.contains(4))
ev.set() # Unblock d1
self.assertEquals(d1.future.result(1), 2)
self.assertEquals(d2.future.result(1), 2)
self.assertTrue(self.client.contains(4))
self.assertEquals(self.client.get(4), 2)
def testStepFutures(self):
from chorde.clients.async import Defer, Future
ev = threading.Event()
ev2 = threading.Event()
def sleepit():
ev2.set()
ev.wait()
return 2
d1 = Defer(sleepit)
d1.future = Future()
self.addCleanup(ev.set)
self.client.put(1, Defer(sleepit), 120) # Delay the pool
self.client.put(4, d1, 120)
self.client.put(4, 7, 120)
self.assertTrue(self.client.contains(4))
self.assertEquals(d1.future.result(1), 7)
self.assertTrue(self.client.contains(4))
self.assertEquals(self.client.get(4), 7)
def testAny(self):
from chorde.clients.async import Future
rv = []
def exc(exc):
rv.append("exc")
def value(val):
rv.append("val")
def miss():
rv.append("miss")
f = Future()
f.on_any(value,miss,exc)
f.exc((RuntimeError,RuntimeError(1),None))
self.assertEquals(["exc"], rv)
def foo():
f = Future()
f.set(1)
rv = yield f
raise Return(rv)
def testTimeout(self):
from chorde.clients.async import Future
f = Future()
self.assertRaises(TimeoutError, f.result, 0.1)
def testExc(self):
from chorde.clients.async import Future
f = Future()
f.exc((RuntimeError,RuntimeError(1),None))
self.assertRaises(RuntimeError, f.result, 0)
def testMiss(self):
from chorde.clients.async import Future
f = Future()
f.miss()
self.assertRaises(CacheMissError, f.result, 0)
def testPreSet(self):
from chorde.clients.async import Future
f = Future()
f.set(1)
self.assertEqual(f.result(0), 1)