def test_call_at(self): ioloop = get_event_loop() d1 = pulsar.Deferred() d2 = pulsar.Deferred() c1 = ioloop.call_at(ioloop.timer() + 1, lambda: d1.callback(ioloop.timer())) c2 = ioloop.call_later(1, lambda: d2.callback(ioloop.timer())) t1, t2 = yield pulsar.multi_async((d1, d2)) self.assertTrue(t1 <= t2)
def test_call_later_cheat(self): ioloop = get_event_loop() def dummy(d, sleep=None): d.callback(time.time()) if sleep: time.sleep(sleep) d1 = pulsar.Deferred() d2 = pulsar.Deferred() ioloop.call_later(0, dummy, d1, 0.2) ioloop.call_later(-5, dummy, d2) yield d2 self.assertTrue(d1.result < d2.result)
def test_periodic(self): test = self ioloop = get_event_loop() d = pulsar.Deferred() # class p: def __init__(self, loops): self.loops = loops self.c = 0 def __call__(self): self.c += 1 if self.c == self.loops: try: raise ValueError('test periodic') except Exception: mute_failure(test, sys.exc_info()) raise finally: d.callback(self.c) # every = 2 loops = 2 track = p(loops) start = time.time() periodic = ioloop.call_repeatedly(every, track) loop = yield d taken = time.time() - start self.assertEqual(loop, loops) self.assertTrue(taken > every * loops) self.assertTrue(taken < every * loops + 2) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))
def _maybe_async(obj, **params): # pragma nocover if isinstance(obj, Deferred): d = pulsar.Deferred() d._twisted_deferred = obj obj.addBoth(d.callback) obj = d return default_maybe_async(obj, **params)
def test_call_soon(self): ioloop = get_event_loop() d = pulsar.Deferred() callback = lambda: d.callback(current_thread().ident) cbk = ioloop.call_soon(callback) self.assertEqual(cbk.callback, callback) self.assertEqual(cbk.args, ()) # we should be able to wait less than a second yield d self.assertEqual(d.result, ioloop.tid)
def test_run_until_complete(self): event_loop = new_event_loop(iothreadloop=False) self.assertFalse(event_loop.running) self.assertFalse(event_loop.iothreadloop) self.assertEqual(str(event_loop), '<not running> pulsar') d = pulsar.Deferred() event_loop.call_later(2, d.callback, 'OK') event_loop.run_until_complete(d) self.assertTrue(d.done()) self.assertEqual(d.result, 'OK') self.assertFalse(event_loop.running)
def test_run_until_complete_timeout(self): event_loop = new_event_loop(iothreadloop=False) self.assertFalse(event_loop.running) self.assertFalse(event_loop.iothreadloop) d = pulsar.Deferred() event_loop.call_later(10, d.callback, 'OK') self.assertRaises(pulsar.TimeoutError, event_loop.run_until_complete, d, timeout=2) self.assertFalse(d.done()) self.assertFalse(event_loop.running)
def test_yield(self): '''Yielding a deferred calling back on separate thread''' worker = pulsar.get_actor() loop = pulsar.get_request_loop() self.assertNotEqual(worker.tid, current_thread().ident) self.assertEqual(loop.tid, current_thread().ident) yield pulsar.NOT_DONE self.assertEqual(loop.tid, current_thread().ident) d = pulsar.Deferred() # We are calling back the deferred in the event_loop which is on # a separate thread def _callback(): d.callback(current_thread().ident) worker.event_loop.call_later(0.2, _callback) yield d self.assertEqual(worker.tid, d.result) self.assertEqual(worker.event_loop.tid, d.result) self.assertNotEqual(worker.tid, current_thread().ident) self.assertEqual(loop.tid, current_thread().ident)
def test_call_later(self): ioloop = get_event_loop() d = pulsar.Deferred() timeout1 = ioloop.call_later( 20, lambda: d.callback(current_thread().ident)) timeout2 = ioloop.call_later( 10, lambda: d.callback(current_thread().ident)) # lets wake the ioloop self.assertTrue(ioloop.has_callback(timeout1)) self.assertTrue(ioloop.has_callback(timeout2)) timeout1.cancel() timeout2.cancel() self.assertTrue(timeout1.cancelled) self.assertTrue(timeout2.cancelled) timeout1 = ioloop.call_later( 0.1, lambda: d.callback(current_thread().ident)) yield d self.assertTrue(d.done()) self.assertEqual(d.result, ioloop.tid) self.assertFalse(ioloop.has_callback(timeout1))
def test_call_every(self): test = self ioloop = get_event_loop() thread = current_thread() d = pulsar.Deferred() test = self # class p: def __init__(self, loop): self.loop = loop self.c = 0 self.prev_loop = 0 def __call__(self): try: test.assertNotEqual(current_thread(), thread) if self.prev_loop: test.assertEqual(ioloop.num_loops, self.prev_loop + 1) except Exception: d.callback(sys.exc_info()) else: self.prev_loop = ioloop.num_loops self.c += 1 if self.c == self.loop: d.callback(self.c) try: raise ValueError('test call every') except Exception: mute_failure(test, Failure(sys.exc_info())) raise # loops = 5 track = p(loops) start = time.time() periodic = ioloop.call_every(track) loop = yield d self.assertEqual(loop, loops) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))