def test_poll_result(self):
class MockBinding(object):
get_returns = [True]
def __init__(self, *args, **kwargs):
pass
def __call__(self, *args, **kwargs):
return self
def declare(self):
pass
def get(self):
if self.get_returns[0]:
class Object(object):
payload = {"status": "STARTED",
"result": None}
return Object()
class MockBackend(AMQPBackend):
Queue = MockBinding
backend = MockBackend()
backend.poll(gen_unique_id())
uuid = gen_unique_id()
backend.poll(uuid)
self.assertIn(uuid, backend._cache)
MockBinding.get_returns[0] = False
backend._cache[uuid] = "hello"
self.assertEqual(backend.poll(uuid), "hello")
def assertStatusForIs(self, status, outcome):
uuid = gen_unique_id()
result = gen_unique_id()
default_app.backend.store_result(uuid, result, status)
json = self.client.get(task_is_successful(task_id=uuid))
self.assertJSONEqual(json, {"task": {"id": uuid,
"executed": outcome}})
def test_on_timeout(self):
class MockLogger(object):
def __init__(self):
self.warnings = []
self.errors = []
def warning(self, msg, *args, **kwargs):
self.warnings.append(msg)
def error(self, msg, *args, **kwargs):
self.errors.append(msg)
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.logger = MockLogger()
tw.on_timeout(soft=True)
self.assertIn("Soft time limit exceeded", tw.logger.warnings[0])
tw.on_timeout(soft=False)
self.assertIn("Hard time limit exceeded", tw.logger.errors[0])
self.assertEqual(mytask.backend.get_status(tw.task_id),
states.FAILURE)
mytask.ignore_result = True
try:
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.logger = MockLogger()
finally:
mytask.ignore_result = False
tw.on_timeout(soft=True)
self.assertEqual(mytask.backend.get_status(tw.task_id),
states.PENDING)
def test_forget(self):
subs = [MockAsyncResultSuccess(gen_unique_id()),
MockAsyncResultSuccess(gen_unique_id())]
ts = TaskSetResult(gen_unique_id(), subs)
ts.forget()
for sub in subs:
self.assertTrue(sub.forgotten)
def test_iter_native(self):
backend = SimpleBackend()
subtasks = [AsyncResult(gen_unique_id(), backend=backend)
for i in range(10)]
ts = TaskSetResult(gen_unique_id(), subtasks)
backend.ids = [subtask.task_id for subtask in subtasks]
self.assertEqual(len(list(ts.iter_native())), 10)
def test_iterate_eager(self):
ar1 = EagerResult(gen_unique_id(), 42, states.SUCCESS)
ar2 = EagerResult(gen_unique_id(), 42, states.SUCCESS)
ts = TaskSetResult(gen_unique_id(), [ar1, ar2])
it = iter(ts)
self.assertEqual(it.next(), 42)
self.assertEqual(it.next(), 42)
def assertStatusForIs(self, status, outcome, result=None):
uuid = gen_unique_id()
result = result or gen_unique_id()
current_app.backend.store_result(uuid, result, status)
json = self.client.get(task_is_successful(task_id=uuid))
self.assertJSONEqual(json, {'task': {'id': uuid,
'executed': outcome}})
def test_iterate_yields(self):
ar = MockAsyncResultSuccess(gen_unique_id())
ar2 = MockAsyncResultSuccess(gen_unique_id())
ts = TaskSetResult(gen_unique_id(), [ar, ar2])
it = iter(ts)
self.assertEqual(it.next(), 42)
self.assertEqual(it.next(), 42)
def test_backend(self):
b = DatabaseBackend()
tid = gen_unique_id()
self.assertEqual(b.get_status(tid), states.PENDING)
self.assertIsNone(b.get_result(tid))
b.mark_as_done(tid, 42)
self.assertEqual(b.get_status(tid), states.SUCCESS)
self.assertEqual(b.get_result(tid), 42)
tid2 = gen_unique_id()
result = {'foo': 'baz', 'bar': SomeClass(12345)}
b.mark_as_done(tid2, result)
# is serialized properly.
rindb = b.get_result(tid2)
self.assertEqual(rindb.get('foo'), 'baz')
self.assertEqual(rindb.get('bar').data, 12345)
tid3 = gen_unique_id()
try:
raise KeyError('foo')
except KeyError as exception:
pass
b.mark_as_failure(tid3, exception)
self.assertEqual(b.get_status(tid3), states.FAILURE)
self.assertIsInstance(b.get_result(tid3), KeyError)
def test_backend(self):
b = DatabaseBackend()
tid = gen_unique_id()
self.assertFalse(b.is_successful(tid))
self.assertEquals(b.get_status(tid), states.PENDING)
self.assertTrue(b.get_result(tid) is None)
b.mark_as_done(tid, 42)
self.assertTrue(b.is_successful(tid))
self.assertEquals(b.get_status(tid), states.SUCCESS)
self.assertEquals(b.get_result(tid), 42)
self.assertTrue(b._cache.get(tid))
self.assertTrue(b.get_result(tid), 42)
tid2 = gen_unique_id()
result = {"foo": "baz", "bar": SomeClass(12345)}
b.mark_as_done(tid2, result)
# is serialized properly.
rindb = b.get_result(tid2)
self.assertEquals(rindb.get("foo"), "baz")
self.assertEquals(rindb.get("bar").data, 12345)
tid3 = gen_unique_id()
try:
raise KeyError("foo")
except KeyError, exception:
pass
def test_revoke_from_resultset(self):
r = self.app.TaskSetResult(gen_unique_id(),
map(self.app.AsyncResult,
[gen_unique_id()
for i in range(10)]))
r.revoke()
self.assertIn("revoke", MockMailbox.sent)
def test_join_native(self):
backend = SimpleBackend()
subtasks = [AsyncResult(gen_unique_id(), backend=backend)
for i in range(10)]
ts = TaskSetResult(gen_unique_id(), subtasks)
backend.ids = [subtask.task_id for subtask in subtasks]
res = ts.join_native()
self.assertEqual(res, range(10))
def test_objects_ratio(self):
models.Feed.objects.all().delete()
[models.Feed.objects.create(name=gen_unique_id(),
feed_url=gen_unique_id(),
sort=0, ratio=i)
for i in (0, 0.23, 0.24, 0.25, 1.12, 2.43)]
self.assertEqual(models.Feed.objects.ratio(min=0).count(), 5)
self.assertEqual(
models.Feed.objects.ratio(min=0.23, max=0.25).count(), 1)
self.assertEqual(models.Feed.objects.ratio(max=0.24).count(), 2)
def test_save_restore_taskset(self):
backend = CacheBackend()
taskset_id = gen_unique_id()
subtask_ids = [gen_unique_id() for i in range(10)]
subtasks = map(result.AsyncResult, subtask_ids)
res = result.TaskSetResult(taskset_id, subtasks)
res.save(backend=backend)
saved = result.TaskSetResult.restore(taskset_id, backend=backend)
self.assertListEqual(saved.subtasks, subtasks)
self.assertEqual(saved.taskset_id, taskset_id)
def test_save_restore(self):
subs = [MockAsyncResultSuccess(gen_unique_id()),
MockAsyncResultSuccess(gen_unique_id())]
ts = TaskSetResult(gen_unique_id(), subs)
ts.save()
self.assertRaises(AttributeError, ts.save, backend=object())
self.assertEqual(TaskSetResult.restore(ts.taskset_id).subtasks,
ts.subtasks)
self.assertRaises(AttributeError,
TaskSetResult.restore, ts.taskset_id,
backend=object())
def test_sets_store_errors(self):
mytask.ignore_result = True
try:
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
self.assertFalse(tw._store_errors)
mytask.store_errors_even_if_ignored = True
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
self.assertTrue(tw._store_errors)
finally:
mytask.ignore_result = False
mytask.store_errors_even_if_ignored = False
def test_save_restore_delete_group(self):
backend = CacheBackend(app=app)
group_id = gen_unique_id()
subtask_ids = [gen_unique_id() for i in range(10)]
subtasks = map(result.AsyncResult, subtask_ids)
res = result.GroupResult(group_id, subtasks)
res.save(backend=backend)
saved = result.GroupResult.restore(group_id, backend=backend)
self.assertListEqual(saved.subtasks, subtasks)
self.assertEqual(saved.id, group_id)
saved.delete(backend=backend)
self.assertIsNone(result.GroupResult.restore(group_id, backend=backend))
def test_poll_result(self):
results = Queue()
class Message(object):
def __init__(self, **merge):
self.payload = dict({"status": states.STARTED,
"result": None}, **merge)
class MockBinding(object):
def __init__(self, *args, **kwargs):
pass
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
class MockBackend(AMQPBackend):
Queue = MockBinding
backend = MockBackend()
# 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.poll(gen_unique_id())
self.assertDictContainsSubset({"status": states.FAILURE,
"seq": 3}, r1,
"FFWDs to the last state")
# Caches last known state.
results.put(Message())
uuid = gen_unique_id()
backend.poll(uuid)
self.assertIn(uuid, backend._cache, "Caches last known state")
# Returns cache if no new states.
results.queue.clear()
assert not results.qsize()
backend._cache[uuid] = "hello"
self.assertEqual(backend.poll(uuid), "hello",
"Returns cache if no new states")
def test_expire_old_posts(self):
now = datetime.now()
f = models.Feed.objects.create(name="foozalaz",
feed_url=gen_unique_id(), sort=0)
[models.Post.objects.create(feed=f,
title=gen_unique_id(),
date_published=now,
date_updated=now)
for i in range(10)]
self.assertEqual(f.expire_old_posts(min_posts=5, max_posts=5), 5)
self.assertEqual(models.Post.objects.filter(feed=f).count(), 5)
self.assertEqual(f.expire_old_posts(min_posts=3, max_posts=3), 2)
self.assertEqual(models.Post.objects.filter(feed=f).count(), 3)
def test_cleanup(self):
tb = DatabaseBackend()
for i in range(10):
tb.mark_as_done(gen_unique_id(), 42)
tb.save_taskset(gen_unique_id(), {"foo": "bar"})
s = tb.ResultSession()
for t in s.query(Task).all():
t.date_done = datetime.now() - tb.result_expires * 2
for t in s.query(TaskSet).all():
t.date_done = datetime.now() - tb.result_expires * 2
s.commit()
s.close()
tb.cleanup()
def test_revoke_terminate(self):
request = Mock()
request.task_id = uuid = gen_unique_id()
state.active_requests.add(request)
try:
r = builtins.revoke(Mock(), uuid, terminate=True)
self.assertIn(uuid, revoked)
self.assertTrue(request.terminate.call_count)
self.assertIn("terminated", r["ok"])
# unknown task id only revokes
r = builtins.revoke(Mock(), gen_unique_id(), terminate=True)
self.assertIn("revoked", r["ok"])
finally:
state.active_requests.discard(request)
def apply(self):
"""Applies the taskset locally."""
taskset_id = gen_unique_id()
# This will be filled with EagerResults.
return TaskSetResult(taskset_id, [task.apply(taskset_id=taskset_id)
for task in self.tasks])
def test_send_email(self):
app = app_or_default()
old_mail_admins = app.mail_admins
old_enable_mails = mytask.send_error_emails
mail_sent = [False]
def mock_mail_admins(*args, **kwargs):
mail_sent[0] = True
app.mail_admins = mock_mail_admins
mytask.send_error_emails = True
try:
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
try:
raise KeyError("moofoobar")
except:
einfo = ExceptionInfo(sys.exc_info())
tw.on_failure(einfo)
self.assertTrue(mail_sent[0])
mail_sent[0] = False
mytask.send_error_emails = False
tw.on_failure(einfo)
self.assertFalse(mail_sent[0])
finally:
app.mail_admins = old_mail_admins
mytask.send_error_emails = old_enable_mails
def test_forget(self):
tb = CacheBackend(backend="memory://")
tid = gen_unique_id()
tb.mark_as_done(tid, {"foo": "bar"})
x = AsyncResult(tid, backend=tb)
x.forget()
self.assertIsNone(x.result)
def test_execute_success_no_kwargs(self):
tid = gen_unique_id()
tw = TaskRequest(mytask_no_kwargs.name, tid, [4], {})
self.assertEqual(tw.execute(), 256)
meta = mytask_no_kwargs.backend.get_task_meta(tid)
self.assertEqual(meta["result"], 256)
self.assertEqual(meta["status"], states.SUCCESS)
def test_execute_fail(self):
tid = gen_unique_id()
tw = TaskRequest(mytask_raising.name, tid, [4], {"f": "x"})
self.assertIsInstance(tw.execute(), ExceptionInfo)
meta = mytask_raising.backend.get_task_meta(tid)
self.assertEqual(meta["status"], states.FAILURE)
self.assertIsInstance(meta["result"], KeyError)
def test_empty(self):
x = buckets.TaskBucket(task_registry=self.registry)
self.assertTrue(x.empty())
x.put(MockJob(gen_unique_id(), TaskC.name, [], {}))
self.assertFalse(x.empty())
x.clear()
self.assertTrue(x.empty())
def with_ctypes_masked(_val):
from celery.utils import ctypes, gen_unique_id
self.assertIsNone(ctypes)
uuid = gen_unique_id()
self.assertTrue(uuid)
self.assertIsInstance(uuid, basestring)
def with_catch_warnings(log):
res = execute_and_trace(mytask.name, gen_unique_id(),
[4], {})
self.assertIsInstance(res, ExceptionInfo)
self.assertTrue(log)
self.assertIn("Exception outside", log[0].message.args[0])
self.assertIn("KeyError", log[0].message.args[0])
def test_execute_using_pool(self):
tid = gen_unique_id()
tw = TaskRequest(mytask.name, tid, [4], {"f": "x"})
class MockPool(BasePool):
target = None
args = None
kwargs = None
def __init__(self, *args, **kwargs):
pass
def apply_async(self, target, args=None, kwargs=None,
*margs, **mkwargs):
self.target = target
self.args = args
self.kwargs = kwargs
p = MockPool()
tw.execute_using_pool(p)
self.assertTrue(p.target)
self.assertEqual(p.args[0], mytask.name)
self.assertEqual(p.args[1], tid)
self.assertEqual(p.args[2], [4])
self.assertIn("f", p.args[3])
self.assertIn([4], p.args)
def test_mark_as_failure(self):
tb = CacheBackend(backend="memory://")
tid3 = gen_unique_id()
try:
raise KeyError("foo")
except KeyError, exception:
pass
def test_revoke_with_name_not_in_registry(self):
uuid = gen_unique_id()
m = {"method": "revoke",
"destination": hostname,
"arguments": {"task_id": uuid,
"task_name": "xxxxxxxxx33333333388888"}}
self.panel.dispatch_from_message(m)
self.assertIn(uuid, revoked)
def test_forget(self):
b = DatabaseBackend(app=app)
tid = gen_unique_id()
b.mark_as_done(tid, {'foo': 'bar'})
x = AsyncResult(tid)
self.assertEqual(x.result.get('foo'), 'bar')
x.forget()
self.assertIsNone(x.result)
def test_forget(self):
b = CacheBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {"foo": "bar"})
self.assertEqual(b.get_result(tid).get("foo"), "bar")
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_cleanup(self):
tb = DatabaseBackend()
for i in range(10):
tb.mark_as_done(gen_unique_id(), 42)
tb.save_taskset(gen_unique_id(), {"foo": "bar"})
s = tb.ResultSession()
for t in s.query(Task).all():
t.date_done = datetime.now() - tb.result_expires * 2
for t in s.query(TaskSet).all():
t.date_done = datetime.now() - tb.result_expires * 2
s.commit()
s.close()
tb.cleanup()
s2 = tb.ResultSession()
self.assertEqual(s2.query(Task).count(), 0)
self.assertEqual(s2.query(TaskSet).count(), 0)
def test_from_message_nonexistant_task(self):
body = {"task": "cu.mytask.doesnotexist", "id": gen_unique_id(),
"args": [2], "kwargs": {u"æØåveéðƒeæ": "bar"}}
m = Message(None, body=anyjson.serialize(body), backend="foo",
content_type="application/json",
content_encoding="utf-8")
self.assertRaises(NotRegistered, TaskRequest.from_message,
m, m.decode())
def test_execute_ack(self):
tid = gen_unique_id()
tw = TaskRequest(mytask.name, tid, [4], {"f": "x"}, on_ack=on_ack)
self.assertEqual(tw.execute(), 256)
meta = mytask.backend.get_task_meta(tid)
self.assertTrue(scratch["ACK"])
self.assertEqual(meta["result"], 256)
self.assertEqual(meta["status"], states.SUCCESS)
def test_on_accepted_acks_late(self):
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
mytask.acks_late = True
try:
tw.on_accepted(pid=os.getpid(), time_accepted=time.time())
self.assertFalse(tw.acknowledged)
finally:
mytask.acks_late = False
def test_on_failure_WorkerLostError(self):
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
try:
raise WorkerLostError("do re mi")
except WorkerLostError:
exc_info = ExceptionInfo(sys.exc_info())
tw.on_failure(exc_info)
self.assertEqual(mytask.backend.get_status(tw.task_id), states.FAILURE)
mytask.ignore_result = True
try:
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.on_failure(exc_info)
self.assertEqual(mytask.backend.get_status(tw.task_id),
states.PENDING)
finally:
mytask.ignore_result = False
def test_execute_success_some_kwargs(self):
tid = gen_unique_id()
tw = TaskRequest(mytask_some_kwargs.name, tid, [4], {})
self.assertEqual(tw.execute(logfile="foobaz.log"), 256)
meta = mytask_some_kwargs.backend.get_task_meta(tid)
self.assertEqual(some_kwargs_scratchpad.get("logfile"), "foobaz.log")
self.assertEqual(meta["result"], 256)
self.assertEqual(meta["status"], states.SUCCESS)
def test_ready(self):
oks = (AsyncResult(self.task1["id"]),
AsyncResult(self.task2["id"]),
AsyncResult(self.task3["id"]))
self.assertTrue(all(result.ready() for result in oks))
self.assertFalse(AsyncResult(self.task4["id"]).ready())
self.assertFalse(AsyncResult(gen_unique_id()).ready())
def test_mark_as_retry(self):
tb = DatabaseBackend()
tid = gen_unique_id()
try:
raise KeyError("foo")
except KeyError, exception:
import traceback
trace = "\n".join(traceback.format_stack())
def test_execute_acks_late(self):
mytask_raising.acks_late = True
tw = TaskRequest(mytask_raising.name, gen_unique_id(), [1], {"f": "x"})
try:
tw.execute()
self.assertTrue(tw.acknowledged)
finally:
mytask_raising.acks_late = False
def test_get_set_forget(self):
b = self.Backend()
uuid = gen_unique_id()
b.store_result(uuid, 42, states.SUCCESS)
self.assertEqual(b.get_status(uuid), states.SUCCESS)
self.assertEqual(b.get_result(uuid), 42)
b.forget(uuid)
self.assertEqual(b.get_status(uuid), states.PENDING)
def test_terminate__task_reserved(self):
pool = Mock()
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.time_start = None
tw.terminate(pool, signal="KILL")
self.assertFalse(pool.terminate_job.call_count)
self.assertTupleEqual(tw._terminate_on_ack, (True, pool, "KILL"))
tw.terminate(pool, signal="KILL")
def with_wrap_logger(sio):
uuid = gen_unique_id()
ret = jail(uuid, mytask.name, [2], {})
self.assertEqual(ret, 4)
mytask.backend.mark_as_done.assert_called_with(uuid, 4)
logs = sio.getvalue().strip()
self.assertIn("Process cleanup failed", logs)
return 1234
def test_forget(self):
b = CacheBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {'foo': 'bar'})
self.assertEqual(b.get_result(tid).get('foo'), 'bar')
b.forget(tid)
self.assertNotIn(tid, b._cache)
self.assertIsNone(b.get_result(tid))
def test_forget(self):
b = DatabaseBackend()
tid = gen_unique_id()
b.mark_as_done(tid, {"foo": "bar"})
x = AsyncResult(tid)
self.assertEqual(x.result.get("foo"), "bar")
x.forget()
self.assertIsNone(x.result)
def test_mark_as_failure(self):
tb = get_redis_or_SkipTest()
tid3 = gen_unique_id()
try:
raise KeyError("foo")
except KeyError, exception:
pass
def delay_task(self,
task_name,
task_args=None,
task_kwargs=None,
countdown=None,
eta=None,
task_id=None,
taskset_id=None,
exchange=None,
exchange_type=None,
expires=None,
**kwargs):
"""Delay task for execution by the celery nodes."""
task_id = task_id or gen_unique_id()
task_args = task_args or []
task_kwargs = task_kwargs or {}
now = None
if countdown: # convert countdown to ETA.
now = datetime.now()
eta = now + timedelta(seconds=countdown)
if not isinstance(task_args, (list, tuple)):
raise ValueError("task args must be a list or tuple")
if not isinstance(task_kwargs, dict):
raise ValueError("task kwargs must be a dictionary")
if isinstance(expires, int):
now = now or datetime.now()
expires = now + timedelta(seconds=expires)
message_data = {
"task": task_name,
"id": task_id,
"args": task_args or [],
"kwargs": task_kwargs or {},
"retries": kwargs.get("retries", 0),
"eta": eta and eta.isoformat(),
"expires": expires and expires.isoformat(),
}
if taskset_id:
message_data["taskset"] = taskset_id
# custom exchange passed, need to declare it
if exchange and exchange not in _exchanges_declared:
exchange_type = exchange_type or self.exchange_type
self.backend.exchange_declare(exchange=exchange,
type=exchange_type,
durable=self.durable,
auto_delete=self.auto_delete)
self.send(message_data,
exchange=exchange,
**extract_msg_options(kwargs))
signals.task_sent.send(sender=task_name, **message_data)
return task_id
def test_on_shutter(self):
state = self.state
cam = self.cam
ws = ["worker1.ex.com", "worker2.ex.com", "worker3.ex.com"]
uus = [gen_unique_id() for i in xrange(50)]
events = [Event("worker-online", hostname=ws[0]),
Event("worker-online", hostname=ws[1]),
Event("worker-online", hostname=ws[2]),
Event("task-received", uuid=uus[0], name="A",
hostname=ws[0]),
Event("task-started", uuid=uus[0], name="A",
hostname=ws[0]),
Event("task-received", uuid=uus[1], name="B",
hostname=ws[1]),
Event("task-revoked", uuid=uus[2], name="C",
hostname=ws[2])]
map(state.event, events)
cam.on_shutter(state)
for host in ws:
worker = models.WorkerState.objects.get(hostname=host)
self.assertTrue(worker.is_alive())
t1 = models.TaskState.objects.get(task_id=uus[0])
self.assertEqual(t1.state, "STARTED")
self.assertEqual(t1.name, "A")
t2 = models.TaskState.objects.get(task_id=uus[1])
self.assertEqual(t2.state, "RECEIVED")
t3 = models.TaskState.objects.get(task_id=uus[2])
self.assertEqual(t3.state, "REVOKED")
events = [Event("task-succeeded", uuid=uus[0],
hostname=ws[0],
result=42),
Event("task-failed", uuid=uus[1],
exception="KeyError('foo')",
hostname=ws[1]),
Event("worker-offline", hostname=ws[0])]
map(state.event, events)
cam._last_worker_write.clear()
cam.on_shutter(state)
w1 = models.WorkerState.objects.get(hostname=ws[0])
self.assertFalse(w1.is_alive())
t1 = models.TaskState.objects.get(task_id=uus[0])
self.assertEqual(t1.state, "SUCCESS")
self.assertEqual(t1.result, u'42')
self.assertEqual(t1.worker, w1)
t2 = models.TaskState.objects.get(task_id=uus[1])
self.assertEqual(t2.state, "FAILURE")
self.assertEqual(t2.result, u"KeyError('foo')")
self.assertEqual(t2.worker.hostname, ws[1])
cam.on_shutter(state)
def test_process_cleanup_BaseException(self):
backend = mytask.backend
mytask.backend = Mock()
mytask.backend.process_cleanup = Mock(side_effect=SystemExit())
try:
self.assertRaises(SystemExit, jail, gen_unique_id(), mytask.name,
[2], {})
finally:
mytask.backend = backend
def test_on_retry(self):
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.eventer = MockEventDispatcher()
try:
raise RetryTaskError("foo", KeyError("moofoobar"))
except:
einfo = ExceptionInfo(sys.exc_info())
tw.on_failure(einfo)
self.assertIn("task-retried", tw.eventer.sent)
def test_update_state(self):
@task_dec
def yyy():
pass
tid = gen_unique_id()
yyy.update_state(tid, "FROBULATING", {"fooz": "baaz"})
self.assertEqual(yyy.AsyncResult(tid).status, "FROBULATING")
self.assertDictEqual(yyy.AsyncResult(tid).result, {"fooz": "baaz"})
def test_on_success_acks_late(self):
tw = TaskRequest(mytask.name, gen_unique_id(), [1], {"f": "x"})
tw.time_start = 1
mytask.acks_late = True
try:
tw.on_success(42)
self.assertTrue(tw.acknowledged)
finally:
mytask.acks_late = False
def __init__(self):
self.ready_queue = FastQueue()
self.ready_queue.put(
TaskRequest(task_name=mytask.name,
task_id=gen_unique_id(),
args=(2, 2),
kwargs={}))
self.eta_schedule = Timer()
self.event_dispatcher = Dispatcher()
def test_mark_as_failure(self):
tb1 = self.create_backend()
tb2 = self.create_backend()
tid3 = gen_unique_id()
try:
raise KeyError("foo")
except KeyError, exception:
einfo = ExceptionInfo(sys.exc_info())
def test_is_pickled(self):
tb = CacheBackend(backend="memory://")
tid2 = gen_unique_id()
result = {"foo": "baz", "bar": SomeClass(12345)}
tb.mark_as_done(tid2, result)
# is serialized properly.
rindb = tb.get_result(tid2)
self.assertEqual(rindb.get("foo"), "baz")
self.assertEqual(rindb.get("bar").data, 12345)
def test_is_pickled(self):
tb = get_redis_or_SkipTest()
tid2 = gen_unique_id()
result = {"foo": "baz", "bar": SomeClass(12345)}
tb.mark_as_done(tid2, result)
# is serialized properly.
rindb = tb.get_result(tid2)
self.assertEqual(rindb.get("foo"), "baz")
self.assertEqual(rindb.get("bar").data, 12345)
def test_is_pickled(self):
cb = CacheBackend(app=app)
tid2 = gen_unique_id()
result = {'foo': 'baz', 'bar': SomeClass(12345)}
cb.mark_as_done(tid2, result)
# is serialized properly.
rindb = cb.get_result(tid2)
self.assertEqual(rindb.get('foo'), 'baz')
self.assertEqual(rindb.get('bar').data, 12345)
