def testDeferredList(self):
defr1 = deferred.Deferred()
defr2 = deferred.Deferred()
defr3 = deferred.Deferred()
dl = deferred.DeferredList([defr1, defr2, defr3])
result = []
def cb(resultList, result=result):
result.extend(resultList)
def catch(err):
return None
dl.addCallbacks(cb, cb)
defr1.callback("1")
defr2.addErrback(catch)
# "catch" is added to eat the GenericError that will be passed on by
# the DeferredList's callback on defr2. If left unhandled, the
# Failure object would cause a log.err() warning about "Unhandled
# error in Deferred". Twisted's pyunit watches for log.err calls and
# treats them as failures. So "catch" must eat the error to prevent
# it from flunking the test.
defr2.errback(GenericError("2"))
defr3.callback("3")
self.failUnlessEqual(
[
result[0],
#result[1][1] is now a Failure instead of an Exception
(result[1][0], str(result[1][1].value)),
result[2]
],
[(deferred.SUCCESS, "1"), (deferred.FAILURE, "2"),
(deferred.SUCCESS, "3")])
def sendImage(self, message, ID, to):
if (".jpg" in message.lower()):
imgType = "jpg"
if (".webp" in message.lower()):
imgType = "webp"
success = deferred.Deferred()
error = deferred.Deferred()
self.downloadMedia(message, success.run, error.run)
# Success
path = success.arg(0)
call(self.logger.info, "Success: Image downloaded to %s" % path)
pathWithExt = path.then(lambda p: p + "." + imgType)
call(os.rename, path, pathWithExt)
pathJpg = path.then(lambda p: p + ".jpg")
if imgType != "jpg":
im = call(Image.open, pathWithExt)
call(im.save, pathJpg)
call(os.remove, pathWithExt)
call(self.logger.info, "Sending image to %s" % to)
waId = deferred.Deferred()
call(super(Session, self).sendImage, to, pathJpg, onSuccess=waId.run)
call(self.setWaId, ID, waId)
waId.when(call, os.remove, pathJpg)
waId.when(self.logger.info, "Image sent")
# Error
error.when(self.logger.info, "Download Error. Sending message as is.")
waId = error.when(self.sendTextMessage, to, message)
call(self.setWaId, ID, waId)
def testCallbackErrors(self):
l = []
d = deferred.Deferred().addCallback(lambda _: 1 / 0).addErrback(
l.append)
d.callback(1)
self.assert_(isinstance(l[0].value, ZeroDivisionError))
l = []
d = deferred.Deferred().addCallback(
lambda _: Failure(ZeroDivisionError())).addErrback(l.append)
d.callback(1)
self.assert_(isinstance(l[0].value, ZeroDivisionError))
def requestVCard(self, buddy, ID=None):
if "/" in buddy:
room, nick = buddy.split("/")
group = self.session.groups[room]
buddynr = None
for othernumber, othernick in group.participants.iteritems():
if othernick == nick:
buddynr = othernumber
break
if buddynr is None:
return
else:
buddynr = buddy
if buddynr == self.user or buddynr == self.user.split('@')[0]:
buddynr = self.session.legacyName
# Get profile picture
self.logger.debug('Requesting profile picture of %s' % buddynr)
response = deferred.Deferred()
# Error probably means image doesn't exist
error = deferred.Deferred()
self.session.requestProfilePicture(buddynr, onSuccess=response.run,
onFailure=error.run)
response = response.arg(0)
pictureData = response.pictureData()
# Send VCard
if ID != None:
call(self.logger.debug, 'Sending VCard (%s) with image id %s: %s' %
(ID, response.pictureId(), pictureData.then(base64.b64encode)))
call(self.backend.handleVCard, self.user, ID, buddy, "", "",
pictureData)
# If error
error.when(self.logger.debug, 'Sending VCard (%s) without image' % ID)
error.when(self.backend.handleVCard, self.user, ID, buddy, "", "", "")
# Send image hash
if not buddynr == self.session.legacyName:
try:
obuddy = self[buddynr]
nick = obuddy.nick
groups = obuddy.groups
except KeyError:
nick = ""
groups = []
image_hash = pictureData.then(utils.sha1hash)
call(self.logger.debug, 'Image hash is %s' % image_hash)
call(self.update, buddynr, nick, groups, image_hash)
# No image
error.when(self.logger.debug, 'No image')
error.when(self.update, buddynr, nick, groups, '')
def testDeferredListFireOnOneErrorWithAlreadyFiredDeferreds(self):
# Create some deferreds, and errback one
d1 = deferred.Deferred()
d2 = deferred.Deferred()
d1.errback(GenericError('Bang'))
# *Then* build the DeferredList, with fireOnOneErrback=True
dl = deferred.DeferredList([d1, d2], fireOnOneErrback=True)
result = []
dl.addErrback(result.append)
self.failUnlessEqual(1, len(result))
d1.addErrback(lambda e: None) # Swallow error
def testReturnDeferred(self):
d = deferred.Deferred()
d2 = deferred.Deferred()
d2.pause()
d.addCallback(lambda r, d2=d2: d2)
d.addCallback(self._callback)
d.callback(1)
assert self.callback_results is None, "Should not have been called yet."
d2.callback(2)
assert self.callback_results is None, "Still should not have been called yet."
d2.unpause()
assert self.callback_results[0][
0] == 2, "Result should have been from second deferred:%s" % (
self.callback_results, )
def testSwitchDebugging(self):
# Make sure Deferreds can deal with debug state flipping
# around randomly. This is covering a particular fixed bug.
deferred.setDebugging(False)
d = deferred.Deferred()
d.addBoth(lambda ign: None)
deferred.setDebugging(True)
d.callback(None)
deferred.setDebugging(False)
d = deferred.Deferred()
d.callback(None)
deferred.setDebugging(True)
d.addBoth(lambda ign: None)
def testSemaphore(self):
N = 13
sem = deferred.DeferredSemaphore(N)
controlDeferred = deferred.Deferred()
def helper(self, arg):
self.arg = arg
return controlDeferred
results = []
uniqueObject = object()
resultDeferred = sem.run(helper, self=self, arg=uniqueObject)
resultDeferred.addCallback(results.append)
resultDeferred.addCallback(self._incr)
self.assertEquals(results, [])
self.assertEquals(self.arg, uniqueObject)
controlDeferred.callback(None)
self.assertEquals(results.pop(), None)
self.assertEquals(self.counter, 1)
self.counter = 0
for i in range(1, 1 + N):
sem.acquire().addCallback(self._incr)
self.assertEquals(self.counter, i)
sem.acquire().addCallback(self._incr)
self.assertEquals(self.counter, N)
sem.release()
self.assertEquals(self.counter, N + 1)
for i in range(1, 1 + N):
sem.release()
self.assertEquals(self.counter, N + 1)
def process(self, item):
if item[:4] == "MSG\x00":
print item[4:] + "\n"
elif item[:6] == "GFILE!":
name, content = item[6:].split('\0', 1)
with open("download{}{}".format(os.sep, name), "w") as f:
f.write(content)
elif item[:6] == "SFILE!":
name, user = item[6:].split('!', 1)
if os.path.isfile("download{}{}".format(os.sep, name)):
with open("download{}{}".format(os.sep, name), 'r') as f:
msg = "GFILE!{}\0{}".format(name, f.read())
self.outbox.append((user, msg))
else:
print "No file: download{}{}".format(os.sep, name)
#Zwraca wyslanemu brak pliku. Outbox powinien informowac o braku pliku.
#promises: local
#deferred: remote
elif item[:6] == "CPROM!": #createPromise
lang, executor, receiver, code = item[6:].split('\0', 3)
digest = str(hash(item))
self.environment["P" + digest] = promise.Promise(
executor, lang, code)
self.outbox.append(
(executor, "RDEFR!{}\0{}\0{}\0".format(lang, receiver, digest,
code)))
elif item[:6] == "RDEFR!": #receiveDeferred
lang, requester, digest, code = item[6:].split('\0', 3)
dfr = deferred.Deferred(self.outbox, digest, requester, lang, code)
self.environment["D" + digest] = dfr
elif item[:6] == "RPROM!": #receivePromise
id, content = item[6:].split('\0', 1)
self.environment["P" + id].fulfill(content)
def testDeferredListWithAlreadyFiredDeferreds(self):
# Create some deferreds, and err one, call the other
d1 = deferred.Deferred()
d2 = deferred.Deferred()
d1.errback(GenericError('Bang'))
d2.callback(2)
# *Then* build the DeferredList
dl = deferred.DeferredList([d1, d2])
result = []
dl.addCallback(result.append)
self.failUnlessEqual(1, len(result))
d1.addErrback(lambda e: None) # Swallow error
def requestVCard(self, buddy, ID=None):
if buddy == self.user or buddy == self.user.split('@')[0]:
buddy = self.session.legacyName
# Get profile picture
self.logger.debug('Requesting profile picture of %s', buddy)
response = deferred.Deferred()
self.session.requestProfilePicture(buddy, onSuccess=response.run)
response = response.arg(0)
pictureData = response.pictureData()
# Send VCard
if ID != None:
call(self.logger.debug, 'Sending VCard (%s) with image id %s: %s',
ID, response.pictureId(), pictureData.then(base64.b64encode))
call(self.backend.handleVCard, self.user, ID, buddy, "", "",
pictureData)
# Send image hash
if not buddy == self.session.legacyName:
try:
obuddy = self[buddy]
nick = obuddy.nick
groups = obuddy.groups
except KeyError:
nick = ""
groups = []
image_hash = pictureData.then(utils.sha1hash)
call(self.logger.debug, 'Image hash is %s', image_hash)
call(self.update, buddy, nick, groups, image_hash)
def testTwoCallbacks(self):
d = deferred.Deferred()
d.addCallback(self._callback)
d.addCallback(self._callback2)
d.callback("hello")
self.failUnlessEqual(self.errback_results, None)
self.failUnlessEqual(self.callback_results, (('hello', ), {}))
self.failUnlessEqual(self.callback2_results, (('hello', ), {}))
def testCallbackWithKwArgs(self):
d = deferred.Deferred()
d.addCallback(self._callback, world="world")
d.callback("hello")
self.failUnlessEqual(self.errback_results, None)
self.failUnlessEqual(self.callback_results, (('hello', ), {
'world': 'world'
}))
def test_errorLog(self):
"""
Verify that when a Deferred with no references to it is fired, and its
final result (the one not handled by any callback) is an exception,
that exception will be logged immediately.
"""
deferred.Deferred().addCallback(lambda x: 1 / 0).callback(1)
gc.collect()
self._check()
def test_maybeDeferredAsync(self):
"""
L{deferred.maybeDeferred} should let L{deferred.Deferred} instance pass by
so that original result is the same.
"""
d = deferred.Deferred()
d2 = deferred.maybeDeferred(lambda: d)
d.callback('Success')
return d2.addCallback(self.assertEquals, 'Success')
def test_maybeDeferredAsyncError(self):
"""
L{deferred.maybeDeferred} should let L{deferred.Deferred} instance pass by
so that L{Failure} returned by the original instance is the
same.
"""
d = deferred.Deferred()
d2 = deferred.maybeDeferred(lambda: d)
d.errback(Failure(RuntimeError()))
return self.assertFailure(d2, RuntimeError)
def testAlreadyCalledDebug_EE(self):
d = deferred.Deferred()
d.addCallbacks(self._callback, self._errback)
self._err_1(d)
try:
self._err_2(d)
except deferred.AlreadyCalledError as e:
self._check(e, "testAlreadyCalledDebug_EE", "_err_1", "_err_2")
else:
self.fail("second errback failed to raise AlreadyCalledError")
def testNoDebugging(self):
deferred.setDebugging(False)
d = deferred.Deferred()
d.addCallbacks(self._callback, self._errback)
self._call_1(d)
try:
self._call_2(d)
except deferred.AlreadyCalledError as e:
self.failIf(e.args)
else:
self.fail("second callback failed to raise AlreadyCalledError")
def testDeferredListFireOnOneError(self):
defr1 = deferred.Deferred()
defr2 = deferred.Deferred()
defr3 = deferred.Deferred()
dl = deferred.DeferredList([defr1, defr2, defr3], fireOnOneErrback=1)
result = []
dl.addErrback(result.append)
# consume errors after they pass through the DeferredList (to avoid
# 'Unhandled error in Deferred'.
def catch(err):
return None
defr2.addErrback(catch)
# fire one Deferred's callback, no result yet
defr1.callback("1")
self.failUnlessEqual(result, [])
# fire one Deferred's errback -- now we have a result
defr2.errback(GenericError("from def2"))
self.failUnlessEqual(len(result), 1)
# extract the result from the list
failure = result[0]
# the type of the failure is a FirstError
self.failUnless(
issubclass(failure.type, deferred.FirstError),
'issubclass(failure.type, deferred.FirstError) failed: '
'failure.type is %r' % (failure.type, ))
firstError = failure.value
# check that the GenericError("2") from the deferred at index 1
# (defr2) is intact inside failure.value
self.failUnlessEqual(firstError.subFailure.type, GenericError)
self.failUnlessEqual(firstError.subFailure.value.args, ("from def2", ))
self.failUnlessEqual(firstError.index, 1)
def testDeferredListConsumeErrors(self):
d1 = deferred.Deferred()
dl = deferred.DeferredList([d1], consumeErrors=True)
errorTrap = []
d1.addErrback(errorTrap.append)
result = []
dl.addCallback(result.append)
d1.errback(GenericError('Bang'))
self.failUnlessEqual([], errorTrap)
self.failUnlessEqual(1, len(result))
self.failUnlessEqual('Bang', result[0][0][1].value.args[0])
def testLock(self):
lock = deferred.DeferredLock()
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 1)
lock.release()
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
lock.release()
self.failIf(lock.locked)
self.assertEquals(self.counter, 2)
self.assertRaises(TypeError, lock.run)
firstUnique = object()
secondUnique = object()
controlDeferred = deferred.Deferred()
def helper(self, b):
self.b = b
return controlDeferred
resultDeferred = lock.run(helper, self=self, b=firstUnique)
self.failUnless(lock.locked)
self.assertEquals(self.b, firstUnique)
resultDeferred.addCallback(lambda x: setattr(self, 'result', x))
lock.acquire().addCallback(self._incr)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 2)
controlDeferred.callback(secondUnique)
self.assertEquals(self.result, secondUnique)
self.failUnless(lock.locked)
self.assertEquals(self.counter, 3)
lock.release()
self.failIf(lock.locked)
def test_nonReentrantCallbacks(self):
"""
A callback added to a L{Deferred} by a callback on that L{Deferred}
should not be executed until the running callback returns.
"""
d = deferred.Deferred()
called = []
def callback2(result):
called.append(2)
def callback1(result):
called.append(1)
d.addCallback(callback2)
self.assertEquals(called, [1])
d.addCallback(callback1)
d.callback(None)
self.assertEqual(called, [1, 2])
def test_reentrantRunCallbacks(self):
"""
A callback added to a L{Deferred} by a callback on that L{Deferred}
should be added to the end of the callback chain.
"""
d = deferred.Deferred()
called = []
def callback3(result):
called.append(3)
def callback2(result):
called.append(2)
def callback1(result):
called.append(1)
d.addCallback(callback3)
d.addCallback(callback1)
d.addCallback(callback2)
d.callback(None)
self.assertEqual(called, [1, 2, 3])
def test_reentrantRunCallbacksWithFailure(self):
"""
After an exception is raised by a callback which was added to a
L{Deferred} by a callback on that L{Deferred}, the L{Deferred} should
call the first errback with a L{Failure} wrapping that exception.
"""
exceptionMessage = "callback raised exception"
d = deferred.Deferred()
def callback2(result):
raise Exception(exceptionMessage)
def callback1(result):
d.addCallback(callback2)
d.addCallback(callback1)
d.callback(None)
self.assertFailure(d, Exception)
def cbFailed(exception):
self.assertEqual(exception.args, (exceptionMessage, ))
d.addCallback(cbFailed)
return d
def testUnpauseBeforeCallback(self):
d = deferred.Deferred()
d.pause()
d.addCallback(self._callback)
d.unpause()
return d.addCallback(a).addErrback(b)
else:
return d.addCallback(b).addErrback(a)
def doList(d, op, n):
for i in range(n):
d = d.addCallback(op, i)
return d
def errorout(derp):
raise RuntimeException('hi')
d = deferred.Deferred()
def feep(d):
d = doList(d, lambda thing, i: i, 5)
d = doAorB(d, lambda thing: deferred.succeed('whee'), errorout)
d = doList(d, lambda thing, i: i, 5)
feep(d)
feep(d)
with graph('demo.dot') as g:
graphtree(d, g)
subprocess.call(["neato", "-T", "png", "-o", "demo.png", "demo.dot"])
webbrowser.open('demo.png')
def _subErrorLogWithInnerFrameCycle():
d = deferred.Deferred()
d.addCallback(lambda x, d=d: 1 / 0)
d._d = d
d.callback(1)
def testAlreadyCalled_EC(self):
d = deferred.Deferred()
d.addCallbacks(self._callback, self._errback)
self._err_1(d)
self.failUnlessRaises(deferred.AlreadyCalledError, self._call_2, d)
def _subErrorLogWithInnerFrameRef():
d = deferred.Deferred()
d.addCallback(lambda x: 1 / 0)
d.callback(1)
