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_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):
"""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):
"""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_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_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_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()
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()
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()
