def test_fail(self):
"""Test event failure."""
result = []
def failed(res):
result.append(res)
e = TwistedEvent()
e.wait().addErrback(failed)
self.assertEqual(result, [])
f = Failure(Exception())
e.fail(f)
self.assertEqual(result, [f])
self.assertRaises(AlreadyFiredError, e.fire)
self.assertRaises(AlreadyFiredError, e.fail, f)
e.wait().addErrback(failed)
self.assertEqual(result, [f, f])
e.fail_if_not_fired(None)
e = TwistedEvent()
e.wait().addErrback(failed)
e.fail_if_not_fired(f)
self.assertEqual(result, [f, f, f])
def __init__(self,
delegate,
vhost,
spec,
heartbeat=0,
clock=None,
insist=False):
FrameReceiver.__init__(self, spec)
self.delegate = delegate
# XXX Cyclic dependency
self.delegate.client = self
self.vhost = vhost
self.channelFactory = type("Channel%s" % self.spec.klass.__name__,
(self.channelClass, self.spec.klass), {})
self.channels = {}
self.channelLock = defer.DeferredLock()
self.outgoing = defer.DeferredQueue()
self.work = defer.DeferredQueue()
self.started = TwistedEvent()
self.disconnected = TwistedEvent() # Fired upon connection shutdown
self.closed = False
self.queueLock = defer.DeferredLock()
self.basic_return_queue = TimeoutDeferredQueue()
self.queues = {}
self.outgoing.get().addCallback(self.writer)
self.work.get().addCallback(self.worker)
self.heartbeatInterval = heartbeat
self.insist = insist
if clock is None:
from twisted.internet import reactor
clock = reactor
self.clock = clock
if self.heartbeatInterval > 0:
self.checkHB = self.clock.callLater(
self.heartbeatInterval * self.MAX_UNSEEN_HEARTBEAT,
self.check_heartbeat)
self.sendHB = LoopingCall(self.send_heartbeat)
self.sendHB.clock = self.clock
d = self.started.wait()
d.addCallback(lambda _: self.reschedule_send_heartbeat())
d.addCallback(lambda _: self.reschedule_check_heartbeat())
# If self.started fails, don't start the heartbeat.
d.addErrback(lambda _: None)
def __init__(self, delegate, vhost, spec, heartbeat=0):
FrameReceiver.__init__(self, spec)
self.delegate = delegate
# XXX Cyclic dependency
self.delegate.client = self
self.vhost = vhost
self.channelFactory = type("Channel%s" % self.spec.klass.__name__,
(self.channelClass, self.spec.klass), {})
self.channels = {}
self.channelLock = defer.DeferredLock()
self.outgoing = defer.DeferredQueue()
self.work = defer.DeferredQueue()
self.started = TwistedEvent()
self.queueLock = defer.DeferredLock()
self.basic_return_queue = TimeoutDeferredQueue()
self.queues = {}
self.outgoing.get().addCallback(self.writer)
self.work.get().addCallback(self.worker)
self.heartbeatInterval = heartbeat
if self.heartbeatInterval > 0:
self.checkHB = reactor.callLater(
self.heartbeatInterval * self.MAX_UNSEEN_HEARTBEAT,
self.checkHeartbeat)
self.sendHB = LoopingCall(self.sendHeartbeat)
d = self.started.wait()
d.addCallback(lambda _: self.reschedule_sendHB())
d.addCallback(lambda _: self.reschedule_checkHB())
def test_independent(self):
"""Test that waiters are independent."""
result = []
def bad(res):
result.append(res)
raise Exception()
def fired(res):
result.append(res)
e = TwistedEvent()
d = e.wait().addCallback(bad)
e.wait().addCallback(fired)
d.addErrback(lambda _ : None)
e.fire()
self.assertEqual(result, [True, True])
def test_fire(self):
"""Test event success."""
result = []
def fired(res):
result.append(res)
e = TwistedEvent()
e.wait().addCallback(fired)
self.assertEqual(result, [])
e.fire()
self.assertEqual(result, [True])
self.assertRaises(AlreadyFiredError, e.fire)
self.assertRaises(AlreadyFiredError, e.fail, None)
e.wait().addCallback(fired)
self.assertEqual(result, [True, True])
e.fail_if_not_fired(None)
