def test_stuff(self):
p = FilePath(self.mktemp().decode("ascii"))
p.makedirs()
stripe_secret = p.child(b"stripe-key.secret")
stripe_secret.setContent(b"foo")
stripe_publishable = p.child(b"stripe-key.publishable")
stripe_publishable.setContent(b"bar")
options = SiteOptions(MemoryReactor())
options.parseOptions([
b"--stripe-secret-api-key-path",
stripe_secret.path,
b"--stripe-publishable-api-key-path",
stripe_publishable.path,
b"--stripe-plan-id",
b"foo-bar",
b"--site-logs-path",
b"httpd.log",
b"--secure-port",
b"tcp:0",
b"--subscription-manager",
b"http://127.0.0.1:8888/",
b"--cross-domain",
b"http://127.0.0.1:5000/",
b"--wormhole-result-path",
self.mktemp(),
])
site = site_for_options(MemoryReactor(), options)
# XXX Very weak assertion...
self.assertThat(site, IsInstance(Site))
def test_missing_ca_certificate(self):
"""
If no CA certificate is found in the service account directory,
``authenticate_with_serviceaccount`` raises ``ValueError``.
"""
t = FilePath(self.useFixture(TempDir()).join(b""))
serviceaccount = t.child(b"serviceaccount")
serviceaccount.makedirs()
serviceaccount.child(b"ca.crt").setContent(b"not a cert pem")
serviceaccount.child(b"token").setContent(b"token")
self.patch(
os,
"environ",
{
b"KUBERNETES_SERVICE_HOST": b"example.invalid.",
b"KUBERNETES_SERVICE_PORT": b"443",
},
)
self.assertThat(
lambda: authenticate_with_serviceaccount(
MemoryReactor(),
path=serviceaccount.path,
),
raises(ValueError("No certificate authority certificate found.")),
)
def test_bad_ca_certificate(self):
"""
If no CA certificate is found in the service account directory,
``authenticate_with_serviceaccount`` raises ``ValueError``.
"""
t = FilePath(self.useFixture(TempDir()).join(b""))
serviceaccount = t.child(b"serviceaccount")
serviceaccount.makedirs()
serviceaccount.child(b"ca.crt").setContent(
b"-----BEGIN CERTIFICATE-----\n"
b"not a cert pem\n"
b"-----END CERTIFICATE-----\n")
serviceaccount.child(b"token").setContent(b"token")
self.patch(
os,
"environ",
{
b"KUBERNETES_SERVICE_HOST": b"example.invalid.",
b"KUBERNETES_SERVICE_PORT": b"443",
},
)
self.assertThat(
lambda: authenticate_with_serviceaccount(
MemoryReactor(),
path=serviceaccount.path,
),
raises(
ValueError(
"Invalid certificate authority certificate found.",
"[('PEM routines', 'PEM_read_bio', 'bad base64 decode')]",
)),
)
def test_returns_service(self):
"""
``create_api_service`` returns an object providing ``IService``.
"""
reactor = MemoryReactor()
endpoint = TCP4ServerEndpoint(reactor, 6789)
verifyObject(IService, create_api_service(None, None, endpoint))
def _testHook(self, methodName, callerName=None):
"""
Verify that the named hook is run with the expected arguments as
specified by the arguments used to create the L{Runner}, when the
specified caller is invoked.
@param methodName: The name of the hook to verify.
@type methodName: L{str}
@param callerName: The name of the method that is expected to cause the
hook to be called.
If C{None}, use the L{Runner} method with the same name as the
hook.
@type callerName: L{str}
"""
if callerName is None:
callerName = methodName
arguments = dict(a=object(), b=object(), c=object())
argumentsSeen = []
def hook(**arguments):
argumentsSeen.append(arguments)
runnerArguments = {
methodName: hook,
"{}Arguments".format(methodName): arguments.copy(),
}
runner = Runner(reactor=MemoryReactor(), **runnerArguments)
hookCaller = getattr(runner, callerName)
hookCaller()
self.assertEqual(len(argumentsSeen), 1)
self.assertEqual(argumentsSeen[0], arguments)
def build_control_amp_service(test_case, reactor=None):
"""
Create a new ``ControlAMPService``.
:param TestCase test_case: The test this service is for.
:return ControlAMPService: Not started.
"""
if reactor is None:
reactor = Clock()
cluster_state = ClusterStateService(reactor)
cluster_state.startService()
test_case.addCleanup(cluster_state.stopService)
persistence_service = ConfigurationPersistenceService(
reactor, test_case.make_temporary_directory())
persistence_service.startService()
test_case.addCleanup(persistence_service.stopService)
return ControlAMPService(
reactor,
cluster_state,
persistence_service,
TCP4ServerEndpoint(MemoryReactor(), 1234),
# Easiest TLS context factory to create:
ClientContextFactory(),
)
def test_endpointConnectSuccess(self):
"""
A client endpoint can connect and returns a deferred who gets called
back with a protocol instance.
"""
proto = object()
mreactor = MemoryReactor()
clientFactory = object()
ep, expectedArgs, ignoredDest = self.createClientEndpoint(
mreactor, clientFactory)
d = ep.connect(clientFactory)
receivedProtos = []
def checkProto(p):
receivedProtos.append(p)
d.addCallback(checkProto)
factory = self.retrieveConnectedFactory(mreactor)
factory._onConnection.callback(proto)
self.assertEquals(receivedProtos, [proto])
expectedClients = self.expectedClients(mreactor)
self.assertEquals(len(expectedClients), 1)
self.assertConnectArgs(expectedClients[0], expectedArgs)
def test_endpointConnectingCancelled(self):
"""
Calling L{Deferred.cancel} on the L{Deferred} returned from
L{IStreamClientEndpoint.connect} is errbacked with an expected
L{ConnectingCancelledError} exception.
"""
mreactor = MemoryReactor()
clientFactory = object()
ep, ignoredArgs, address = self.createClientEndpoint(
mreactor, clientFactory)
d = ep.connect(clientFactory)
receivedFailures = []
def checkFailure(f):
receivedFailures.append(f)
d.addErrback(checkFailure)
d.cancel()
# When canceled, the connector will immediately notify its factory that
# the connection attempt has failed due to a UserError.
attemptFactory = self.retrieveConnectedFactory(mreactor)
attemptFactory.clientConnectionFailed(None, Failure(error.UserError()))
# This should be a feature of MemoryReactor: <http://tm.tl/5630>.
self.assertEqual(len(receivedFailures), 1)
failure = receivedFailures[0]
self.assertIsInstance(failure.value, error.ConnectingCancelledError)
self.assertEqual(failure.value.address, address)
def test_connectTCP(self):
"""
Called on the object returned by L{loggedReactor}, C{connectTCP} calls
the wrapped reactor's C{connectTCP} method with the original factory
wrapped in a L{_TrafficLoggingFactory}.
"""
class RecordDataProtocol(Protocol):
def dataReceived(self, data):
self.data = data
proto = RecordDataProtocol()
factory = ClientFactory()
factory.protocol = lambda: proto
reactor = MemoryReactor()
logged = loggedReactor(reactor)
logged.connectTCP('192.168.1.2', 1234, factory, 21, '127.0.0.2')
[(host, port, factory, timeout, bindAddress)] = reactor.tcpClients
self.assertEqual('192.168.1.2', host)
self.assertEqual(1234, port)
self.assertIsInstance(factory, _TrafficLoggingFactory)
self.assertEqual(21, timeout)
self.assertEqual('127.0.0.2', bindAddress)
# Verify that the factory and protocol specified are really being used
protocol = factory.buildProtocol(None)
protocol.makeConnection(None)
protocol.dataReceived("foo")
self.assertEqual(proto.data, "foo")
def test_connect(self):
"""Attempts to connect. The client already has credentials in the
appropriate place, and the client is not connected already.
Asserts that stanczyk attempts to connect to the appropriate
place.
"""
reactor = MemoryReactor()
fakeCtxFactory = object()
self.patch(certificate, "getContextFactory",
lambda _path: fakeCtxFactory)
self.assertNotIn("remote", self.namespace)
result = connect(namespace=self.namespace, _reactor=reactor)
self.assertIdentical(result, None)
host, port, factory, _ctxFactory, _, _ = reactor.sslClients[0]
self.assertEqual(host, "localhost")
self.assertEqual(port, 4430)
factory._onConnection.callback(None)
self.assertIn("remote", self.namespace)
line = self.manhole.line
self.assertEqual(line, "Connected to the exercise server!")
def onePrefix(
self,
description: str,
expectedClass: Union[
Type[TCP4ServerEndpoint],
Type[TCP6ServerEndpoint],
Type[UNIXServerEndpoint],
],
) -> _WrapperServerEndpoint:
"""
Test the C{haproxy} enpdoint prefix against one sub-endpoint type.
@param description: A string endpoint description beginning with
C{haproxy}.
@type description: native L{str}
@param expectedClass: the expected sub-endpoint class given the
description.
@type expectedClass: L{type}
@return: the parsed endpoint
@rtype: L{IStreamServerEndpoint}
@raise twisted.trial.unittest.Failtest: if the parsed endpoint doesn't
match expectations.
"""
reactor = MemoryReactor()
endpoint = serverFromString(reactor, description)
self.assertIsInstance(endpoint, _WrapperServerEndpoint)
assert isinstance(endpoint, _WrapperServerEndpoint)
self.assertIsInstance(endpoint._wrappedEndpoint, expectedClass)
self.assertIs(endpoint._wrapperFactory, HAProxyWrappingFactory)
return endpoint
def test_getLogFiles(self):
"""
The reactor returned by L{loggedReactor} has a C{getLogFiles} method
which returns a L{logstate} instance containing the active and
completed log files tracked by the logging wrapper.
"""
wrapped = ClientFactory()
wrapped.protocol = Discard
reactor = MemoryReactor()
logged = loggedReactor(reactor)
logged.connectTCP('127.0.0.1', 1234, wrapped)
factory = reactor.tcpClients[0][2]
finished = factory.buildProtocol(None)
finished.makeConnection(StringTransport())
finished.dataReceived('finished')
finished.connectionLost(None)
active = factory.buildProtocol(None)
active.makeConnection(StringTransport())
active.dataReceived('active')
logs = logged.getLogFiles()
self.assertEqual(1, len(logs.finished))
self.assertIn('finished', logs.finished[0].getvalue())
self.assertEqual(1, len(logs.active))
self.assertIn('active', logs.active[0].getvalue())
def installReactor(name: str) -> IReactorCore:
if name != "fusion":
raise NoSuchReactor()
reactor = MemoryReactor()
self.installedReactors[name] = reactor
return reactor
def test_endpointConnectingCancelled(self):
"""
Calling L{Deferred.cancel} on the L{Deferred} returned from
L{IStreamClientEndpoint.connect} is errbacked with an expected
L{ConnectingCancelledError} exception.
"""
mreactor = MemoryReactor()
clientFactory = object()
ep, ignoredArgs, address = self.createClientEndpoint(
mreactor, clientFactory)
d = ep.connect(clientFactory)
receivedFailures = []
def checkFailure(f):
receivedFailures.append(f)
d.addErrback(checkFailure)
d.cancel()
self.assertEquals(len(receivedFailures), 1)
failure = receivedFailures[0]
self.assertIsInstance(failure.value, error.ConnectingCancelledError)
self.assertEquals(failure.value.address, address)
def test_connect(self):
txyam.client.reactor = MemoryReactor()
YamClient(['one', ('two', 123)])
connection = txyam.client.reactor.connectors[0].getDestination()
self.assertEqual(connection, IPv4Address('TCP', 'one', 11211))
connection = txyam.client.reactor.connectors[1].getDestination()
self.assertEqual(connection, IPv4Address('TCP', 'two', 123))
def _testRender(self, uri, expectedURI):
"""
Check that a request pointing at C{uri} produce a new proxy connection,
with the path of this request pointing at C{expectedURI}.
"""
root = Resource()
reactor = MemoryReactor()
resource = ReverseProxyResource("127.0.0.1", 1234, b"/path", reactor)
root.putChild(b"index", resource)
site = Site(root)
transport = StringTransportWithDisconnection()
channel = site.buildProtocol(None)
channel.makeConnection(transport)
# Clear the timeout if the tests failed
self.addCleanup(channel.connectionLost, None)
channel.dataReceived(b"GET " + uri +
b" HTTP/1.1\r\nAccept: text/html\r\n\r\n")
[(host, port, factory, _timeout, _bind_addr)] = reactor.tcpClients
# Check that one connection has been created, to the good host/port
self.assertEqual(host, "127.0.0.1")
self.assertEqual(port, 1234)
# Check the factory passed to the connect, and its given path
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEqual(factory.rest, expectedURI)
self.assertEqual(factory.headers[b"host"], b"127.0.0.1:1234")
def _testProcess(self, uri, expectedURI, method=b"GET", data=b""):
"""
Build a request pointing at C{uri}, and check that a proxied request
is created, pointing a C{expectedURI}.
"""
transport = StringTransportWithDisconnection()
channel = DummyChannel(transport)
reactor = MemoryReactor()
request = ProxyRequest(channel, False, reactor)
request.gotLength(len(data))
request.handleContentChunk(data)
request.requestReceived(method, b"http://example.com" + uri,
b"HTTP/1.0")
self.assertEqual(len(reactor.tcpClients), 1)
self.assertEqual(reactor.tcpClients[0][0], "example.com")
self.assertEqual(reactor.tcpClients[0][1], 80)
factory = reactor.tcpClients[0][2]
self.assertIsInstance(factory, ProxyClientFactory)
self.assertEqual(factory.command, method)
self.assertEqual(factory.version, b"HTTP/1.0")
self.assertEqual(factory.headers, {b"host": b"example.com"})
self.assertEqual(factory.data, data)
self.assertEqual(factory.rest, expectedURI)
self.assertEqual(factory.father, request)
def test_interface(self):
"""
The endpoint provides L{interfaces.IStreamServerEndpoint}.
"""
factory = object()
ep, ignoredArgs, ignoredDest = self.createServerEndpoint(
MemoryReactor(), factory)
self.assertTrue(verifyObject(interfaces.IStreamServerEndpoint, ep))
def test_interface(self):
"""
The endpoint provides L{interfaces.IStreamClientEndpoint}
"""
clientFactory = object()
ep, ignoredArgs, address = self.createClientEndpoint(
MemoryReactor(), clientFactory)
self.assertTrue(verifyObject(interfaces.IStreamClientEndpoint, ep))
def __init__(self, rootResource):
"""
:param rootResource: The twisted IResource at the root of the resource
tree.
"""
self._memoryReactor = MemoryReactor()
self._realAgent = Agent(reactor=self._memoryReactor)
self._rootResource = rootResource
def setUp(self):
self.patch(client, 'theResolver', FakeResolver())
self.reactor = MemoryReactor()
self.factory = DummyFactory()
self.connector = srvconnect.SRVConnector(self.reactor, 'xmpp-server',
'example.org', self.factory)
self.randIntArgs = []
self.randIntResults = []
def test_stringDescription(self):
"""
L{serverFromString} returns a L{StandardIOEndpoint} instance with a 'stdio'
endpoint string description.
"""
ep = endpoints.serverFromString(MemoryReactor(), "stdio:")
self.assertIsInstance(ep, endpoints.StandardIOEndpoint)
self.assertIsInstance(ep._reactor, MemoryReactor)
def test_list_logging(self, logger):
"""
``_NetworkClient.list`` logs an Eliot event describing its given type.
"""
client = network_kubernetes(
base_url=URL.fromText(u"http://127.0.0.1/"),
agent=Agent(MemoryReactor()),
).client()
client.list(v1.Pod)
def install(self):
"""
Mock installation of L{MockReactor}.
"""
if self.hasInstalled:
raise error.ReactorAlreadyInstalledError(
"reactor already installed")
BaseReactor.install(self)
import sys
import twisted.internet
modules = sys.modules.copy()
modules["twisted.internet.reactor"] = self
self.testCase.patch(sys, "modules", self)
self.testCase.patch(twisted.internet, "reactor", self)
def test_memoryReactorProvides(self):
"""
L{MemoryReactor} provides all of the attributes described by the
interfaces it advertises.
"""
memoryReactor = MemoryReactor()
verifyObject(IReactorTCP, memoryReactor)
verifyObject(IReactorSSL, memoryReactor)
verifyObject(IReactorUNIX, memoryReactor)
def test_stringDescription_SAM(self):
from twisted.internet.endpoints import serverFromString
with mock.patch('txi2p.sam.endpoints.getSession', fakeSession):
ep = serverFromString(
MemoryReactor(), "i2p:/tmp/testkeys.foo:81:api=SAM:options=inbound.length\:5,outbound.length\:5:sigType=foobar")
self.assertIsInstance(ep, SAMI2PStreamServerEndpoint)
s = ep._sessionDeferred
self.assertEqual(s.kwargs['options'], {'inbound.length': '5', 'outbound.length': '5'})
self.assertEqual(s.kwargs['sigType'], 'foobar')
def test_startReactorWithReactor(self):
"""
L{Runner.startReactor} with L{RunnerOptions.reactor} runs that reactor.
"""
reactor = MemoryReactor()
runner = Runner({RunnerOptions.reactor: reactor})
runner.startReactor()
self.assertTrue(reactor.hasRun)
def _authorized_request(self, token, headers):
"""
Get an agent using ``authenticate_with_serviceaccount`` and issue a
request with it.
:return bytes: The bytes of the request the agent issues.
"""
server = AccumulatingProtocol()
factory = Factory.forProtocol(lambda: server)
factory.protocolConnectionMade = None
reactor = MemoryReactor()
reactor.listenTCP(80, factory)
t = FilePath(self.useFixture(TempDir()).join(b""))
serviceaccount = t.child(b"serviceaccount")
serviceaccount.makedirs()
serviceaccount.child(b"ca.crt").setContent(_CA_CERT_PEM)
serviceaccount.child(b"token").setContent(token)
self.patch(
os,
"environ",
{
b"KUBERNETES_SERVICE_HOST": b"example.invalid.",
b"KUBERNETES_SERVICE_PORT": b"443",
},
)
agent = authenticate_with_serviceaccount(
reactor,
path=serviceaccount.path,
)
agent.request(b"GET", b"http://example.invalid.", headers)
[(host, port, factory, _, _)] = reactor.tcpClients
self.expectThat((host, port), Equals((b"example.invalid.", 80)))
pump = ConnectionCompleter(reactor).succeedOnce()
pump.pump()
return server.data
def install(self):
"""
Mock installation of L{MockReactor}.
"""
if self.hasInstalled:
raise error.ReactorAlreadyInstalledError(
"reactor already installed"
)
BaseReactor.install(self)
import sys
import twisted.internet
modules = sys.modules.copy()
modules["twisted.internet.reactor"] = self
self.testCase.patch(sys, "modules", self)
self.testCase.patch(twisted.internet, "reactor", self)
def test_listen_tcp_full_range(self):
reactor = MemoryReactor()
result = listen_tcp(self.portrange,
self.host,
Factory,
reactor=reactor)
assert self.portrange[0] <= result.getHost().port <= self.portrange[1]
assert len(reactor.tcpServers) == 1
assert self.portrange[0] <= reactor.tcpServers[0][0] <= self.portrange[
1]
def test_stringDescription_BOB(self):
from twisted.internet.endpoints import clientFromString
ep = clientFromString(
MemoryReactor(), "i2p:stats.i2p:api=BOB:tunnelNick=spam:inport=12345:options=inbound.length\:5,outbound.length\:5")
self.assertIsInstance(ep, BOBI2PClientEndpoint)
self.assertIsInstance(ep._reactor, MemoryReactor)
self.assertEqual(ep._dest,"stats.i2p")
self.assertEqual(ep._tunnelNick,"spam")
self.assertEqual(ep._inport,12345)
self.assertEqual(ep._options, {'inbound.length': '5', 'outbound.length': '5'})
def test_listenDefaultHost(self):
"""
L{MemoryReactor.listenTCP}, L{MemoryReactor.listenSSL} and
L{MemoryReactor.listenUNIX} will return an L{IListeningPort} whose
C{getHost} method returns an L{IAddress}; C{listenTCP} and C{listenSSL}
will have a default host of C{'0.0.0.0'}, and a port that reflects the
value passed, and C{listenUNIX} will have a name that reflects the path
passed.
"""
memoryReactor = MemoryReactor()
for port in [memoryReactor.listenTCP(8242, Factory()), memoryReactor.listenSSL(8242, Factory(), None)]:
verifyObject(IListeningPort, port)
address = port.getHost()
verifyObject(IAddress, address)
self.assertEqual(address.host, "0.0.0.0")
self.assertEqual(address.port, 8242)
port = memoryReactor.listenUNIX(b"/path/to/socket", Factory())
verifyObject(IListeningPort, port)
address = port.getHost()
verifyObject(IAddress, address)
self.assertEqual(address.name, b"/path/to/socket")
def test_connectDestination(self):
"""
L{MemoryReactor.connectTCP}, L{MemoryReactor.connectSSL}, and
L{MemoryReactor.connectUNIX} will return an L{IConnector} whose
C{getDestination} method returns an L{IAddress} with attributes which
reflect the values passed.
"""
memoryReactor = MemoryReactor()
for connector in [
memoryReactor.connectTCP("test.example.com", 8321, ClientFactory()),
memoryReactor.connectSSL("test.example.com", 8321, ClientFactory(), None),
]:
verifyObject(IConnector, connector)
address = connector.getDestination()
verifyObject(IAddress, address)
self.assertEqual(address.host, "test.example.com")
self.assertEqual(address.port, 8321)
connector = memoryReactor.connectUNIX(b"/fake/path", ClientFactory())
verifyObject(IConnector, connector)
address = connector.getDestination()
verifyObject(IAddress, address)
self.assertEqual(address.name, b"/fake/path")
def test_writers(self):
"""
Adding, removing, and listing writers works.
"""
writer = object()
reactor = MemoryReactor()
reactor.addWriter(writer)
reactor.addWriter(writer)
self.assertEqual(reactor.getWriters(), [writer])
reactor.removeWriter(writer)
self.assertEqual(reactor.getWriters(), [])
def test_readers(self):
"""
Adding, removing, and listing readers works.
"""
reader = object()
reactor = MemoryReactor()
reactor.addReader(reader)
reactor.addReader(reader)
self.assertEqual(reactor.getReaders(), [reader])
reactor.removeReader(reader)
self.assertEqual(reactor.getReaders(), [])
def setUp(self):
self.reactor = MemoryReactor()
self.eventloop = TwistedEventLoop(self.reactor)
def __init__(self):
MemoryReactor.__init__(self)
Clock.__init__(self)
self.spawnedProcesses = []
def __init__(self):
MemoryReactor.__init__(self)
self._triggers = {}
def __init__(self, testCase):
BaseReactor.__init__(self)
self.testCase = testCase
def __init__(self):
MemoryReactor.__init__(self)
Clock.__init__(self)
class FileDescriptorRegistrationTests(TestCase):
"""
Tests for the add/remove_reader/writer API.
"""
def setUp(self):
self.reactor = MemoryReactor()
self.eventloop = TwistedEventLoop(self.reactor)
def test_reactor(self):
"""
FileDescriptors added to the reactor have a reference to the correct
reactor.
"""
self.eventloop.add_reader(123, lambda: None)
reader, = self.reactor.getReaders()
self.assertIs(reader.reactor, self.reactor)
def assert_descriptor_has_callbacks(self, fd, read_callback,
write_callback):
fd_wrappers = set(
[wrapper for wrapper in
self.reactor.getReaders() + self.reactor.getWriters()
if wrapper.fileno() == fd])
self.assertEqual(len(fd_wrappers), 1)
wrapper = fd_wrappers.pop()
self.assertEqual((wrapper.__class__, wrapper.fileno(),
wrapper._read_callback, wrapper._write_callback),
(_GenericFileDescriptor, fd, read_callback,
write_callback))
return wrapper
def test_add_reader_callback(self):
"""
For a new fd, the callback passed to add_reader is hooked up to the
Twisted FileDescriptor's doRead, and a no-op for doWrite.
"""
func = lambda: None
self.eventloop.add_reader(123, func, 1, 2)
self.eventloop.add_reader(125, func, 1)
self.assert_descriptor_has_callbacks(123, _Callable(func, (1, 2)),
_noop)
self.assert_descriptor_has_callbacks(125, _Callable(func, (1,)),
_noop)
def test_add_writer_callback(self):
"""
For a new fd, the callback passed to add_writer is hooked up to the
Twisted FileDescriptor's doWrite, and a no-op for doRead.
"""
func = lambda: None
self.eventloop.add_writer(123, func, 1, 2)
self.eventloop.add_writer(125, func, 5)
self.assert_descriptor_has_callbacks(123, _noop, _Callable(func, (1, 2)))
self.assert_descriptor_has_callbacks(125, _noop, _Callable(func, (5,)))
def test_remove_reader_callback(self):
"""
For a new fd that is only added with add_reader, the FileDescriptor for
the fd removed by remove_reader.
"""
self.eventloop.add_reader(123, lambda: None, 1, 2)
self.eventloop.add_reader(124, lambda: None)
self.eventloop.remove_reader(123)
self.assertEqual([f.fileno() for f in self.reactor.getReaders()], [124])
def test_remove_writer_callback(self):
"""
For a new fd that is only added with add_writer, the FileDescriptor for
the fd removed by remove_writer.
"""
self.eventloop.add_writer(123, lambda: None, 1, 2)
self.eventloop.add_writer(124, lambda: None)
self.eventloop.remove_writer(123)
self.assertEqual([f.fileno() for f in self.reactor.getWriters()], [124])
def test_remove_reader_twice(self):
"""
Calling remove_reader a second time has no effect.
"""
self.eventloop.add_reader(123, lambda: None, 1, 2)
self.eventloop.remove_reader(123)
self.eventloop.remove_reader(123)
def test_remove_writer_twice(self):
"""
Calling remove_writer a second time has no effect.
"""
self.eventloop.add_writer(123, lambda: None, 1, 2)
self.eventloop.remove_writer(123)
self.eventloop.remove_writer(123)
def test_add_reader_twice(self):
"""
Calling add_reader a second time overrides the first callback.
"""
self.eventloop.add_reader(123, lambda: None, 1, 2)
reader = next(iter(self.reactor.getReaders()))
f = lambda x: 2
self.eventloop.add_reader(123, f, 4)
self.assertEqual(reader._read_callback, _Callable(f, (4,)))
def test_add_writer_twice(self):
"""
Calling add_writer a second time overrides the first callback.
"""
self.eventloop.add_writer(123, lambda: None, 1, 2)
writer = next(iter(self.reactor.getWriters()))
f = lambda x: 2
self.eventloop.add_writer(123, f, 4)
self.assertEqual(writer._write_callback, _Callable(f, (4,)))
def test_add_reader_add_writer(self):
"""
If a new fd is added with add_reader and then add_writer, both callbacks
are hooked up to a Twisted FileDescriptor.
"""
f = lambda x: 2
g = lambda y: 3
self.eventloop.add_reader(123, g, 5)
self.eventloop.add_writer(123, f, 4)
desc = self.assert_descriptor_has_callbacks(123, _Callable(g, (5,)),
_Callable(f, (4,)))
self.assertIn(desc, self.reactor.getReaders())
self.assertIn(desc, self.reactor.getWriters())
def test_add_writer_add_reader(self):
"""
If a new fd is added with add_writer and then add_reader, both callbacks
are hooked up to a Twisted FileDescriptor.
"""
f = lambda x: 2
g = lambda y: 3
self.eventloop.add_writer(123, f, 4)
self.eventloop.add_reader(123, g, 5)
desc = self.assert_descriptor_has_callbacks(123, _Callable(g, (5,)),
_Callable(f, (4,)))
self.assertIn(desc, self.reactor.getReaders())
self.assertIn(desc, self.reactor.getWriters())
def test_remove_reader_remove_writer(self):
"""
If a new fd is added as both reader and writer, the FileDescriptor for
the fd is removed if remove_reader and then remove_writer are called.
"""
self.eventloop.add_writer(123, lambda: None)
self.eventloop.add_reader(123, lambda: None)
self.eventloop.remove_reader(123)
self.eventloop.remove_writer(123)
self.assertFalse(self.reactor.getReaders() + self.reactor.getWriters())
def test_remove_writer_remove_reader(self):
"""
If a new fd is added as both reader and writer, the FileDescriptor for
the fd is removed if remove_writer and then remove_reader are called.
"""
self.eventloop.add_writer(123, lambda: None)
self.eventloop.add_reader(123, lambda: None)
self.eventloop.remove_writer(123)
self.eventloop.remove_reader(123)
self.assertFalse(self.reactor.getReaders() + self.reactor.getWriters())
def test_add_both_remove_reader(self):
"""
If a new fd is added as both reader and writer, the FileDescriptor for
the fd is not removed if only remove_writer is called.
"""
f = lambda x: 2
g = lambda y: 3
self.eventloop.add_writer(123, f, 4)
self.eventloop.add_reader(123, g, 5)
self.eventloop.remove_reader(123)
desc = self.assert_descriptor_has_callbacks(123, _noop,
_Callable(f, (4,)))
self.assertNotIn(desc, self.reactor.getReaders())
self.assertIn(desc, self.reactor.getWriters())
def test_add_both_remove_writer(self):
"""
If a new fd is added as both reader and writer, the FileDescriptor for
the fd is not removed if only remove_reader is called.
"""
f = lambda x: 2
g = lambda y: 3
self.eventloop.add_writer(123, f, 4)
self.eventloop.add_reader(123, g, 5)
self.eventloop.remove_writer(123)
desc = self.assert_descriptor_has_callbacks(123, _Callable(g, (5,)),
_noop)
self.assertIn(desc, self.reactor.getReaders())
self.assertNotIn(desc, self.reactor.getWriters())
def __init__(self):
MemoryReactor.__init__(self)
Clock.__init__(self)
self.connectors = []
def connectSSL(self, *a, **kw):
MemoryReactor.connectSSL(self, *a, **kw)
connector = MemoryConnector()
self.connectors.append(connector)
return connector
