def basicUnitTest():
loop = asyncio.set_event_loop(TestLoopEx())
serverProtocol = MyServerProtocol()
clientProtocol = MyClientProtocol(loop)
# calling transportToServer’s write method will route the data directly to server’s data_received method
#transportToServer = MockTransportToProtocol(serverProtocol)
#transportToClient = MockTransportToProtocol(clientProtocol)
transportToServer = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient = MockTransportToProtocol(myProtocol=serverProtocol)
# when setRemoteTransport is called, it writes data to the transport's protocol
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
# serverProtocol.connection_made(transportToClient)
# clientProtocol.connection_made(transportToServer)
clientProtocol.connection_made(transportToServer)
serverProtocol.connection_made(transportToClient)
# try to send a pkt with clientID = 1
clientProtocol.sendRequest(1)
# try to send something not packet
try:
serverProtocol.data_received('Test')
except TypeError:
print(TypeError)
def basicUnitTest():
clientProtocol = MyProtocolClient("hello", TestLoopEx())
serverProtocol = MyProtocolServer()
transportToServer = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
serverProtocol.connection_made(transportToClient)
clientProtocol.connection_made(transportToServer)
def basicUnitTest():
clientProtocol = MyProtocolClient("hello", TestLoopEx())
serverProtocol = MyProtocolServer()
transportToServer = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
serverProtocol.connection_made(transportToClient)
clientProtocol.connection_made(transportToServer)
def basicUnitTest():
asyncio.set_event_loop(TestLoopEx())
client = ClientProtocol()
server = ServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=client)
transportToClient = MockTransportToProtocol(myProtocol=server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
client.connection_made(transportToServer)
server.connection_made(transportToClient)
client.sendpkt1(b"ABC123", b"EN.601.644", True)
def basicUnitTest():
# Build a MockConnection between Client and Server
set_event_loop(TestLoopEx())
client = ClientProtocol() #sending data from the protocol
server = ServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=client)
transportToClient = MockTransportToProtocol(myProtocol=server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
server.connection_made(transportToClient)
client.connection_made(transportToServer)
client.Login("wwz", "hellowwz")
def UnitTest1():
set_event_loop(TestLoopEx())
clientProtocol = EchoClientProtocol()
serverProtocol = EchoServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
clientProtocol.connection_made(transportToServer)
serverProtocol.connection_made(transportToClient)
clientProtocol.SetIdentityInfo(123, "Alex", "2017alex")
clientProtocol.SendLoginRequest()
def test_connection(self):
asyncio.set_event_loop(TestLoopEx())
testData = RequestFlip()
testData.headOrTail = True
testData.numFlips = 1000
client = CoinClientProtocol(testData)
server = CoinServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=server)
transportToClient = MockTransportToProtocol(myProtocol=client)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
client.connection_made(transportToServer)
server.connection_made(transportToClient)
def basicUnitTest():
asyncio.set_event_loop(TestLoopEx())
server = MoviesServer()
client = MoviesClient()
transportToServer = MockTransportToProtocol(myProtocol=client)
transportToClient = MockTransportToProtocol(myProtocol=server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
server.connection_made(transportToClient)
client.connection_made(transportToServer)
client.requestMovieInfo("frozen", "genre")
assert MoviesClient.str == "Comedy"
assert MoviesServer.str == "genre"
def basic_unit_test():
set_event_loop(TestLoopEx())
client = ClientProtocol("harry", "123456", "*****@*****.**")
server = ServerProtocol()
transport_to_server = MockTransportToProtocol(client)
transport_to_client = MockTransportToProtocol(server)
transport_to_server.setRemoteTransport(transport_to_client)
transport_to_client.setRemoteTransport(transport_to_server)
client.connection_made(transport_to_server)
server.connection_made(transport_to_client)
client.sign_up()
def basicUnitTest():
loop = TestLoopEx()
asyncio.set_event_loop(loop)
Server = ServerProtocol()
Client = ClientProtocol()
transportToServer = MockTransportToProtocol(myProtocol=Client)
transportToClient = MockTransportToProtocol(myProtocol=Server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
Server.connection_made(transportToClient)
Client.first_packet('111','POP')
Client.connection_made(transportToServer)
def BasicUnitTest():
set_event_loop(TestLoopEx())
client = IoTClientProtocol()
server = IoTServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=client)
transportToClient = MockTransportToProtocol(myProtocol=server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
client.connection_made(transportToServer)
server.connection_made(transportToClient)
client.GetDeviceList()
server.DeviceList()
client.ModifyDevice()
server.Respond()
def UnitTest():
loop = TestLoopEx()
asyncio.set_event_loop(loop)
Server = MyServer()
Client = MyClient()
transportToServer = MockTransportToProtocol(myProtocol=Client)
transportToClient = MockTransportToProtocol(myProtocol=Server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
Server.connection_made(transportToClient)
Client.Initial_Packet()
Client.connection_made(transportToServer)
def basicUnitTest():
loop = asyncio.set_event_loop(TestLoopEx())
client = ClientProtocol(loop)
server = ServerProtocol()
transportToServer = MockTransportToProtocol(myProtocol=client)
transportToClient = MockTransportToProtocol(myProtocol=server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
server.connection_made(transportToClient)
client.connection_made(transportToServer)
loginWithUsername = LogInWithUsername()
getUserProfile = GetUserProfleWithID()
client.loginStart(loginWithUsername, getUserProfile)
assert client.state == 1
assert server.state == 1
def basicUnitTest():
asyncio.set_event_loop(TestLoopEx())
client=MyClientProtocol()
server=MyServerProtocol()
transportToServer=MockTransportToProtocol(myProtocol = client)
transportToClient=MockTransportToProtocol(myProtocol = server)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
server.connection_made(transportToClient)
client.connection_made(transportToServer)
pktCR = ConnectionRequest()
#pktCR2 = ConnectionRequest()
#pktCR3 = ConnectionRequest()
print("Start test. The packet is sent.")
client.send(pktCR)
#client.send(pktCR2)
#client.send(pktCR3)
print("Test End")
def basicUnitTest():
print(
"WARNING: Since most of the data only exist in transmission, this unit test will use printing method to show if the code works"
)
print("")
asyncio.set_event_loop(TestLoopEx())
clientName = "peter"
tableNumber = 14
stockList = {
"Appetizers": {
"Buffalo Fried Cauliflower": 43,
"Triple Dipper": 37
},
"Sandwiches": {
"Bacon Avocado Chicken": 96,
"Buffalo Chicken Ranch": 23,
"Grilled Chicken": 3
},
"Salads_and_Soups": {
"Santa Fe Crisper Salad": 54,
"Margherita Flatbread Salad": 42,
"Margherita Flatbread Salad with Chicken": 32,
"House Salad": 35
},
"Desert": {
"Triple Berry Crumble Cake": 1
}
}
menu = {
"Appetizers": ["Buffalo Fried Cauliflower", "Triple Dipper"],
"Sandwiches":
["Bacon Avocado Chicken", "Buffalo Chicken Ranch", "Grilled Chicken"],
"Salads_and_Soups": [
"Santa Fe Crisper Salad", "Margherita Flatbread Salad",
"Margherita Flatbread Salad with Chicken", "House Salad"
],
"Desert": ["Triple Berry Crumble Cake"]
}
client = playground.getConnector().create_playground_server(
lambda: CustomerClientProtocol(clientName, tableNumber), 101)
server = playground.getConnector().create_playground_connection(
lambda: RestaurantServerProtocol(stockList, menu), "20174.1.1.1", 101)
# client = CustomerClientProtocol(clientName, tableNumber)
# server = RestaurantServerProtocol(stockList, menu)
transportToServer = MockTransportToProtocol(server)
transportToClient = MockTransportToProtocol(client)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
client.connection_made(transportToServer)
server.connection_made(transportToClient)
print(
"======================================================================"
)
print("Submission: Testing sending menu...")
client.requestMenu()
assert menu.keys() == client.receivedMenu.keys()
for key in menu.keys():
assert menu[key] == client.receivedMenu[key]
assert client.receivedMenu[key] == server.originalMenu[key]
assert client.status == client.SEND_ORDER
assert server.status == server.WAITING_ORDER
print(
"======================================================================"
)
print("Submission: Testing sending order from Client...")
print("1) Testing normal orders...(should success)")
ordered = {
"Bacon Avocado Chicken": 1,
"Buffalo Chicken Ranch": 2,
"Buffalo Fried Cauliflower": 1
}
client.sendOrder(ordered)
assert client.status == client.WAITING
assert server.status == server.WAITING
print(" ")
print(
"2) Testing ordering dishes that does not exist in menu...(should fail)"
)
client.requestMenu()
ordered = {
"Bacon Avocado Chicken": 1,
"Buffalo Chicken Ranch": 2,
"Buffalo Fried Cauliflower": 1,
"Something not exist1": 10,
"Something not exist3": 12
}
client.sendOrder(ordered)
print(" ")
print("3) Testing ordering dishes that are out of stock...(should fail)")
client.requestMenu()
ordered = {
"Bacon Avocado Chicken": 1,
"Buffalo Chicken Ranch": 2,
"Triple Berry Crumble Cake": 3,
"Grilled Chicken": 4
}
client.sendOrder(ordered)
print(" ")
print(
"4) Testing ordering dishes that are both not exist and out of stock...(should fail)"
)
client.requestMenu()
ordered = {
"Bacon Avocado Chicken": 1,
"Buffalo Chicken Ranch": 2,
"Triple Berry Crumble Cake": 3,
"Grilled Chicken": 4,
"Something not exist1": 10,
"Something not exist3": 12
}
client.sendOrder(ordered)
print(" ")
print("5) Testing ordering nothing")
client.requestMenu()
client.sendOrder({})
print(
"======================================================================"
)
def basicUnitTest():
packet1 = RequestCountry()
packet1Bytes = packet1.__serialize__()
packet1a = RequestCountry.Deserialize(packet1Bytes)
assert packet1 == packet1a
packet2 = Question()
packet2.country = "Japan"
packet2.id = 1
packet2Bytes = packet2.__serialize__()
packet2a = Question.Deserialize(packet2Bytes)
assert packet2 == packet2a
packet3 = Answer()
packet3.capital = "Tokyo"
packet3.id = 1
packet3Bytes = packet3.__serialize__()
packet3a = Answer.Deserialize(packet3Bytes)
assert packet3 == packet3a
packet4 = Result()
packet4.passfail = True
packet4.id = 1
packet4Bytes = packet4.__serialize__()
packet4a = Result.Deserialize(packet4Bytes)
assert packet4 == packet4a
asyncio.set_event_loop(TestLoopEx())
clientProtocol = StudentClient()
serverProtocol = QuizServer()
transportToServer = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer.setRemoteTransport(transportToClient)
transportToClient.setRemoteTransport(transportToServer)
clientProtocol.connection_made(transportToServer)
serverProtocol.connection_made(transportToClient)
# client sends first packet
clientProtocol.request(stdInCallback)
transportToClient.close()
transportToServer.close()
print()
transportToServer2 = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient2 = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer2.setRemoteTransport(transportToClient)
transportToClient2.setRemoteTransport(transportToServer)
clientProtocol.connection_made(transportToServer2)
serverProtocol.connection_made(transportToClient2)
# server receives wrong packet
serverProtocol.data_received(packet3Bytes)
print()
transportToServer3 = MockTransportToProtocol(myProtocol=clientProtocol)
transportToClient3 = MockTransportToProtocol(myProtocol=serverProtocol)
transportToServer3.setRemoteTransport(transportToClient)
transportToClient3.setRemoteTransport(transportToServer)
clientProtocol.connection_made(transportToServer3)
serverProtocol.connection_made(transportToClient3)
# client receives wrong packet
clientProtocol.data_received(packet4Bytes)
