All tests passing

Author: ask

djcelery/snapshot.py

@@ -76,7 +76,7 @@ def handle_worker(self, hostname_worker):
 
     def handle_task(self, uuid_task, worker=None):
         """Handle snapshotted event."""
-        (uuid, task) = uuid_task
+        uuid, task = uuid_task
         if task.worker and task.worker.hostname:
             worker = self.handle_worker(
                 (task.worker.hostname, task.worker),

djcelery/tests/test_snapshot.py

@@ -4,6 +4,7 @@
 from itertools import count
 from time import time
 
+from celery import states
 from celery.events import Event as _Event
 from celery.events.state import State, Worker, Task
 from celery.utils import gen_unique_id
@@ -52,14 +53,14 @@ def test_get_heartbeat(self):
         t2 = time()
         t3 = time()
         for t in t1, t2, t3:
-            worker.on_heartbeat(t, t)
+            worker.event('heartbeat', t, t, {})
         self.state.workers[worker.hostname] = worker
         self.assertEqual(self.cam.get_heartbeat(worker),
                          make_aware(datetime.fromtimestamp(t3)))
 
     def test_handle_worker(self):
         worker = Worker(hostname='fuzzie')
-        worker.on_online(time(), time())
+        worker.event('online', time(), time(), {})
         self.cam._last_worker_write.clear()
         m = self.cam.handle_worker((worker.hostname, worker))
         self.assertTrue(m)
@@ -71,11 +72,11 @@ def test_handle_worker(self):
 
     def test_handle_task_received(self):
         worker = Worker(hostname='fuzzie')
-        worker.on_online(time(), time())
+        worker.event('oneline', time(), time(), {})
         self.cam.handle_worker((worker.hostname, worker))
 
         task = create_task(worker)
-        task.on_received(time())
+        task.event('received', time(), time(), {})
         self.assertEqual(task.state, 'RECEIVED')
         mt = self.cam.handle_task((task.uuid, task))
         self.assertEqual(mt.name, task.name)
@@ -87,36 +88,38 @@ def test_handle_task_received(self):
 
     def test_handle_task(self):
         worker1 = Worker(hostname='fuzzie')
-        worker1.on_online(time(), time())
+        worker1.event('online', time(), time(), {})
         mw = self.cam.handle_worker((worker1.hostname, worker1))
         task1 = create_task(worker1)
-        task1.on_received(timestamp=time())
+        task1.event('received', time(), time(), {})
         mt = self.cam.handle_task((task1.uuid, task1))
         self.assertEqual(mt.worker, mw)
 
         worker2 = Worker(hostname=None)
         task2 = create_task(worker2)
-        task2.on_received(timestamp=time())
+        task2.event('received', time(), time(), {})
         mt = self.cam.handle_task((task2.uuid, task2))
         self.assertIsNone(mt.worker)
 
-        task1.on_succeeded(timestamp=time(), result=42)
+        task1.event('succeeded', time(), time(), {'result': 42})
+        self.assertEqual(task1.state, states.SUCCESS)
+        self.assertEqual(task1.result, 42)
         mt = self.cam.handle_task((task1.uuid, task1))
         self.assertEqual(mt.name, task1.name)
         self.assertEqual(mt.result, 42)
 
         task3 = create_task(worker1, name=None)
-        task3.on_revoked(timestamp=time())
+        task3.event('revoked', time(), time(), {})
         mt = self.cam.handle_task((task3.uuid, task3))
         self.assertIsNone(mt)
 
     def assertExpires(self, dec, expired, tasks=10):
         worker = Worker(hostname='fuzzie')
-        worker.on_online(time(), time())
+        worker.event('online', time(), time(), {})
         for total in xrange(tasks):
             task = create_task(worker)
-            task.on_received(timestamp=time() - dec)
-            task.on_succeeded(timestamp=time() - dec, result=42)
+            task.event('received', time() - dec, time() - dec, {})
+            task.event('succeeded', time() - dec, time() - dec, {'result': 42})
             self.assertTrue(task.name)
             self.assertTrue(self.cam.handle_task((task.uuid, task)))
         self.assertEqual(self.cam.on_cleanup(), expired)