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()