def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertTrue(isinstance(T1(), T1))
self.assertTrue(T1().run())
self.assertTrue(callable(T1()),
"Task class is callable()")
self.assertTrue(T1()(),
"Task class runs run() when called")
# task name generated out of class module + name.
T2 = self.createTaskCls("T2")
self.assertEquals(T2().name, "celery.tests.test_task.T2")
registry.tasks.register(T1)
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertTrue(consumer.fetch() is None)
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEquals(consumer, presult, t1.name)
# With arguments.
presult2 = task.delay_task(t1.name, name="George Constanza")
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza")
# With eta.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
eta=datetime.now() + timedelta(days=1))
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
# With countdown.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
countdown=10)
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
self.assertRaises(registry.tasks.NotRegistered, task.delay_task,
"some.task.that.should.never.exist.X.X.X.X.X")
# Discarding all tasks.
task.discard_all()
tid3 = task.delay_task(t1.name)
self.assertEquals(task.discard_all(), 1)
self.assertTrue(consumer.fetch() is None)
self.assertFalse(task.is_done(presult.task_id))
self.assertFalse(presult.is_done())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(task.is_done(presult.task_id))
self.assertTrue(presult.is_done())
publisher = t1.get_publisher()
self.assertTrue(isinstance(publisher, messaging.TaskPublisher))
def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertIsInstance(T1(), T1)
self.assertTrue(T1().run())
self.assertTrue(callable(T1()),
"Task class is callable()")
self.assertTrue(T1()(),
"Task class runs run() when called")
# task name generated out of class module + name.
T2 = self.createTaskCls("T2")
self.assertTrue(T2().name.endswith("test_task.T2"))
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertIsNone(consumer.fetch())
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEqual(consumer, presult, t1.name)
# With arguments.
presult2 = t1.apply_async(kwargs=dict(name="George Constanza"))
self.assertNextTaskDataEqual(consumer, presult2, t1.name,
name="George Constanza")
# send_task
sresult = send_task(t1.name, kwargs=dict(name="Elaine M. Benes"))
self.assertNextTaskDataEqual(consumer, sresult, t1.name,
name="Elaine M. Benes")
# With eta.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
eta=datetime.now() + timedelta(days=1))
self.assertNextTaskDataEqual(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
# With countdown.
presult2 = task.apply_async(t1, kwargs=dict(name="George Constanza"),
countdown=10)
self.assertNextTaskDataEqual(consumer, presult2, t1.name,
name="George Constanza", test_eta=True)
# Discarding all tasks.
consumer.discard_all()
task.apply_async(t1)
self.assertEqual(consumer.discard_all(), 1)
self.assertIsNone(consumer.fetch())
self.assertFalse(presult.successful())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(presult.successful())
publisher = t1.get_publisher()
self.assertIsInstance(publisher, messaging.TaskPublisher)
def save_result(task):
traceback = "Some traceback"
if task["status"] == states.SUCCESS:
default_backend.mark_as_done(task["id"], task["result"])
elif task["status"] == states.RETRY:
default_backend.mark_as_retry(task["id"], task["result"],
traceback=traceback)
else:
default_backend.mark_as_failure(task["id"], task["result"],
traceback=traceback)
def save_result(task):
traceback = "Some traceback"
if task["status"] == states.SUCCESS:
default_backend.mark_as_done(task["id"], task["result"])
elif task["status"] == states.RETRY:
default_backend.mark_as_retry(task["id"], task["result"],
traceback=traceback)
else:
default_backend.mark_as_failure(task["id"], task["result"],
traceback=traceback)
def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertTrue(isinstance(T1(), T1))
self.assertTrue(T1().run())
self.assertTrue(callable(T1()),
"Task class is callable()")
self.assertTrue(T1()(),
"Task class runs run() when called")
# task without name raises NotImplementedError
T2 = self.createTaskCls("T2")
self.assertRaises(NotImplementedError, T2)
registry.tasks.register(T1)
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertTrue(consumer.fetch() is None)
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEquals(consumer, presult, t1.name)
# With arguments.
presult2 = task.delay_task(t1.name, name="George Constanza")
self.assertNextTaskDataEquals(consumer, presult2, t1.name,
name="George Constanza")
self.assertRaises(registry.tasks.NotRegistered, task.delay_task,
"some.task.that.should.never.exist.X.X.X.X.X")
# Discarding all tasks.
task.discard_all()
tid3 = task.delay_task(t1.name)
self.assertEquals(task.discard_all(), 1)
self.assertTrue(consumer.fetch() is None)
self.assertFalse(task.is_done(presult.task_id))
self.assertFalse(presult.is_done())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(task.is_done(presult.task_id))
self.assertTrue(presult.is_done())
publisher = t1.get_publisher()
self.assertTrue(isinstance(publisher, messaging.TaskPublisher))
def handle_success(self, retval):
"""Handle successful execution.
Saves the result to the current result store (skipped if the callable
has a ``ignore_result`` attribute set to ``True``).
If the callable has a ``on_success`` function, it as called with
``retval`` as argument.
:param retval: The return value.
"""
if not getattr(self.fun, "ignore_result", False):
default_backend.mark_as_done(self.task_id, retval)
# Run success handler last to be sure the status is saved.
success_handler = getattr(self.fun, "on_success", noop)
success_handler(retval, self.task_id, self.args, self.kwargs)
return retval
def save_result(task):
if task["status"] == "DONE":
default_backend.mark_as_done(task["id"], task["result"])
else:
default_backend.mark_as_failure(task["id"], task["result"])
cache.cache.close()
# Backend process cleanup
default_backend.process_cleanup()
try:
result = func(*args, **kwargs)
except (SystemExit, KeyboardInterrupt):
raise
except Exception, exc:
stored_exc = default_backend.mark_as_failure(task_id, exc)
type_, _, tb = sys.exc_info()
retval = ExceptionInfo((type_, stored_exc, tb))
else:
if not ignore_result:
default_backend.mark_as_done(task_id, result)
retval = result
finally:
timer_stat.stop()
return retval
class TaskWrapper(object):
"""Class wrapping a task to be run.
:param task_name: see :attr:`task_name`.
:param task_id: see :attr:`task_id`.
:param task_func: see :attr:`task_func`
def test_regular_task(self):
T1 = self.createTaskCls("T1", "c.unittest.t.t1")
self.assertIsInstance(T1(), T1)
self.assertTrue(T1().run())
self.assertTrue(callable(T1()), "Task class is callable()")
self.assertTrue(T1()(), "Task class runs run() when called")
# task name generated out of class module + name.
T2 = self.createTaskCls("T2")
self.assertTrue(T2().name.endswith("test_task.T2"))
t1 = T1()
consumer = t1.get_consumer()
self.assertRaises(NotImplementedError, consumer.receive, "foo", "foo")
consumer.discard_all()
self.assertIsNone(consumer.fetch())
# Without arguments.
presult = t1.delay()
self.assertNextTaskDataEqual(consumer, presult, t1.name)
# With arguments.
presult2 = t1.apply_async(kwargs=dict(name="George Costanza"))
self.assertNextTaskDataEqual(consumer,
presult2,
t1.name,
name="George Costanza")
# send_task
sresult = send_task(t1.name, kwargs=dict(name="Elaine M. Benes"))
self.assertNextTaskDataEqual(consumer,
sresult,
t1.name,
name="Elaine M. Benes")
# With eta.
presult2 = task.apply_async(t1,
kwargs=dict(name="George Costanza"),
eta=datetime.now() + timedelta(days=1))
self.assertNextTaskDataEqual(consumer,
presult2,
t1.name,
name="George Costanza",
test_eta=True)
# With countdown.
presult2 = task.apply_async(t1,
kwargs=dict(name="George Costanza"),
countdown=10)
self.assertNextTaskDataEqual(consumer,
presult2,
t1.name,
name="George Costanza",
test_eta=True)
# Discarding all tasks.
consumer.discard_all()
task.apply_async(t1)
self.assertEqual(consumer.discard_all(), 1)
self.assertIsNone(consumer.fetch())
self.assertFalse(presult.successful())
default_backend.mark_as_done(presult.task_id, result=None)
self.assertTrue(presult.successful())
publisher = t1.get_publisher()
self.assertIsInstance(publisher, messaging.TaskPublisher)
