Ticket #1875: deferlater.diff

twisted/test/test_task.py

@@ -163 +163 @@
         L = []
         lc = TestableLoopingCall(clock, L.append, None)
         d = lc.start(0.1, now=False)
-        
+
         theResult = []
         def saveResult(result):
             theResult.append(result)
@@ -298 +298 @@
         clock.pump(timings)
         self.failIf(clock.calls)
         return d
+
+
+class _TestableDeferredScheduler(task._DeferredScheduler):
+    """
+    I am a L{task._DeferredScheduler} using a dummy L{task.Clock}, for testing
+    purposes.
+    """
+    def __init__(self):
+        self.clock = task.Clock()
+
+    def _callLater(self, *a, **kw):
+        return self.clock.callLater(*a, **kw)
+
+
+
+class DeferLaterTestCase(unittest.TestCase):
+    def testCallback(self):
+        """
+        Test that the callback is actually invoked, and with the correct
+        arguments.
+        """
+        deferLater = _TestableDeferredScheduler()
+
+        flag = object()
+        def _cb(foo, bar):
+            self.assertEquals(foo, 'foo')
+            self.assertEquals(bar, 'bar')
+            return flag
+
+        d = deferLater(1, _cb, 'foo', bar='bar')
+        d.addCallback(self.assertEquals, flag)
+        deferLater.clock.pump([2])
+        return d
+
+    def testErrback(self):
+        """
+        Test that an exception raised in the callback is translated to a
+        Failure.
+        """
+        deferLater = _TestableDeferredScheduler()
+
+        def _cb():
+            raise TestException()
+
+        d = deferLater(1, _cb)
+        deferLater.clock.pump([2])
+        return self.assertFailure(d, TestException)

twisted/internet/task.py

@@ -357 +357 @@
             self.advance(amount)
 
 
+class _DeferredScheduler(object):
+    """
+    I wrap a Deferred around L{IReactorTime.callLater}. Invoke me as
+    L{twisted.internet.task.deferLater}.
+    """
 
+    def _callLater(self, *a, **kw):
+        from twisted.internet import reactor
+        return reactor.callLater(*a, **kw)
+
+    def __call__(self, delay, callable, *args, **kw):
+        """
+        Schedule a function to be run after a certain period of time has
+        passed.
+
+        @type delay: C{float}
+        @param delay: the number of seconds to wait.
+
+        @param callable: the callable object to call later.
+
+        @param args: the arguments to call it with.
+
+        @param kw: the keyword arguments to call it with.
+
+        @return: A deferred that fires when the specified time has elapsed, and
+                 has had the provided callback added to its chain.
+        """
+        d = defer.Deferred()
+        d.addCallback(lambda dummy: callable(*args, **kw))
+        self._callLater(delay, lambda: d.callback(None))
+        return d
+
+
+
+deferLater = _DeferredScheduler()
+
+
+
 __all__ = [
     'LoopingCall',
 
     'Clock',
 
     'SchedulerStopped', 'Cooperator', 'coiterate',
+
+    'deferLater',
     ]