def _result_context(self):
results = Queue()
class Message(object):
acked = 0
requeued = 0
def __init__(self, **merge):
self.payload = dict({
'status': states.STARTED,
'result': None
}, **merge)
self.body = pickle.dumps(self.payload)
self.content_type = 'application/x-python-serialize'
self.content_encoding = 'binary'
def ack(self, *args, **kwargs):
self.acked += 1
def requeue(self, *args, **kwargs):
self.requeued += 1
class MockBinding(object):
def __init__(self, *args, **kwargs):
self.channel = Mock()
def __call__(self, *args, **kwargs):
return self
def declare(self):
pass
def get(self, no_ack=False, accept=None):
try:
m = results.get(block=False)
if m:
m.accept = accept
return m
except Empty:
pass
def is_bound(self):
return True
class MockBackend(AMQPBackend):
Queue = MockBinding
backend = MockBackend(self.app)
backend._republish = Mock()
yield results, backend, Message
def test_run(self):
ready_queue = Queue()
condition = [None]
def mycallback(value):
condition[0].set()
m = Mediator(ready_queue, mycallback)
condition[0] = m._is_shutdown
ready_queue.put(MockTask('Elaine M. Benes'))
m.run()
self.assertTrue(m._is_shutdown.isSet())
self.assertTrue(m._is_stopped.isSet())
def test_mediator_body(self):
ready_queue = Queue()
got = {}
def mycallback(value):
got['value'] = value.value
m = Mediator(ready_queue, mycallback)
ready_queue.put(MockTask('George Costanza'))
m.body()
self.assertEqual(got['value'], 'George Costanza')
ready_queue.put(MockTask('Jerry Seinfeld'))
m._does_debug = False
m.body()
self.assertEqual(got['value'], 'Jerry Seinfeld')
def test_mediator_crash(self, _exit):
ms = [None]
class _Mediator(Mediator):
def body(self):
try:
raise KeyError('foo')
finally:
ms[0]._is_shutdown.set()
ready_queue = Queue()
ms[0] = m = _Mediator(ready_queue, None)
ready_queue.put(MockTask('George Constanza'))
stderr = Mock()
p, sys.stderr = sys.stderr, stderr
try:
m.run()
finally:
sys.stderr = p
self.assertTrue(_exit.call_count)
self.assertTrue(stderr.write.call_count)
def __init__(self, fill_rate, queue=None, capacity=1):
self._bucket = TokenBucket(fill_rate, capacity)
self.queue = queue
if not self.queue:
self.queue = Queue()
def __init__(self):
self._buffer = Queue()
self._count = count(1)
self._tref = None
self._pool = None
def test_poll_result(self):
results = Queue()
class Message(object):
def __init__(self, **merge):
self.payload = dict({
'status': states.STARTED,
'result': None
}, **merge)
self.body = pickle.dumps(self.payload)
self.content_type = 'application/x-python-serialize'
self.content_encoding = 'binary'
class MockBinding(object):
def __init__(self, *args, **kwargs):
self.channel = Mock()
def __call__(self, *args, **kwargs):
return self
def declare(self):
pass
def get(self, no_ack=False):
try:
return results.get(block=False)
except Empty:
pass
def is_bound(self):
return True
class MockBackend(AMQPBackend):
Queue = MockBinding
backend = MockBackend()
backend._republish = Mock()
# FFWD's to the latest state.
results.put(Message(status=states.RECEIVED, seq=1))
results.put(Message(status=states.STARTED, seq=2))
results.put(Message(status=states.FAILURE, seq=3))
r1 = backend.get_task_meta(uuid())
self.assertDictContainsSubset({
'status': states.FAILURE,
'seq': 3
}, r1, 'FFWDs to the last state')
# Caches last known state.
results.put(Message())
tid = uuid()
backend.get_task_meta(tid)
self.assertIn(tid, backend._cache, 'Caches last known state')
self.assertTrue(backend._republish.called)
# Returns cache if no new states.
results.queue.clear()
assert not results.qsize()
backend._cache[tid] = 'hello'
self.assertEqual(backend.get_task_meta(tid), 'hello',
'Returns cache if no new states')
