def test_adds_user(self):
"""
When L{UserAdder} is connected to L{IdentityAdmin}, the L{AddUser}
command is called and L{IdentityAdmin} adds the user to its factory's
store.
"""
admin = IdentityAdmin()
admin.factory = self.adminFactory
serverTransport = makeFakeServer(admin)
serverTransport.getQ2QHost = lambda: Q2QAddress('Q2Q Host')
client = AMP()
pump = connect(admin, serverTransport, client, makeFakeClient(client))
d = client.callRemote(AddUser, name='q2q username',
password='******')
pump.flush()
# The username and password are added, along with the domain=q2q
# host, to the IdentityAdmin's factory's store
self.assertEqual([call('Q2Q Host', 'q2q username', 'q2q password')],
self.addUser.calls)
# The server responds with {}
self.assertEqual({}, self.successResultOf(d))
def new_protocol_tcp(self):
"""
Create a new client protocol connected to the server.
:returns: a IRelayTestClient implementation
"""
server_factory = ServerFactory()
server_factory.protocol = TransitConnection
server_factory.transit = self._transit_server
server_factory.log_requests = self.log_requests
server_protocol = server_factory.buildProtocol(('127.0.0.1', 0))
@implementer(IRelayTestClient)
class TransitClientProtocolTcp(Protocol):
"""
Speak the transit client protocol used by the tests over TCP
"""
_received = b""
connected = False
# override Protocol callbacks
def connectionMade(self):
self.connected = True
return Protocol.connectionMade(self)
def connectionLost(self, reason):
self.connected = False
return Protocol.connectionLost(self, reason)
def dataReceived(self, data):
self._received = self._received + data
# IRelayTestClient
def send(self, data):
self.transport.write(data)
def disconnect(self):
self.transport.loseConnection()
def reset_received_data(self):
self._received = b""
def get_received_data(self):
return self._received
client_factory = ClientFactory()
client_factory.protocol = TransitClientProtocolTcp
client_protocol = client_factory.buildProtocol(('127.0.0.1', 31337))
pump = iosim.connect(
server_protocol,
iosim.makeFakeServer(server_protocol),
client_protocol,
iosim.makeFakeClient(client_protocol),
)
pump.flush()
self._pumps.append(pump)
return client_protocol
def _new_protocol_ws(transit_server, log_requests):
"""
Internal helper for test-suites that need to provide WebSocket
client/server pairs.
:returns: a 2-tuple: (iosim.IOPump, protocol)
"""
ws_factory = WebSocketServerFactory("ws://localhost:4002")
ws_factory.protocol = WebSocketTransitConnection
ws_factory.transit = transit_server
ws_factory.log_requests = log_requests
ws_protocol = ws_factory.buildProtocol(('127.0.0.1', 0))
@implementer(IRelayTestClient)
class TransitWebSocketClientProtocol(WebSocketClientProtocol):
_received = b""
connected = False
def connectionMade(self):
self.connected = True
return super(TransitWebSocketClientProtocol, self).connectionMade()
def connectionLost(self, reason):
self.connected = False
return super(TransitWebSocketClientProtocol,
self).connectionLost(reason)
def onMessage(self, data, isBinary):
self._received = self._received + data
def send(self, data):
self.sendMessage(data, True)
def get_received_data(self):
return self._received
def reset_received_data(self):
self._received = b""
def disconnect(self):
self.sendClose(1000, True)
client_factory = WebSocketClientFactory()
client_factory.protocol = TransitWebSocketClientProtocol
client_protocol = client_factory.buildProtocol(('127.0.0.1', 31337))
client_protocol.disconnect = client_protocol.dropConnection
pump = iosim.connect(
ws_protocol,
iosim.makeFakeServer(ws_protocol),
client_protocol,
iosim.makeFakeClient(client_protocol),
)
return pump, client_protocol
def connect(self, cluster, region):
"""Wire up a connection between cluster and region.
:type cluster: `twisted.internet.interfaces.IProtocol`
:type region: `twisted.internet.interfaces.IProtocol`
:return: py:class:`twisted.test.iosim.IOPump`
"""
return iosim.connect(
region,
iosim.makeFakeServer(region),
cluster,
iosim.makeFakeClient(cluster),
debug=False, # Debugging is useful, but too noisy by default.
)
def addCluster(self, protocol):
"""Add a new stub cluster using the given `protocol`.
The `protocol` should be an instance of `amp.AMP`.
:return: py:class:`twisted.test.iosim.IOPump`
"""
server_factory = Factory.forProtocol(RegionServer)
server_factory.service = self.rpc
server = server_factory.buildProtocol(addr=None)
return iosim.connect(
server, iosim.makeFakeServer(server),
protocol, iosim.makeFakeClient(protocol),
debug=False, # Debugging is useful, but too noisy by default.
)
async def execute(reactor, dbDir):
root = SoftFabRoot(dbDir, reactor=None, anonOperator=False)
await root.startup()
clientInfo, = reactor.unixClients
clientFactory = clientInfo[1]
serverFactory = ControlSocket(root.apiRoot)
clientProtocol = clientFactory.buildProtocol(None)
serverProtocol = serverFactory.buildProtocol(None)
serverTransport = makeFakeServer(serverProtocol)
clientTransport = makeFakeClient(clientProtocol)
pump = connect(serverProtocol,
serverTransport,
clientProtocol,
clientTransport,
debug=False)
pump.flush()
