def basicUnitTest(): #asyncio.set_event_loop(TestLoopEx()) # server = EchoServerProtocol() # client = EchoClientProtocol() # transportToServer = MockTransportToProtocol(server) # transportToClient = MockTransportToProtocol(client) # server.connection_made(transportToClient) # client.connection_made(transportToServer) client = EchoClientProtocol() server = EchoServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) firstRequest = packetClass.RequestRecommandation() client.Request(firstRequest) assert server.serverstatus == 1 assert client.clientstatus == 1 #client.method(firstRequest) OneAnswer = packetClass.Answer() OneAnswer.answer = "oliy" OneAnswer.ID = 1 client.method(OneAnswer) assert server.serverstatus == 2 assert client.clientstatus == 2
def UnitTest(): asyncio.set_event_loop(TestLoopEx()) clientProtocol = ClientSide() serverProtocol = ServerSide() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) serverProtocol.connection_made(sTransport) clientProtocol.connection_made(cTransport)
def basicProtocolTest(): asyncio.set_event_loop(TestLoopEx()) clientProtocol = EchoClientProtocol() serverProtocol = EchoServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) clientProtocol.connection_made(cTransport) serverProtocol.connection_made(sTransport) clientProtocol.send_request()
def UnitTest2(): set_event_loop(TestLoopEx()) clientProtocol = EchoClientProtocol() serverProtocol = EchoServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) clientProtocol.connection_made(cTransport) serverProtocol.connection_made(sTransport) clientProtocol.SetIdentityInfo(123, "Jack", "2017jack") clientProtocol.SendLoginRequest()
def basicUnitTest(): print('Begin') asyncio.set_event_loop(TestLoopEx()) clientProtocol = ClientProtocol() serverProtocol = ServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) clientProtocol.connection_made(cTransport) serverProtocol.connection_made(sTransport) clientProtocol.start()
def basicUnitTest(): # asyncio.set_event_loop(TestLoopEx()) clientProtocol = MyClientProtocol() serverProtocol = MyServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) clientProtocol.connection_made(cTransport) serverProtocol.connection_made(sTransport) packet1 = RequestConnect() packet1.iD = "ELROY" clientProtocol.transport.write(packet1.__serialize__())
def unitTest(): #for now params are picked within the protocols from playground.network.testing import MockTransportToProtocol from playground.asyncio_lib.testing import TestLoopEx asyncio.set_event_loop(TestLoopEx()) server = PlaneServer() client = PlaneClient() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) server.connection_made(sTransport) client.connection_made(cTransport)
def basicUnitTest(): client = Protocol.ForgotPasswordClientProtocol() server = Protocol.ForgotPasswordServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) server.connection_made(sTransport) client.connection_made(cTransport) # client.send_initial_message() packet1 = Packets.RequestForgotPasswordPacket() packet1.userId = 'ehsia1' packet1Bytes = packet1.__serialize__() sResponse1 = server.data_received(packet1Bytes) assert isinstance(sResponse1, Packets.SecurityQuestionPacket) packet2 = Packets.SecurityQuestionPacket() packet2.securityQuestion = 'What was your hometown?' packet2Bytes = packet2.__serialize__() cResponse1 = client.data_received(packet2Bytes) cResponse1 = PacketType.Deserialize(cResponse1) assert isinstance(cResponse1, Packets.SecurityAnswerPacket) packet3 = Packets.SecurityAnswerPacket() packet3.securityAnswer = 'Windsor, CT' packet3Bytes = packet3.__serialize__() sResponse2 = server.data_received(packet3Bytes) assert isinstance(sResponse2, Packets.ForgotPasswordTokenPacket) packet3.securityAnswer = 'Windsor' packet3Bytes = packet3.__serialize__() sResponse2 = server.data_received(packet3Bytes) assert sResponse2 == "Invalid" packet4 = Packets.ForgotPasswordTokenPacket() packet4.token = 'asdf2313241SqwerXq' packet4Bytes = packet4.__serialize__() cResponse2 = client.data_received(packet4Bytes) cResponse2 = PacketType.Deserialize(cResponse2) assert isinstance(cResponse2, Packets.ResetPasswordInputPacket) packet5 = Packets.ResetPasswordInputPacket() packet5.newPassword = '******' packet5.passwordConfirmation = 'gronkgronkgronk' packet5Bytes = packet5.__serialize__() sResponse3 = server.data_received(packet5Bytes) assert isinstance(sResponse3, Packets.PasswordResetPacket) assert sResponse3.verification == True packet5.newPassword = '******' packet5.passwordConfirmation = 'gronkgronkgronk' packet5Bytes = packet5.__serialize__() sResponse3 = server.data_received(packet5Bytes) assert isinstance(sResponse3, Packets.PasswordResetPacket) assert sResponse3.verification == False print("Protocol completed! All tests passed!")
def basicUnitTest(): loop = TestLoopEx() asyncio.set_event_loop(TestLoopEx()) clientProtocol = ClientProtocol(loop) serverProtocol = ServerProtocol() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair(clientProtocol, serverProtocol) clientProtocol.connection_made(cTransport) serverProtocol.connection_made(sTransport) pkt1 = DB_connect() clientProtocol.send_packet(pkt1)
def basicUnitTest(): loop = asyncio.set_event_loop(TestLoopEx()) server = EchoServerProtocol() server.invite('Bob', 'California', 1, 1, '10.0.0.1', 65001, ['G711u', 'G729', 'G722', 'OPUS', 'G711a']) client = EchoClientProtocol(loop) client.response('Alice', 'WashingtonDC', 1, 1, '192.168.1.254', 45532, ["G722a", "G729"]) #transportToServer = MockTransportToProtocol(server) #transportToClient = MockTransportToProtocol(client) transportToServer, transportToClient = MockTransportToProtocol.CreateTransportPair( client, server) server.connection_made(transportToClient) client.connection_made(transportToServer)
def basicUnitTest(): from playground.asyncio_lib.testing import TestLoopEx from playground.network.testing import MockTransportToProtocol loop = asyncio.get_event_loop() print("Making the server choose a 'random' number of 5.") client_1 = RandomNumberGameClientProtocol(loop) server_1 = RandomNumberGameServerProtocol(seed=5) cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client_1, server_1) server_1.connection_made(sTransport) client_1.connection_made(cTransport) client_1.initiate_game(guess=4) client_2 = RandomNumberGameClientProtocol(loop) server_2 = RandomNumberGameServerProtocol(seed=5) cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client_2, server_2) server_2.connection_made(sTransport) client_2.connection_made(cTransport) client_2.initiate_game(guess=5)
def basicUnitTestForPEEPProtocol(loggingFlag): asyncio.set_event_loop(TestLoopEx()) loop = asyncio.get_event_loop() server = PEEPServerProtocol(False) client = PEEPClientProtocol(False) client.set_timeout_flag(False) client.set_mock_flag(True) server.set_mock_flag(True) cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) # test for general connection_made client.connection_made(cTransport) server.connection_made(sTransport) if loggingFlag == True: print("- test for general connection_made SUCCESS") if loggingFlag == True: print("") # negative test for messing up packet order cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) MockPEEPPacket_SYN = Util.create_outbound_packet(0, 1, 1, b"data") packetBytes = MockPEEPPacket_SYN.__serialize__() server.state = "SYN_State_1" client.state = "SYN_ACK_State_1" server.data_received(packetBytes) assert server.state == "error_state" if loggingFlag == True: print("- negative test for messing up packet order SUCCESS") if loggingFlag == True: print("")
def basicUnitTest(): loop = TestLoopEx() asyncio.set_event_loop(loop) # Test Loop client = EchoClientProtocol() # Initialize Client Protocol server = EchoServerProtocol() # Initialize Server Protocol cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) #transportToServer = MockTransportToProtocol(server) #transportToClient = MockTransportToProtocol(client) packet1 = AccessResource() packet1Bytes = packet1.__serialize__() server.connection_made(sTransport) client.connection_made(cTransport) server.data_received(packet1Bytes)
def basicUnitTest(): loop = asyncio.get_event_loop() playground.getConnector().create_playground_server( lambda: EchoServerProtocol(), 8000) playground.getConnector().create_playground_connection( lambda: EchoClientProtocol(), "20174.1.1.1", 8000) client = EchoClientProtocol() # Initialize Client Protocol server = EchoServerProtocol() # Initialize Server Protocol cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) #transportToServer = MockTransportToProtocol(server) #transportToClient = MockTransportToProtocol(client) packet1 = AccessResource() packet1Bytes = packet1.__serialize__() server.connection_made(sTransport) client.connection_made(cTransport) server.data_received(packet1Bytes)
def basicUnitTest(): from playground.network.testing import MockTransportToProtocol as MTP from playground.network.testing import MockTransportToStorageStream as MTSS from playground.asyncio_lib.testing import TestLoopEx loop = asyncio.set_event_loop(TestLoopEx()) clientProtocol = SimpleMathProtocolClient() serverProtocol = SimpleMathProtocolServer() transportToServer, transportToClient = MTP.CreateTransportPair( clientProtocol, serverProtocol) clientProtocol.connection_made(transportToServer) serverProtocol.connection_made(transportToClient) for i in range(0, 10): clientProtocol.requestProblem()
def basicUnitTestForAppLayerProtocol(loggingFlag): asyncio.set_event_loop(TestLoopEx()) loop = asyncio.get_event_loop() server = VerificationCodeServerProtocol(loop, False) client = VerificationCodeClientProtocol(1, loop, False) server.set_mock_flag(True) client.set_mock_flag(True) cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) # test for general connection_made client.connection_made(cTransport) server.connection_made(sTransport) if loggingFlag == True: print("- test for general connection_made SUCCESS") if loggingFlag == True: print("") # test for client verification code length cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) MockRequestPacket = RequestPacket() MockRequestPacket.ID = 1 packetBytes = MockRequestPacket.__serialize__() server.data_received(packetBytes) assert len(str(server._verificationCode)) == 6 if loggingFlag == True: print("- test for client verification code length SUCCESS") if loggingFlag == True: print("") # negative test for messing up packet order cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) MockVerifyPacket = VerifyPacket() MockVerifyPacket.ID = 1 MockVerifyPacket.answer = server._verificationCode packetBytes = MockVerifyPacket.__serialize__() server.state = "wait_for_verify_packet" client.state = "initial_state" server.data_received(packetBytes) assert client.state == "error_state" if loggingFlag == True: print("- negative test for messing up packet order SUCCESS") if loggingFlag == True: print("") # test for client vericifation result cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) MockVerifyPacket = VerifyPacket() MockVerifyPacket.ID = 1 MockVerifyPacket.answer = server._verificationCode packetBytes = MockVerifyPacket.__serialize__() server.state = "wait_for_verify_packet" client.state = "wait_for_result_packet" server.data_received(packetBytes) assert server._result == "pass" if loggingFlag == True: print("- test for client vericifation result SUCCESS") if loggingFlag == True: print("") # negative test for client vericifation result cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( client, server) client.connection_made(cTransport) server.connection_made(sTransport) MockVerifyPacket = VerifyPacket() MockVerifyPacket.ID = 1 MockVerifyPacket.answer = 0 packetBytes = MockVerifyPacket.__serialize__() server.state = "wait_for_verify_packet" client.state = "wait_for_result_packet" server.data_received(packetBytes) assert server._result == "fail" if loggingFlag == True: print("- negative test for client vericifation result SUCCESS") if loggingFlag == True: print("")
def basicUnitTest(): from playground.network.testing import MockTransportToProtocol as MockTransport class MockSwitch: def __init__(self): self.addresses = {} self.extensionPackets = [] def registerLink(self, address, protocol): self.addresses[address] = self.addresses.get(address, []) + [protocol] def unregisterLink(self, protocol): # this is slow, but fine for testing: rem = None for address in self.addresses: if not protocol in self.addresses[address]: continue self.addresses[address].remove(protocol) if len(self.addresses[address]) == 0: rem = address if rem: del self.addresses[rem] def getOutboundLinks(self, source, sourcePort, destination, destinationPort): return self.addresses[destination] def handleExtensionPacket(self, ep): self.extensionPackets.append(ep) class MockClient: def __init__(self): self.results = [] def demux(self, source, sourcePort, destination, destinationPort, data): self.results.append( (source, sourcePort, destination, destinationPort, data)) def connectionMade(self): pass def connectionLost(self): pass switch = MockSwitch() rx1 = PlaygroundSwitchRxProtocol(switch) rx2 = PlaygroundSwitchRxProtocol(switch) rx3 = PlaygroundSwitchRxProtocol(switch) client1, client2, client3 = MockClient(), MockClient(), MockClient() c1Tx = PlaygroundSwitchTxProtocol(client1, "1.1.1.1") c2Tx = PlaygroundSwitchTxProtocol(client2, "2.2.2.2") c3Tx = PlaygroundSwitchTxProtocol(client3, "2.2.2.2") # Client transports send data to rx) c1Transport, rx1Transport = MockTransport.CreateTransportPair(c1Tx, rx1) c2Transport, rx2Transport = MockTransport.CreateTransportPair(c2Tx, rx2) c3Transport, rx3Transport = MockTransport.CreateTransportPair(c3Tx, rx3) # Make the switch-side connections first rx1.connection_made(rx1Transport) rx2.connection_made(rx2Transport) rx3.connection_made(rx3Transport) # Connecting the client protocols should cause an announce packet sent assert len(switch.addresses) == 0 c1Tx.connection_made(c1Transport) assert len(switch.addresses) == 1 c2Tx.connection_made(c2Transport) assert len(switch.addresses) == 2 # Client 3 has the same address as client 2 c3Tx.connection_made(c3Transport) assert len(switch.addresses) == 2 # Send some small hello messages. c1Tx.write("1.1.1.1", 80, "2.2.2.2", 1000, b"Test1") assert len(client2.results) == 1 assert client2.results[0] == ("1.1.1.1", 80, "2.2.2.2", 1000, b"Test1") assert len(client3.results) == 1 assert client3.results[0] == client2.results[0] c2Tx.write("2.2.2.2", 1000, "1.1.1.1", 80, b"Response") assert client1.results[0] == ("2.2.2.2", 1000, "1.1.1.1", 80, b"Response") # Send a large packet to test fragmentation/re-assembly repeatingKey = b"REPEATINGKEY" largeData = b"" while len(largeData) < (PlaygroundSwitchTxProtocol.MAX_MSG_SIZE + 100): largeData += repeatingKey curWriteCount = c3Transport.writeCount c3Tx.write("2.2.2.2", 1000, "1.1.1.1", 80, largeData) # should have written twice (two fragments) assert c3Transport.writeCount == (curWriteCount + 2) print("client 1 results count {}, len data {}, original len{}.".format( len(client1.results), len(client1.results[1][-1]), len(largeData))) assert client1.results[1][-1] == largeData c1Transport.close() assert c1Tx.transport == None assert rx1Transport.closed assert rx1.transport == None rx2Transport.close() assert rx2.transport == None assert c2Transport.closed assert c2Tx.transport == None
def basicUnitTest(): # initialize packets pktInfoSequence = [] unlockPacket1 = UnlockPacket() unlockPacket1.password = "******" pktInfoSequence.append( ("Sending unlock packet #1 (1234, bad format)", unlockPacket1)) unlockPacket2 = UnlockPacket() unlockPacket2.password = "******" pktInfoSequence.append( ("Sending unlock packet #2 (001, wrong password)", unlockPacket2)) unlockPacket3 = UnlockPacket() unlockPacket3.password = "******" pktInfoSequence.append(("Sending unlock packet #3 (000)", unlockPacket3)) unlockPacket4 = unlockPacket3 pktInfoSequence.append( ("Sending unlock packet #4 (000, duplicate)", unlockPacket4)) changePasswordPacket1 = ChangePasswordPacket() changePasswordPacket1.password = "******" pktInfoSequence.append( ("Sending change password packet #1 (1234, bad format)", changePasswordPacket1)) changePasswordPacket2 = ChangePasswordPacket() changePasswordPacket2.password = "******" pktInfoSequence.append( ("Sending change password packet #2 (123)", changePasswordPacket2)) lockPacket1 = LockPacket() pktInfoSequence.append(("Sending lock packet #1", lockPacket1)) lockPacket2 = LockPacket() pktInfoSequence.append(("Sending lock packet #2", lockPacket2)) changePasswordPacket3 = ChangePasswordPacket() changePasswordPacket3.password = "******" pktInfoSequence.append( ("Sending change password packet #3 (456, now locked)", changePasswordPacket3)) unlockPacket5 = UnlockPacket() unlockPacket5.password = "******" pktInfoSequence.append( ("Sending unlock packet #5 (000, wrong password)", unlockPacket5)) unlockPacket6 = UnlockPacket() unlockPacket6.password = "******" pktInfoSequence.append(("Sending unlock packet #6 (123)", unlockPacket6)) testOptionalListPacket = TestOptionalListPacket() testOptionalListPacket.testlist = ["Whatever"] pktInfoSequence.append( ("Sending unknown type packet", testOptionalListPacket)) lock = Lock("000", True) print("Unit test started; Lock initialized as locked, password = 000") # Modified from lab1c PDF asyncio.set_event_loop(TestLoopEx()) clientProtocol = LockClientProtocol() serverProtocol = LockServerProtocol(lock) cTransport, sTransport = MockTransportToProtocol.CreateTransportPair( clientProtocol, serverProtocol) # Initialize server first to obtain transport serverProtocol.connection_made(sTransport) clientProtocol.connection_made(cTransport) clientProtocol.sendPackets(pktInfoSequence)
def connection_made(self, transport): print('--- peep connect to client---') self.transport = transport self.deserializer = PacketType.Deserializer() def data_received(self, data): self.deserializer.update(data) print (data) # peepInfoS = PEEPPacket() # peepInfoS.sequenceNumber = 5 # for pkt in self.deserializer.nextPackets(): # if isinstance(pkt,PEEPClient.connection_made().peepInfoC.sequenceNumber()): # peepInfoS.Acknowledgement = PEEPClient.connection_made().peepInfoC.sequenceNumber()+1 # self.transport.write(peepInfoS.__serialize__()) def connection_lost(self, exc): self.connection_lost(exc) if __name__ == '__main__': client = PEEPClient() server = PEEPServer() cTransport, sTransport = MockTransportToProtocol.CreateTransportPair(client, server) client.connection_made(cTransport) server.connection_made(sTransport)