async def test_receive_raises_struct_error(self):
"""Test the case when a receive raises a struct error."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
with unittest.mock.patch.object(tcp_client.logger,
"debug") as mock_logger:
with unittest.mock.patch.object(tcp_client,
"_recv",
side_effect=struct.error):
task = asyncio.ensure_future(tcp_client.receive())
await asyncio.sleep(0.1)
mock_logger.assert_called_with("Struct error: ")
assert task.result() is None
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_raises_exception(self, caplog):
"""Test the case when a receive raises a generic exception."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
await asyncio.sleep(0.1)
with caplog.at_level(
logging.DEBUG,
"aea.packages.fetchai.connections.tcp.tcp_server"):
with unittest.mock.patch(
"asyncio.wait",
side_effect=Exception("generic exception")):
result = await tcp_server.receive()
assert result is None
assert "Error in the receiving loop: generic exception" in caplog.text
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_cancelled(self):
"""Test that cancelling a receive task works correctly."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
with unittest.mock.patch.object(tcp_client.logger,
"debug") as mock_logger:
task = asyncio.ensure_future(tcp_client.receive())
await asyncio.sleep(0.1)
task.cancel()
await asyncio.sleep(0.1)
mock_logger.assert_called_with(
"[{}] Read cancelled.".format("address_client"))
assert task.result() is None
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_raises_struct_error(self, caplog):
"""Test the case when a receive raises a struct error."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
with caplog.at_level(
logging.DEBUG,
"aea.packages.fetchai.connections.tcp.tcp_client"):
with unittest.mock.patch.object(tcp_client,
"_recv",
side_effect=struct.error):
task = asyncio.ensure_future(tcp_client.receive())
await asyncio.sleep(0.1)
assert "Struct error: " in caplog.text
assert task.result() is None
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_raises_exception(self):
"""Test the case when a receive raises a generic exception."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
await asyncio.sleep(0.1)
with unittest.mock.patch.object(tcp_server.logger,
"error") as mock_logger:
with unittest.mock.patch(
"asyncio.wait",
side_effect=Exception("generic exception")):
result = await tcp_server.receive()
assert result is None
mock_logger.assert_any_call(
"Error in the receiving loop: generic exception")
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_raises_exception(self):
"""Test the case when a receive raises a generic exception."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
with pytest.raises(Exception, match="generic exception"):
with unittest.mock.patch.object(
tcp_client,
"_recv",
side_effect=Exception("generic exception")):
task = asyncio.ensure_future(tcp_client.receive())
await asyncio.sleep(0.1)
assert task.result() is None
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_receive_cancelled(self, caplog):
"""Test that cancelling a receive task works correctly."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection(
"address_server",
"127.0.0.1",
port,
)
tcp_client = _make_tcp_client_connection(
"address_client",
"127.0.0.1",
port,
)
await tcp_server.connect()
await tcp_client.connect()
with caplog.at_level(
logging.DEBUG,
"aea.packages.fetchai.connections.tcp.tcp_client"):
task = asyncio.ensure_future(tcp_client.receive())
await asyncio.sleep(0.1)
task.cancel()
await asyncio.sleep(0.1)
assert "[{}] Read cancelled.".format(
"address_client") in caplog.text
assert task.result() is None
await tcp_client.disconnect()
await tcp_server.disconnect()
async def test_disconnect_when_already_disconnected():
"""Test that disconnecting a connection already disconnected works correctly."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
with unittest.mock.patch.object(tcp_connection.logger, "warning") as mock_logger:
await tcp_connection.disconnect()
mock_logger.assert_called_with("Connection already disconnected.")
async def test_disconnect_when_already_disconnected(caplog):
"""Test that disconnecting a connection already disconnected works correctly."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
with caplog.at_level(logging.WARNING,
"aea.packages.fetchai.connections.tcp"):
await tcp_connection.disconnect()
assert "Connection already disconnected." in caplog.text
async def test_connect_raises_exception():
"""Test the case that a connection attempt raises an exception."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
with unittest.mock.patch.object(tcp_connection.logger, "error") as mock_logger:
with unittest.mock.patch.object(
tcp_connection, "setup", side_effect=Exception("error during setup")
):
await tcp_connection.connect()
mock_logger.assert_called_with("error during setup")
async def test_connect_twice():
"""Test that connecting twice the tcp connection works correctly."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
await tcp_connection.connect()
await asyncio.sleep(0.1)
with unittest.mock.patch.object(tcp_connection.logger, "warning") as mock_logger:
await tcp_connection.connect()
mock_logger.assert_called_with("Connection already set up.")
await tcp_connection.disconnect()
async def test_send_to_unknown_destination():
"""Test that a message to an unknown destination logs an error."""
address = "address"
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
envelope = Envelope(
to="non_existing_destination",
sender="address",
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
with unittest.mock.patch.object(tcp_connection.logger,
"error") as mock_logger:
await tcp_connection.send(envelope)
mock_logger.assert_called_with("[{}]: Cannot send envelope {}".format(
address, envelope))
async def test_send_to_unknown_destination(caplog):
"""Test that a message to an unknown destination logs an error."""
address = "address"
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
envelope = Envelope(
to="non_existing_destination",
sender="address",
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
with caplog.at_level(logging.ERROR,
"aea.packages.fetchai.connections.tcp"):
await tcp_connection.send(envelope)
assert "[{}]: Cannot send envelope {}".format(address,
envelope) in caplog.text
async def test_connect_twice(caplog):
"""Test that connecting twice the tcp connection works correctly."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
loop = asyncio.get_event_loop()
tcp_connection.loop = loop
await tcp_connection.connect()
await asyncio.sleep(0.1)
with caplog.at_level(logging.WARNING,
"aea.packages.fetchai.connections.tcp"):
await tcp_connection.connect()
assert "Connection already set up." in caplog.text
await tcp_connection.disconnect()
async def test_connect_raises_exception(caplog):
"""Test the case that a connection attempt raises an exception."""
port = get_unused_tcp_port()
tcp_connection = _make_tcp_server_connection("address", "127.0.0.1", port)
loop = asyncio.get_event_loop()
tcp_connection.loop = loop
with caplog.at_level(logging.ERROR,
"aea.packages.fetchai.connections.tcp"):
with unittest.mock.patch.object(
tcp_connection,
"setup",
side_effect=Exception("error during setup")):
await tcp_connection.connect()
assert "error during setup" in caplog.text
async def test_send_cancelled():
"""Test that cancelling a send works correctly."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection("address_server", "127.0.0.1", port)
tcp_client = _make_tcp_client_connection("address_client", "127.0.0.1", port)
await tcp_server.connect()
await tcp_client.connect()
with unittest.mock.patch.object(
tcp_client._writer, "drain", side_effect=CancelledError
):
envelope = Envelope(
to="address_client",
sender="address_server",
protocol_specification_id=DefaultMessage.protocol_specification_id,
message=b"",
)
await tcp_client.send(envelope)
await tcp_client.disconnect()
await tcp_server.disconnect()
def setup_class(cls):
"""Set up the test class."""
cls.host = "127.0.0.1"
cls.port = get_unused_tcp_port()
cls.server_addr = "server_addr"
cls.client_addr_1 = "client_addr_1"
cls.client_addr_2 = "client_addr_2"
cls.server_conn = _make_tcp_server_connection(
cls.server_addr,
cls.host,
cls.port,
)
cls.client_conn_1 = _make_tcp_client_connection(
cls.client_addr_1,
cls.host,
cls.port,
)
cls.client_conn_2 = _make_tcp_client_connection(
cls.client_addr_2,
cls.host,
cls.port,
)
cls.server_multiplexer = Multiplexer([cls.server_conn])
cls.client_1_multiplexer = Multiplexer([cls.client_conn_1])
cls.client_2_multiplexer = Multiplexer([cls.client_conn_2])
assert not cls.server_conn.is_connected
assert not cls.client_conn_1.is_connected
assert not cls.client_conn_2.is_connected
cls.server_multiplexer.connect()
cls.client_1_multiplexer.connect()
cls.client_2_multiplexer.connect()
