utils.timer2 and utils.threads tests

celery/tests/utilities/test_threads.py

@@ -0,0 +1,82 @@
+from __future__ import absolute_import
+
+from mock import Mock, patch
+
+from celery.utils.threads import (
+    _LocalStack,
+    _FastLocalStack,
+    LocalManager,
+    Local,
+    bgThread,
+)
+
+from celery.tests.utils import Case, override_stdouts
+
+
+class test_bgThread(Case):
+
+    def test_crash(self):
+
+        class T(bgThread):
+
+            def body(self):
+                raise KeyError()
+
+        with patch('os._exit') as _exit:
+            with override_stdouts():
+                _exit.side_effect = ValueError()
+                t = T()
+                with self.assertRaises(ValueError):
+                    t.run()
+                _exit.assert_called_with(1)
+
+
+class test_Local(Case):
+
+    def test_iter(self):
+        x = Local()
+        x.foo = 'bar'
+        ident = x.__ident_func__()
+        self.assertIn((ident, {'foo': 'bar'}), list(iter(x)))
+
+        delattr(x, 'foo')
+        self.assertNotIn((ident, {'foo': 'bar'}), list(iter(x)))
+        with self.assertRaises(AttributeError):
+            delattr(x, 'foo')
+
+        self.assertIsNotNone(x(lambda: 'foo'))
+
+
+class test_LocalStack(Case):
+
+    def test_stack(self):
+        x = _LocalStack()
+        self.assertIsNone(x.pop())
+        x.__release_local__()
+        ident = x.__ident_func__
+        x.__ident_func__ = ident
+
+        with self.assertRaises(RuntimeError):
+            x()[0]
+
+        x.push(['foo'])
+        self.assertEqual(x()[0], 'foo')
+        x.pop()
+        with self.assertRaises(RuntimeError):
+            x()[0]
+
+
+class test_FastLocalStack(Case):
+
+    def test_stack(self):
+        x = _FastLocalStack()
+        x.push(['foo'])
+        x.push(['bar'])
+        self.assertEqual(x.top, ['bar'])
+        self.assertEqual(len(x), 2)
+        x.pop()
+        self.assertEqual(x.top, ['foo'])
+        x.pop()
+        self.assertIsNone(x.top)
+
+

celery/tests/utilities/test_timer2.py

@@ -29,6 +29,10 @@ class test_Entry(Case):
         tref.cancel()
         self.assertTrue(tref.cancelled)
 
+    def test_repr(self):
+        tref = tiemr2.Entry(lambda x: x (1, ), {})
+        self.assertTrue(repr(tref))
+
 
 class test_Schedule(Case):
 
@@ -40,6 +44,9 @@ class test_Schedule(Case):
         x.cancel(tref)
         tref.cancel.assert_called_with()
 
+        self.assertIs(x.schedule, x)
+
+
     def test_handle_error(self):
         from datetime import datetime
         to_timestamp = timer2.to_timestamp

celery/utils/threads.py

@@ -316,7 +316,7 @@ class _FastLocalStack(threading.local):
     def __len__(self):
         return len(self.stack)
 
-if USE_FAST_LOCALS:
+if USE_FAST_LOCALS:  # pragma: no cover
     LocalStack = _FastLocalStack
 else:
     # - See #706

celery/utils/timer2.py

@@ -40,7 +40,7 @@ logger = get_logger('timer2')
 
 
 class Entry(object):
-    if not IS_PYPY:
+    if not IS_PYPY:  # pragma: no cover
         __slots__ = (
             'fun', 'args', 'kwargs', 'tref', 'cancelled',
             '_last_run', '__weakref__',
@@ -60,7 +60,7 @@ class Entry(object):
     def cancel(self):
         try:
             self.tref.cancelled = True
-        except ReferenceError:
+        except ReferenceError:  # pragma: no cover
             pass
 
     def __repr__(self):