Compat execute context did not re-raise exceptions, so some tests were actually failing.

celery/task/base.py

@@ -725,7 +725,7 @@ class BaseTask(object):
         """Returns :class:`~celery.task.sets.subtask` object for
         this task, wrapping arguments and execution options
         for a single task invocation."""
-        return subtask(cls, *args, **kwargs)
+        return sets.subtask(cls, *args, **kwargs)
 
     @property
     def __name__(self):

celery/tests/test_bin/test_celeryd.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import sys
+import warnings
 
 from multiprocessing import get_logger, current_process
 
@@ -108,18 +109,10 @@ class test_Worker(unittest.TestCase):
     def test_run(self):
         self.Worker().run()
         self.Worker(discard=True).run()
-
         worker = self.Worker()
         worker.init_loader()
-        worker.settings.DEBUG = True
-
-        def with_catch_warnings(log):
-            worker.run()
-            self.assertIn("memory leak", log[0].message.args[0])
+        worker.run()
 
-        context = catch_warnings(record=True)
-        execute_context(context, with_catch_warnings)
-        worker.settings.DEBUG = False
 
     @disable_stdouts
     def test_purge_messages(self):
@@ -162,7 +155,6 @@ class test_Worker(unittest.TestCase):
         worker2 = self.Worker(autoscale="10")
         self.assertListEqual(worker2.autoscale, [10, 0])
 
-    @disable_stdouts
     def test_include_argument(self):
         worker1 = self.Worker(include="some.module")
         self.assertListEqual(worker1.include, ["some.module"])
@@ -178,8 +170,8 @@ class test_Worker(unittest.TestCase):
         worker1 = self.Worker(loglevel=0xFFFF)
         self.assertEqual(worker1.loglevel, 0xFFFF)
 
-    @disable_stdouts
     def test_warns_if_running_as_privileged_user(self):
+        warnings.resetwarnings()
 
         def geteuid():
             return 0
@@ -190,7 +182,7 @@ class test_Worker(unittest.TestCase):
                 worker = self.Worker()
                 worker.run()
                 self.assertTrue(log)
-                self.assertIn("supervisor privileges is not encouraged",
+                self.assertIn("superuser privileges is not encouraged",
                               log[0].message.args[0])
             context = catch_warnings(record=True)
             execute_context(context, with_catch_warnings)

celery/tests/test_concurrency_base.py

@@ -0,0 +1,59 @@
+from itertools import count
+
+from celery.concurrency.base import apply_target, BasePool
+from celery.tests.utils import unittest
+
+
+class test_BasePool(unittest.TestCase):
+
+    def test_apply_target(self):
+
+        scratch = {}
+        counter = count(0).next
+
+        def gen_callback(name, retval=None):
+
+            def callback(*args):
+                scratch[name] = (counter(), args)
+                return retval
+
+            return callback
+
+        res = apply_target(gen_callback("target", 42),
+                           args=(8, 16),
+                           callback=gen_callback("callback"),
+                           accept_callback=gen_callback("accept_callback"))
+
+        self.assertDictEqual(scratch,
+                             {"accept_callback": (0, ()),
+                              "target": (1, (8, 16)),
+                              "callback": (2, (42, ))})
+
+        # No accept callback
+        scratch.clear()
+        res2 = apply_target(gen_callback("target", 42),
+                            args=(8, 16),
+                            callback=gen_callback("callback"),
+                            accept_callback=None)
+        self.assertDictEqual(scratch,
+                              {"target": (3, (8, 16)),
+                               "callback": (4, (42, ))})
+
+    def test_interface_on_start(self):
+        BasePool(10).on_start()
+
+    def test_interface_on_stop(self):
+        BasePool(10).on_stop()
+
+    def test_interface_on_apply(self):
+        BasePool(10).on_apply()
+
+    def test_interface_info(self):
+        self.assertDictEqual(BasePool(10).info, {})
+
+    def test_active(self):
+        p = BasePool(10)
+        self.assertFalse(p.active)
+        p._state = p.RUN
+        self.assertTrue(p.active)
+

celery/tests/test_decorators.py

@@ -0,0 +1,37 @@
+import warnings
+
+from celery import decorators
+from celery.task import base
+
+from celery.tests.compat import catch_warnings
+from celery.tests.utils import unittest
+from celery.tests.utils import execute_context
+
+
+def add(x, y):
+    return x + y
+
+
+class test_decorators(unittest.TestCase):
+
+    def assertCompatDecorator(self, decorator, type, **opts):
+        warnings.resetwarnings()
+
+        def with_catch_warnings(log):
+            return decorator(**opts)(add), log[0].message
+
+        context = catch_warnings(record=True)
+        task, w = execute_context(context, with_catch_warnings)
+
+        self.assertEqual(task(8, 8), 16)
+        self.assertTrue(task.accept_magic_kwargs)
+        self.assertIsInstance(task, type)
+        self.assertIsInstance(w, PendingDeprecationWarning)
+
+    def test_task(self):
+        self.assertCompatDecorator(decorators.task, base.Task)
+
+    def test_periodic_task(self):
+        self.assertCompatDecorator(decorators.periodic_task,
+                                   base.PeriodicTask,
+                                   run_every=1)

celery/tests/test_log.py

@@ -122,7 +122,7 @@ class test_default_logger(unittest.TestCase):
                                    root=False)
 
         def with_wrap_logger(sio):
-            p = LoggingProxy(logger)
+            p = LoggingProxy(logger, loglevel=logging.ERROR)
             p.close()
             p.write("foo")
             self.assertNotIn("foo", sio.getvalue())

celery/tests/test_task_sets.py

@@ -1,11 +1,11 @@
-from celery.tests.utils import unittest
-
 import anyjson
+import warnings
 
 from celery.app import app_or_default
 from celery.task import Task
 from celery.task.sets import subtask, TaskSet
 
+from celery.tests.utils import unittest
 from celery.tests.utils import execute_context
 from celery.tests.compat import catch_warnings
 
@@ -91,6 +91,7 @@ class test_subtask(unittest.TestCase):
 class test_TaskSet(unittest.TestCase):
 
     def test_interface__compat(self):
+        warnings.resetwarnings()
 
         def with_catch_warnings(log):
             ts = TaskSet(MockTask, [[(2, 2)], [(4, 4)], [(8, 8)]])
@@ -108,7 +109,7 @@ class test_TaskSet(unittest.TestCase):
         # TaskSet.task (deprecated)
         def with_catch_warnings2(log):
             ts = TaskSet(MockTask, [[(2, 2)], [(4, 4)], [(8, 8)]])
-            self.assertEqual(ts.task, MockTask)
+            self.assertEqual(ts.task.name, MockTask.name)
             self.assertTrue(log)
             self.assertIn("TaskSet.task is deprecated",
                           log[0].message.args[0])

celery/tests/utils.py

@@ -63,11 +63,13 @@ def execute_context(context, fun):
     exc_info = (None, None, None)
     retval = None
     try:
-        retval = fun(val)
-    except:
-        exc_info = sys.exc_info()
-    context.__exit__(*exc_info)
-    return retval
+        try:
+            return fun(val)
+        except:
+            exc_info = sys.exc_info()
+            raise
+    finally:
+        context.__exit__(*exc_info)
 
 
 try: