def test_connectWaitsForConnection(self): """ Calling L{gConnectTCP} blocks until a connection is made and returns a L{GreenletTransport}. """ transports = [] def connect(): transports.append( gConnectTCP("whatever", 9090, reactor=fakeReactor)) class FakeReactor(object): def __init__(self): self.connections = [] def connectTCP(self, host, port, factory): self.connections.append((host, port, factory)) fakeReactor = FakeReactor() greenlet(connect).switch() self.assertEquals(transports, []) self.assertEquals(len(fakeReactor.connections), 1) self.assertEquals(fakeReactor.connections[0][0], "whatever") self.assertEquals(fakeReactor.connections[0][1], 9090) proto = fakeReactor.connections[0][2].buildProtocol(None) proto.makeConnection(FakeTransport()) # This is gonna switch back! self.assertEquals(transports, [proto.gtransport])
def inner(*args, **kwargs): d = Deferred() def intermediateGreenletFunction(): try: d.callback(gfunction(*args, **kwargs)) except: d.errback() greenlet(intermediateGreenletFunction).switch() return d
def test_alreadyHasResult(self): """ Passing an already-fired Deferred to L{blockOn} will immediately return that Deferred's result. """ events = [] deferred = succeed("hey") def greeny(): events.append("waiting") events.append(blockOn(deferred)) greenlet(greeny).switch() self.assertEquals(events, ["waiting", "hey"])
def test_simpleBlock(self): """ A greenlet which calls L{blockOn} will be resumed when the Deferred passed has fired. """ events = [] deferred = Deferred() def greeny(): events.append("waiting") events.append(blockOn(deferred)) greenlet(greeny).switch() self.assertEquals(events, ["waiting"]) deferred.callback("hey") self.assertEquals(events, ["waiting", "hey"])
def connectionMade(self): """ Initiate the connection by switching to the greenlet. """ self._buffer = "" self.greenlet = greenlet(self._runAndDisconnect) self.gtransport = GreenletTransport(self.transport, self) self.transport.registerProducer(self, True) self.greenlet.switch(self.gtransport)
def test_wait(self): """ L{wait} returns when an amount of time has been passed, allowing the reactor to run in the meantime. """ clock = Clock() events = [] def doit(): events.append("waiting") wait(5, clock) events.append("done") g = greenlet(doit) g.switch() self.assertEquals(events, ["waiting"]) clock.advance(5) self.assertEquals(events, ["waiting", "done"])
class BlockOnTests(TestCase): """ Tests for L{blockOn}. """ def test_simpleBlock(self): """ A greenlet which calls L{blockOn} will be resumed when the Deferred passed has fired. """ events = [] deferred = Deferred() def greeny(): events.append("waiting") events.append(blockOn(deferred)) greenlet(greeny).switch() self.assertEquals(events, ["waiting"]) deferred.callback("hey") self.assertEquals(events, ["waiting", "hey"]) def test_errback(self): """ L{blockOn} will raise an exception when the Deferred fires with an error. """ events = [] deferred = Deferred() def catcher(): events.append("waiting") try: blockOn(deferred) except Exception, e: events.append(e) greenlet(catcher).switch() self.assertEquals(events, ["waiting"]) e = ZeroDivisionError("Yeah whatever") deferred.errback(e) self.assertEquals(events, ["waiting", e])
def startServers(): gListenTCP(1025, discard) gListenTCP(1026, qotd) gListenTCP(1027, echo) gListenTCP(1028, chargen) gListenTCP(1029, fetchGoogle) from twisted.internet.protocol import Factory ampf = Factory() ampf.protocol = GoogleGetter reactor.listenTCP(1030, ampf) chat = Chat() gListenTCP(1031, chat.handleConnection) if __name__ == '__main__': from twisted.internet import reactor from twisted.python.log import startLogging import sys startLogging(sys.stdout) startServers() greenlet(echoclient).switch() # Uncomment to test google thingy. #greenlet(googleAMPClient).switch() reactor.run()
def test_alreadyHasFailure(self): """ Passing an already-failed Deferred to L{blockOn} will immediately raise an exception. """ events = [] e = ZeroDivisionError("whatever") deferred = fail(e) def greeny(): events.append("waiting") try: blockOn(deferred) except Exception, e: events.append(e) greenlet(greeny).switch() self.assertEquals(events, ["waiting", e]) class DeferredGreenletTests(TestCase): """ Tests for L{deferredGreenlet}. """ def test_metadata(self): """ The metadata of a L{deferredGreenlet}-wrapped function is the same as the original function. """ def whatACoolName(): """foo"""
""" Passing an already-failed Deferred to L{blockOn} will immediately raise an exception. """ events = [] e = ZeroDivisionError("whatever") deferred = fail(e) def greeny(): events.append("waiting") try: blockOn(deferred) except Exception, e: events.append(e) greenlet(greeny).switch() self.assertEquals(events, ["waiting", e]) class DeferredGreenletTests(TestCase): """ Tests for L{deferredGreenlet}. """ def test_metadata(self): """ The metadata of a L{deferredGreenlet}-wrapped function is the same as the original function. """ def whatACoolName(): """foo""" pass