def test_callbackResultChangesValue(self):
"""
The result of a callback affects the result returned from
C{synchronize}.
"""
sd = SynchronousDeferred("foo")
sd.addCallback(lambda r: 42)
self.assertEquals(sd.synchronize(), 42)
def test_addBothSuccess(self):
"""
addBoth adds a callback to be run on success.
"""
l = []
sd = SynchronousDeferred("foo")
self.assertEquals(sd.addBoth(l.append), sd)
self.assertEquals(l, ["foo"])
def test_addCallback(self):
"""
C{addCallback} calls the callback passed immediately and returns itself.
"""
l = []
sd = SynchronousDeferred(None)
self.assertEquals(sd.addCallback(l.append), sd)
self.assertEquals(l, [None])
def test_errbackResultChangesValue(self):
"""
The result of an errback affects the result returned from
C{synchronize}.
"""
sd = SynchronousDeferred(SynchronousFailure(RuntimeError()))
sd.addErrback(lambda r: 42)
self.assertEquals(sd.synchronize(), 42)
def test_addCallbacksOnlyCallsOne(self):
"""
If the callback raises an exception, the errback won't be called.
"""
sd = SynchronousDeferred("foo")
failures = []
sd.addCallbacks(lambda r: 1/0, failures.append)
self.assertEquals(failures, [])
def test_addErrback(self):
"""
C{addErrback} immediately calls the errback when the current result is
a failure.
"""
failure = SynchronousFailure(RuntimeError())
sd = SynchronousDeferred(failure)
l = []
self.assertEquals(sd.addErrback(l.append), sd)
self.assertEquals(l, [failure])
def test_callbackResultChangesNextCallbackArgument(self):
"""
The result of a callback affects the argument passed to the next
callback.
"""
sd = SynchronousDeferred("foo")
sd.addCallback(lambda r: 42)
l = []
sd.addCallback(l.append)
self.assertEquals(l, [42])
def test_addBothSuccessExtraArgs(self):
"""
addBoth takes extra arguments, and they get passed in the success case.
"""
sd = SynchronousDeferred("foo")
l = []
def cb(r, extra, more=None):
l.append((r, extra, more))
sd.addBoth(cb, 1, more="heyo")
self.assertEquals(l, [("foo", 1, "heyo")])
def test_errbackResultChangesNextCallbackArgument(self):
"""
The result of an errback affects the argument passed to the next
callback.
"""
sd = SynchronousDeferred(SynchronousFailure(RuntimeError()))
sd.addErrback(lambda r: 42)
l = []
sd.addCallback(l.append)
self.assertEquals(l, [42])
def test_addBothFailureExctraArgs(self):
"""
addBoth adds a callback to be run on success.
"""
failure = SynchronousFailure(RuntimeError())
sd = SynchronousDeferred(failure)
l = []
def eb(r, extra, more=None):
l.append((r, extra, more))
sd.addBoth(eb, 1, more="heyo")
self.assertEquals(l, [(failure, 1, "heyo")])
def test_addCallbacksExtraArgumentsOnCallback(self):
"""
addCallbacks takes some extra arguments to pass to its callback.
"""
sd = SynchronousDeferred("foo")
l = []
def cb(r, extra, more=None):
l.append((r, extra, more))
sd.addCallbacks(cb, lambda ignored: None,
(1,), {},
{"more": "heyo"}, {})
self.assertEquals(l, [("foo", 1, "heyo")])
def test_addCallbacksCallsErrback(self):
"""
C{addCallbacks} calls the errback passed to it, and not the callback,
if the current result is a failure.
"""
failure = SynchronousFailure(RuntimeError())
sd = SynchronousDeferred(failure)
successes = []
failures = []
sd.addCallbacks(successes.append, failures.append)
self.assertEquals(successes, [])
self.assertEquals(failures, [failure])
def test_addCallbacksCallsCallback(self):
"""
C{addCallbacks} calls the callback passed to it, and not the errback,
if the current result is a success.
"""
sd = SynchronousDeferred("foo")
successes = []
failures = []
self.assertEquals(sd.addCallbacks(successes.append, failures.append),
sd)
self.assertEquals(successes, ["foo"])
self.assertEquals(failures, [])
def test_errorRaisingErrback(self):
"""
If an errback raises an exception, errbacks will be called.
"""
sd = SynchronousDeferred(SynchronousFailure(RuntimeError()))
def errback(ignored):
1/0
sd.addErrback(errback)
l = []
sd.addErrback(l.append)
self.assertEquals(len(l), 1)
self.assertTrue(l[0].check(ZeroDivisionError))
def test_errorRaisingCallback(self):
"""
If a callback raises an exception, errbacks will be called.
"""
sd = SynchronousDeferred("foo")
def callback(ignored):
1/0
sd.addCallback(callback)
l = []
sd.addErrback(l.append)
self.assertEquals(len(l), 1)
self.assertTrue(l[0].check(ZeroDivisionError))
def test_addCallbacksExtraArgumentsOnErrback(self):
"""
addCallbacks takes some extra arguments to pass to its errback.
"""
failure = SynchronousFailure(RuntimeError())
sd = SynchronousDeferred(failure)
l = []
def eb(r, extra, more=None):
l.append((r, extra, more))
sd.addCallbacks(lambda ignored: None, eb,
(), (1,),
{}, {"more": "heyo"})
self.assertEquals(l, [(failure, 1, "heyo")])