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