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)