def test_active(self):
r = Request(TaskMessage(self.mytask.name, 'do re mi'), app=self.app)
worker_state.active_requests.add(r)
try:
self.assertTrue(self.panel.handle('dump_active'))
finally:
worker_state.active_requests.discard(r)
def test_from_message_nonexistant_task(self):
m = TaskMessage(
'cu.mytask.doesnotexist',
args=[2], kwargs={'æØåveéðƒeæ': 'bar'},
)
with self.assertRaises(KeyError):
Request(m, app=self.app)
def test_query_task(self):
consumer = Consumer(self.app)
consumer.controller = _WC(app=self.app)
consumer.controller.consumer = consumer
panel = self.create_panel(consumer=consumer)
panel.app = self.app
req1 = Request(
TaskMessage(self.mytask.name, args=(2, 2)),
app=self.app,
)
worker_state.task_reserved(req1)
try:
self.assertFalse(panel.handle('query_task', {'ids': {'1daa'}}))
ret = panel.handle('query_task', {'ids': {req1.id}})
self.assertIn(req1.id, ret)
self.assertEqual(ret[req1.id][0], 'reserved')
worker_state.active_requests.add(req1)
try:
ret = panel.handle('query_task', {'ids': {req1.id}})
self.assertEqual(ret[req1.id][0], 'active')
finally:
worker_state.active_requests.clear()
ret = panel.handle('query_task', {'ids': {req1.id}})
self.assertEqual(ret[req1.id][0], 'reserved')
finally:
worker_state.reserved_requests.clear()
def test_fast_trace_task(self):
from celery.app import trace
setup_worker_optimizations(self.app)
self.assertIs(trace.trace_task_ret, trace._fast_trace_task)
tid = uuid()
message = TaskMessage(self.mytask.name, tid, args=[4])
assert len(message.payload) == 3
try:
self.mytask.__trace__ = build_tracer(
self.mytask.name, self.mytask, self.app.loader, 'test',
app=self.app,
)
failed, res, runtime = trace.trace_task_ret(
self.mytask.name, tid, message.headers, message.body,
message.content_type, message.content_encoding)
self.assertFalse(failed)
self.assertEqual(res, repr(4 ** 4))
self.assertIsNotNone(runtime)
self.assertIsInstance(runtime, numbers.Real)
finally:
reset_worker_optimizations()
self.assertIs(trace.trace_task_ret, trace._trace_task_ret)
delattr(self.mytask, '__trace__')
failed, res, runtime = trace.trace_task_ret(
self.mytask.name, tid, message.headers, message.body,
message.content_type, message.content_encoding, app=self.app,
)
self.assertFalse(failed)
self.assertEqual(res, repr(4 ** 4))
self.assertIsNotNone(runtime)
self.assertIsInstance(runtime, numbers.Real)
def test_from_message(self):
us = 'æØåveéðƒeæ'
tid = uuid()
m = TaskMessage(self.mytask.name, tid, args=[2], kwargs={us: 'bar'})
job = Request(m, app=self.app)
self.assertIsInstance(job, Request)
self.assertEqual(job.name, self.mytask.name)
self.assertEqual(job.id, tid)
self.assertIs(job.message, m)
def xRequest(self, name=None, id=None, args=None, kwargs=None,
on_ack=None, on_reject=None, Request=Request, **head):
args = [1] if args is None else args
kwargs = {'f': 'x'} if kwargs is None else kwargs
on_ack = on_ack or Mock(name='on_ack')
on_reject = on_reject or Mock(name='on_reject')
message = TaskMessage(
name or self.mytask.name, id, args=args, kwargs=kwargs, **head
)
return Request(message, app=self.app,
on_ack=on_ack, on_reject=on_reject)
def test_dump_schedule(self):
consumer = Consumer(self.app)
panel = self.create_panel(consumer=consumer)
self.assertFalse(panel.handle('dump_schedule'))
r = Request(TaskMessage(self.mytask.name, 'CAFEBABE'), app=self.app)
consumer.timer.schedule.enter_at(
consumer.timer.Entry(lambda x: x, (r, )),
datetime.now() + timedelta(seconds=10))
consumer.timer.schedule.enter_at(
consumer.timer.Entry(lambda x: x, (object(), )),
datetime.now() + timedelta(seconds=10))
self.assertTrue(panel.handle('dump_schedule'))
def test_trace_task_ret__no_trace(self):
try:
delattr(self.mytask, '__trace__')
except AttributeError:
pass
tid = uuid()
message = TaskMessage(self.mytask.name, tid, args=[4])
_, R, _ = _trace_task_ret(
self.mytask.name, tid, message.headers,
message.body, message.content_type,
message.content_encoding, app=self.app,
)
self.assertEqual(R, repr(4 ** 4))
def test_trace_task_ret(self):
self.mytask.__trace__ = build_tracer(
self.mytask.name, self.mytask, self.app.loader, 'test',
app=self.app,
)
tid = uuid()
message = TaskMessage(self.mytask.name, tid, args=[4])
_, R, _ = _trace_task_ret(
self.mytask.name, tid, message.headers,
message.body, message.content_type,
message.content_encoding, app=self.app,
)
self.assertEqual(R, repr(4 ** 4))
def test_dump_reserved(self):
consumer = Consumer(self.app)
worker_state.reserved_requests.add(
Request(TaskMessage(self.mytask.name, args=(2, 2)), app=self.app),
)
try:
panel = self.create_panel(consumer=consumer)
response = panel.handle('dump_reserved', {'safe': True})
self.assertDictContainsSubset(
{'name': self.mytask.name,
'hostname': socket.gethostname()},
response[0],
)
worker_state.reserved_requests.clear()
self.assertFalse(panel.handle('dump_reserved'))
finally:
worker_state.reserved_requests.clear()
def create_task_message(channel, *args, **kwargs):
m = TaskMessage(*args, **kwargs)
m.channel = channel
m.delivery_info = {'consumer_tag': 'mock'}
return m
def test_from_message_missing_required_fields(self):
m = TaskMessage(self.mytask.name)
m.headers.clear()
with self.assertRaises(KeyError):
Request(m, app=self.app)
def test_from_message_empty_args(self):
tid = uuid()
m = TaskMessage(self.mytask.name, tid, args=[], kwargs={})
job = Request(m, app=self.app)
self.assertIsInstance(job, Request)
def test_from_message_invalid_kwargs(self):
m = TaskMessage(self.mytask.name, args=(), kwargs='foo')
req = Request(m, app=self.app)
with self.assertRaises(InvalidTaskError):
raise req.execute().exception
def create_task_message(channel, *args, **kwargs):
m = TaskMessage(*args, **kwargs)
m.channel = channel
m.delivery_info = {'consumer_tag': 'mock'}
return m
