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 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 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 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"""
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()
"""
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
