def test_sending_messages(self):
"""
SocketLayer receives a message from higher layer so it sends it
"""
self.socket_layer.start_server("127.0.0.1", 8080)
sender = Peer(33, "33.22.11.22", 9992, False)
sender2 = Peer(21, "23.45.67.86", 9393, False)
receiver = Peer(11, '127.0.0.1', 8080, False)
mess = putils.create_ping_message(sender, receiver)
mess2 = putils.create_ping_message(sender2, receiver)
address = putils.get_receiver_address(mess)
address2 = putils.get_receiver_address(mess2)
_run(self.higher[0].put((mess.SerializeToString(), address)))
_run(self.higher[0].put((mess2.SerializeToString(), address2)))
# Get the message
msg = _run(self.higher[1].get())
msg2 = _run(self.higher[1].get())
log.warning("Stop the server")
status = _run(self.socket_layer.stop_server())
self.assertIs(status, StatusMessage.SUCCESS)
self.assertEqual(msg, mess.SerializeToString())
self.assertEqual(msg2, mess2.SerializeToString())
def test_that_server_receives_messages(self):
"""
We tell SocketLayer to start the server.
It should start it in another thread and listen for incoming connections at given socket.
We test that by sending some message to the server and if everything works it should handle it and put it into the queue.
"""
self.socket_layer.start_server("127.0.0.1", 8080)
log.debug("Create socket")
sock = socket.socket()
sock2 = socket.socket()
try:
sock.connect(("127.0.0.1", 8080))
sock2.connect(("127.0.0.1", 8080))
except socket.error as msg:
log.warning("Could not connect to the server")
return
mess = putils.create_ping_message(self.sender, self.receiver)
sender2 = Peer(555, '1.123.1.123', 333, True)
receiver2 = Peer(5434, '64.88.66.22', 444, True)
mess2 = putils.create_ping_message(sender2, receiver2)
serialized = putils.serialize_message(mess)
framed = self.socket_layer._frame_message(serialized)
serialized2 = putils.serialize_message(mess2)
framed2 = self.socket_layer._frame_message(serialized2)
try:
log.debug("Try to send the messages")
sock.send(framed)
log.debug("Try to send next messages")
sock2.send(framed2)
except socket.error as msg:
log.warning("Could not send the message: {}".format(msg))
sock.close()
sock2.close()
return
sock.close()
sock2.close()
#Get the message
msg = _run(self.higher[1].get())
msg2 = _run(self.higher[1].get())
log.warning("Stop the server")
status = _run(self.socket_layer.stop_server())
self.assertIs(status, StatusMessage.SUCCESS)
# And now we check if the message is correct
self.assertIn(serialized, [msg, msg2])
self.assertIn(serialized2, [msg, msg2])
def test_responding_to_ping(self):
another_peer = Peer(5, "127.33.21.22", 3233, False)
this_peer = self.business_layer.get_myself()
message = putils.create_ping_message(sender=another_peer,
receiver=this_peer)
message2 = putils.create_ping_message(sender=another_peer,
receiver=this_peer)
message3 = putils.create_ping_message(sender=another_peer,
receiver=this_peer)
# Put three messages in queue
_run(self.lower[0].put(message))
_run(self.lower[0].put(message2))
_run(self.lower[0].put(message3))
# Three response messages should be created and passed to the lower layer
respond_message1 = _run(self.lower[1].get())
respond_message2 = _run(self.lower[1].get())
respond_message3 = _run(self.lower[1].get())
# Their uuid should be different
self.assertNotEqual(respond_message1.uuid, respond_message2.uuid)
self.assertNotEqual(respond_message2.uuid, respond_message3.uuid)
self.assertNotEqual(respond_message1.uuid, respond_message3.uuid)
# But after chaanging it to be the same for all three messages they should be the same
respond_message2.uuid = respond_message1.uuid
respond_message3.uuid = respond_message2.uuid
self.assertEqual(respond_message1, respond_message2)
self.assertEqual(respond_message1, respond_message3)
self.assertEqual(respond_message3, respond_message2)
inputed_peer = _run(self.business_layer.lower_layer.get_peer_by_id(5))
self.assertEqual(respond_message1.type, Message.PING_RESPONSE)
self.assertEqual(int(respond_message1.receiver.guid), 5)
self.assertEqual(respond_message1.receiver.IP, "127.33.21.22")
self.assertEqual(respond_message1.receiver.port, 3233)
self.assertEqual(respond_message1.receiver.isNAT, False)
self.assertEqual(int(respond_message1.sender.guid), this_peer.id)
self.assertEqual(respond_message1.sender.IP, this_peer.ip)
self.assertEqual(respond_message1.sender.port, this_peer.port)
self.assertEqual(respond_message1.sender.isNAT, this_peer.is_NAT)
self.assertEqual(inputed_peer, another_peer)
async def ping_all(self):
null_peer = Peer(-1, "127.0.0.1", 22, False)
message = putils.create_ping_message(sender=self.get_myself(), receiver=null_peer)
try:
status = await self._propagate_message(message)
return status
except asyncio.CancelledError:
return StatusMessage.FAILURE
def test_connecting_to_wrong_server(self):
self.socket_layer.start_server("127.0.0.1", 8080)
sender = Peer(33, "33.22.11.22", 9992, False)
sender2 = Peer(21, "23.45.67.86", 9393, False)
receiver = Peer(11, '127.0.0.1', 88, False)
mess = putils.create_ping_message(sender, receiver)
mess2 = putils.create_ping_message(sender2, receiver)
address = putils.get_receiver_address(mess)
address2 = putils.get_receiver_address(mess2)
_run(self.higher[0].put((mess.SerializeToString(), address)))
_run(self.higher[0].put((mess2.SerializeToString(), address2)))
self.assertEqual(self.higher[1].qsize(), 0)
# Get the message
log.warning("Stop the server")
status = _run(self.socket_layer.stop_server())
self.assertIs(status, StatusMessage.SUCCESS)
def test_passing_message(self):
"""
P2P layer got some message from higher layer.
It passes it on to the lower layer using queue.
"""
sender = Peer(123, '123.123.123.123', 8022, True)
receiver = Peer(11, '66.22.66.22', 9090, False)
mess = putils.create_ping_message(sender, receiver)
_run(self.higher[0].put(mess))
# wait a while for message to propagate through the layer
_run(asyncio.sleep(0.1))
self.assertEqual(_run(self.lower[1].get()), mess)
def test_passing_message(self):
"""
Message layer got some message from higher layer.
It serializes it.
Then it passes it on to the lower layer using queue.
"""
mess = putils.create_ping_message(self.sender, self.receiver)
address = putils.get_receiver_address(mess)
_run(self.higher[0].put(mess))
# wait a while for message to propagate through the layer
_run(asyncio.sleep(0.1))
self.assertEqual(_run(self.lower[1].get()),
(putils.serialize_message(mess), address))
async def ping(self, target_id):
"""
Sends ping message to peer with given target_id
:param target_id: id of target peer
:return: SUCCESS or FAILURE
"""
peer = await self.lower_layer.get_peer_by_id(target_id)
if peer is None:
return StatusMessage.FAILURE
message = putils.create_ping_message(sender=self.get_myself(), receiver=peer)
try:
status = await self._put_message_on_lower(message)
self._pinged_peers.append((peer, asyncio.ensure_future(self._wait_for_ping_response(peer=peer, timeout=10))))
return status
except asyncio.CancelledError:
return StatusMessage.FAILURE
def test_ping(self):
"""
Business layer creates ping message using protobuf_utils
and passes it on to the lower layer
"""
peer = Peer(2, "127.33.21.22", 3233, False)
_run(self.business_layer.lower_layer._routing_table.insert(peer))
status = _run(self.business_layer.ping(2))
self.assertIs(status, StatusMessage.SUCCESS)
message = _run(self.lower[1].get())
self.assertIsInstance(message, Message)
self.assertEqual(message.type, Message.PING)
ping_message = putils.create_ping_message(
self.business_layer.get_myself(), peer)
ping_message.uuid = message.uuid
self.assertEqual(message, ping_message)
status = _run(self.business_layer.ping(266))
self.assertIs(status, StatusMessage.FAILURE)
def test_get_receiver_address(self):
mess = putils.create_ping_message(self.sender, self.receiver)
self.assertEqual((self.receiver.ip, self.receiver.port),
putils.get_receiver_address(mess))
def test_encoding_and_decoding(self):
mess = putils.create_ping_message(self.sender, self.receiver)
self.assertEqual(
putils.deserialize_message(putils.serialize_message(mess)), mess)
def test_creation_of_ping_message(self):
mess = putils.create_ping_message(self.sender, self.receiver)
self.assertEqual(mess.type, Message.PING)