More tests

celery/tests/test_backends/test_base.py

@@ -2,6 +2,7 @@ import sys
 import types
 from celery.tests.utils import unittest
 
+from celery.utils import serialization
 from celery.utils.serialization import subclass_exception
 from celery.utils.serialization import \
         find_nearest_pickleable_exception as fnpe
@@ -27,6 +28,15 @@ Lookalike = subclass_exception("Lookalike", wrapobject, "foo.module")
 b = BaseBackend()
 
 
+class test_serialization(unittest.TestCase):
+
+    def test_create_exception_cls(self):
+        self.assertTrue(serialization.create_exception_cls("FooError", "m"))
+        self.assertTrue(serialization.create_exception_cls("FooError",
+                                                            "m",
+                                                            KeyError))
+
+
 class test_BaseBackend_interface(unittest.TestCase):
 
     def test_get_status(self):

celery/tests/test_utils.py

@@ -31,6 +31,12 @@ class test_chunks(unittest.TestCase):
 
 class test_utils(unittest.TestCase):
 
+    def test_maybe_iso8601_datetime(self):
+        from celery.utils.timeutils import maybe_iso8601
+        from datetime import datetime
+        now = datetime.now()
+        self.assertIs(maybe_iso8601(now), now)
+
     def test_get_full_cls_name(self):
         Class = type("Fox", (object, ), {"__module__": "quick.brown"})
         self.assertEqual(utils.get_full_cls_name(Class), "quick.brown.Fox")
@@ -88,6 +94,33 @@ class test_utils(unittest.TestCase):
         instance = object()
         self.assertIs(utils.get_cls_by_name(instance), instance)
 
+    def test_truncate_text(self):
+        self.assertEqual(utils.truncate_text("ABCDEFGHI", 3), "ABC...")
+        self.assertEqual(utils.truncate_text("ABCDEFGHI", 10), "ABCDEFGHI")
+
+    def test_abbr(self):
+        self.assertEqual(utils.abbr(None, 3), "???")
+        self.assertEqual(utils.abbr("ABCDEFGHI", 6), "ABC...")
+        self.assertEqual(utils.abbr("ABCDEFGHI", 20), "ABCDEFGHI")
+        self.assertEqual(utils.abbr("ABCDEFGHI", 6, None), "ABCDEF")
+
+    def test_abbrtask(self):
+        self.assertEqual(utils.abbrtask(None, 3), "???")
+        self.assertEqual(utils.abbrtask("feeds.tasks.refresh", 10),
+                                        "[.]refresh")
+        self.assertEqual(utils.abbrtask("feeds.tasks.refresh", 30),
+                                        "feeds.tasks.refresh")
+
+    def test_cached_property(self):
+
+        def fun(obj):
+            return fun.value
+
+        x =  utils.cached_property(fun)
+        self.assertIs(x.__get__(None), x)
+        self.assertIs(x.__set__(None, None), x)
+        self.assertIs(x.__delete__(None), x)
+
 
 class test_promise(unittest.TestCase):
 

celery/tests/test_worker_controllers.py

@@ -8,6 +8,7 @@ from celery.worker.state import revoked as revoked_tasks
 
 
 class MockTask(object):
+    hostname = "harness.com"
     task_id = 1234
     task_name = "mocktask"
     acked = False
@@ -52,6 +53,33 @@ class test_Mediator(unittest.TestCase):
 
         self.assertEqual(got["value"], "George Costanza")
 
+    def test_mediator_move_exception(self):
+        ready_queue = Queue()
+
+        def mycallback(value):
+            raise KeyError("foo")
+
+        m = Mediator(ready_queue, mycallback)
+        ready_queue.put(MockTask("Elaine M. Benes"))
+
+        m.move()
+
+    def test_run(self):
+        ready_queue = Queue()
+
+        condition = [None]
+
+        def mycallback(value):
+            condition[0].set()
+
+        m = Mediator(ready_queue, mycallback)
+        condition[0] = m._shutdown
+        ready_queue.put(MockTask("Elaine M. Benes"))
+
+        m.run()
+        self.assertTrue(m._shutdown.isSet())
+        self.assertTrue(m._stopped.isSet())
+
     def test_mediator_move_revoked(self):
         ready_queue = Queue()
         got = {}

celery/utils/serialization.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     cpickle = None
 
-if sys.version_info < (2, 6):
+if sys.version_info < (2, 6):  # pragma: no cover
     # cPickle is broken in Python <= 2.5.
     # It unsafely and incorrectly uses relative instead of absolute imports,
     # so e.g.:
@@ -29,14 +29,14 @@ else:
 # BaseException was introduced in Python 2.5.
 try:
     _error_bases = (BaseException, )
-except NameError:
+except NameError:  # pragma: no cover
     _error_bases = (SystemExit, KeyboardInterrupt)
 
 #: List of base classes we probably don't want to reduce to.
 unwanted_base_classes = (StandardError, Exception) + _error_bases + (object, )
 
 
-if sys.version_info < (2, 5):
+if sys.version_info < (2, 5):  # pragma: no cover
 
     # Prior to Python 2.5, Exception was an old-style class
     def subclass_exception(name, parent, unused):
@@ -85,7 +85,6 @@ def find_nearest_pickleable_exception(exc):
             pass
         else:
             return superexc
-    return
 
 
 def create_exception_cls(name, module, parent=None):

celery/utils/timeutils.py

@@ -20,7 +20,7 @@ TIME_UNITS = (("day", 60 * 60 * 24, lambda n: int(math.ceil(n))),
               ("second", 1, lambda n: "%.2f" % n))
 
 
-def timedelta_seconds(delta):
+def timedelta_seconds(delta):  # pragma: no cover
     """Convert :class:`datetime.timedelta` to seconds.
 
     Doesn't account for negative values.

setup.cfg

@@ -18,6 +18,8 @@ cover3-exclude = celery
                  celery.utils.mail
                  celery.utils.functional
                  celery.utils.dispatch*
+                 celery.utils.term
+                 celery.utils.timer2
                  celery.db.a805d4bd
                  celery.db.dfd042c7
                  celery.contrib*