def test_outbox_empty(): """Test thet the outbox queue is empty.""" multiplexer = Multiplexer([DummyConnection()]) multiplexer.connect() outbox = OutBox(multiplexer) assert outbox.empty(), "The outbox is not empty" multiplexer.disconnect()
def test_multiplexer_connect_one_raises_error_many_connections(): """Test the case when the multiplexer raises an exception while attempting the connection of one connection.""" node = LocalNode() tmpdir = Path(tempfile.mkdtemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = OEFLocalConnection( "my_addr", node, connection_id=PublicId("fetchai", "local", "0.1.0") ) connection_2 = StubConnection( input_file_path, output_file_path, connection_id=PublicId("fetchai", "stub", "0.1.0"), ) connection_3 = DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID) multiplexer = Multiplexer([connection_1, connection_2, connection_3]) assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert not connection_3.connection_status.is_connected with unittest.mock.patch.object(connection_3, "connect", side_effect=Exception): with pytest.raises( AEAConnectionError, match="Failed to connect the multiplexer." ): multiplexer.connect() assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert not connection_3.connection_status.is_connected shutil.rmtree(tmpdir)
def test_connect_twice_with_loop(): """Test that connecting twice the multiplexer behaves correctly.""" running_loop = asyncio.new_event_loop() thread_loop = Thread(target=running_loop.run_forever) thread_loop.start() try: multiplexer = Multiplexer( [_make_dummy_connection()], loop=running_loop, ) with unittest.mock.patch.object(aea.mail.base.logger, "debug") as mock_logger_debug: assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected mock_logger_debug.assert_called_with( "Multiplexer already connected.") multiplexer.disconnect() running_loop.call_soon_threadsafe(running_loop.stop) finally: thread_loop.join()
def test_send_message_no_supported_protocol(): """Test the case when we send an envelope with a specific connection that does not support the protocol.""" with LocalNode() as node: address_1 = "address_1" public_id = PublicId.from_str("fetchai/my_private_protocol:0.1.0") connection_1 = _make_local_connection( address_1, node, restricted_to_protocols={public_id}, excluded_protocols={public_id}, ) multiplexer = Multiplexer([connection_1]) multiplexer.connect() with mock.patch.object(aea.mail.base.logger, "warning") as mock_logger_warning: protocol_id = UNKNOWN_PROTOCOL_PUBLIC_ID envelope = Envelope( to=address_1, sender=address_1, protocol_id=protocol_id, message=b"some bytes", ) multiplexer.put(envelope) time.sleep(0.5) mock_logger_warning.assert_called_with( "Connection {} cannot handle protocol {}. Cannot send the envelope." .format(connection_1.connection_id, protocol_id)) multiplexer.disconnect()
def test_outbox_put(): """Tests that an envelope is putted into the queue.""" msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) message_bytes = DefaultSerializer().encode(msg) multiplexer = Multiplexer( [DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)]) outbox = OutBox(multiplexer) inbox = InBox(multiplexer) multiplexer.connect() envelope = Envelope( to="Agent1", sender="Agent0", protocol_id=DefaultMessage.protocol_id, message=message_bytes, ) outbox.put(envelope) time.sleep(0.5) assert not inbox.empty( ), "Inbox must not be empty after putting an envelope" multiplexer.disconnect()
def test_multiplexer_connect_all_raises_error(): """Test the case when the multiplexer raises an exception while connecting.""" multiplexer = Multiplexer([DummyConnection()]) with unittest.mock.patch.object(multiplexer, "_connect_all", side_effect=Exception): with pytest.raises(AEAConnectionError, match="Failed to connect the multiplexer."): multiplexer.connect()
def test_multiplexer_disconnect_one_raises_error_many_connections(): """Test the case when the multiplexer raises an exception while attempting the disconnection of one connection.""" with LocalNode() as node: tmpdir = Path(tempfile.mktemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = OEFLocalConnection("my_pbk", node) connection_2 = StubConnection(input_file_path, output_file_path) connection_3 = DummyConnection() multiplexer = Multiplexer([connection_1, connection_2, connection_3]) assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert not connection_3.connection_status.is_connected multiplexer.connect() assert connection_1.connection_status.is_connected assert connection_2.connection_status.is_connected assert connection_3.connection_status.is_connected with unittest.mock.patch.object(connection_3, "disconnect", side_effect=Exception): # with pytest.raises(AEAConnectionError, match="Failed to disconnect the multiplexer."): multiplexer.disconnect() # TODO is this what we want? assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert connection_3.connection_status.is_connected shutil.rmtree(tmpdir)
def test_multiplexer_connect_one_raises_error_many_connections(): """Test the case when the multiplexer raises an exception while attempting the connection of one connection.""" node = LocalNode() tmpdir = Path(tempfile.mkdtemp()) d = tmpdir / "test_stub" d.mkdir(parents=True) input_file_path = d / "input_file.csv" output_file_path = d / "input_file.csv" connection_1 = _make_local_connection("my_addr", node) connection_2 = _make_stub_connection(input_file_path, output_file_path) connection_3 = _make_dummy_connection() multiplexer = Multiplexer([connection_1, connection_2, connection_3]) assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert not connection_3.connection_status.is_connected with unittest.mock.patch.object(connection_3, "connect", side_effect=Exception): with pytest.raises(AEAConnectionError, match="Failed to connect the multiplexer."): multiplexer.connect() assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected assert not connection_3.connection_status.is_connected try: shutil.rmtree(tmpdir) except OSError as e: logger.warning("Couldn't delete {}".format(tmpdir)) logger.exception(e)
def test_multiplexer(): """Tests if the multiplexer is connected.""" with LocalNode() as node: public_key_1 = "public_key_1" multiplexer = Multiplexer([OEFLocalConnection(public_key_1, node)]) multiplexer.connect() assert multiplexer.is_connected, "Mailbox cannot connect to the specific Connection(OEFLocalConnection)" multiplexer.disconnect()
def test_outbox_empty(): """Test thet the outbox queue is empty.""" multiplexer = Multiplexer( [DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)]) multiplexer.connect() outbox = OutBox(multiplexer) assert outbox.empty(), "The outbox is not empty" multiplexer.disconnect()
def test_multiple_connection(): """Test that we can send a message with two different connections.""" with LocalNode() as node: address_1 = "address_1" address_2 = "address_2" connection_1_id = PublicId.from_str("author/local_1:0.1.0") connection_2_id = PublicId.from_str("author/local_2:0.1.0") connection_1 = OEFLocalConnection(node, address=address_1, connection_id=connection_1_id) connection_2 = OEFLocalConnection(node, address=address_2, connection_id=connection_2_id) multiplexer = Multiplexer([connection_1, connection_2]) assert not connection_1.connection_status.is_connected assert not connection_2.connection_status.is_connected multiplexer.connect() assert connection_1.connection_status.is_connected assert connection_2.connection_status.is_connected message = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) envelope_from_1_to_2 = Envelope( to=address_2, sender=address_1, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(message), context=EnvelopeContext(connection_id=connection_1_id), ) multiplexer.put(envelope_from_1_to_2) actual_envelope = multiplexer.get(block=True, timeout=2.0) assert envelope_from_1_to_2 == actual_envelope envelope_from_2_to_1 = Envelope( to=address_1, sender=address_2, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(message), context=EnvelopeContext(connection_id=connection_2_id), ) multiplexer.put(envelope_from_2_to_1) actual_envelope = multiplexer.get(block=True, timeout=2.0) assert envelope_from_2_to_1 == actual_envelope multiplexer.disconnect()
def test_connection(self): """Test that an OEF connection can be established to the OEF.""" crypto = DefaultCrypto() connection = OEFConnection(crypto.public_key, oef_addr="127.0.0.1", oef_port=10000) multiplexer = Multiplexer([connection]) multiplexer.connect() multiplexer.disconnect()
def test_connection(self): """Test that an OEF connection can be established to the OEF.""" crypto = FetchAICrypto() connection = _make_oef_connection( crypto.address, oef_addr="127.0.0.1", oef_port=10000, ) multiplexer = Multiplexer([connection]) multiplexer.connect() multiplexer.disconnect()
def test_connection(self): """Test that an OEF connection can be established to the OEF.""" connection = _make_oef_connection( FETCHAI_ADDRESS_ONE, oef_addr="127.0.0.1", oef_port=10000, ) multiplexer = Multiplexer([connection]) multiplexer.connect() multiplexer.disconnect()
def test_multiplexer(): """Tests if the multiplexer is connected.""" with LocalNode() as node: address_1 = "address_1" oef_local_connection = _make_local_connection(address_1, node) multiplexer = Multiplexer([oef_local_connection]) multiplexer.connect() assert ( multiplexer.is_connected ), "Mailbox cannot connect to the specific Connection(OEFLocalConnection)" multiplexer.disconnect()
async def test_receiving_loop_terminated(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([DummyConnection()]) multiplexer.connect() with unittest.mock.patch.object(aea.mail.base.logger, "debug") as mock_logger_debug: multiplexer.connection_status.is_connected = False await multiplexer._receiving_loop() mock_logger_debug.assert_called_with("Receiving loop terminated.") multiplexer.connection_status.is_connected = True multiplexer.disconnect()
def test_connect_twice(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer([DummyConnection()]) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect()
def test_connection(): """Test that two OEF local connection can connect to a local node.""" with LocalNode() as node: multiplexer1 = Multiplexer([OEFLocalConnection("multiplexer1", node)]) multiplexer2 = Multiplexer([OEFLocalConnection("multiplexer2", node)]) multiplexer1.connect() multiplexer2.connect() multiplexer1.disconnect() multiplexer2.disconnect()
async def test_sending_loop_cancelled(): """Test the case when the sending loop is cancelled.""" multiplexer = Multiplexer([DummyConnection(connection_id="dummy")]) multiplexer.connect() with unittest.mock.patch.object(aea.mail.base.logger, "debug") as mock_logger_debug: multiplexer._send_loop_task.cancel() await asyncio.sleep(0.1) mock_logger_debug.assert_called_with("Sending loop cancelled.") multiplexer.disconnect()
async def test_receiving_loop_raises_exception(): """Test the case when an error occurs when a receive is started.""" connection = DummyConnection(connection_id="dummy") multiplexer = Multiplexer([connection]) with unittest.mock.patch("asyncio.wait", side_effect=Exception("a weird error.")): with unittest.mock.patch.object(aea.mail.base.logger, "error") as mock_logger_error: multiplexer.connect() time.sleep(0.1) mock_logger_error.assert_called_with("Error in the receiving loop: a weird error.") multiplexer.disconnect()
def test_connection(self): """Test that an OEF connection can be established to the OEF.""" crypto = FetchAICrypto() connection = OEFConnection( crypto.address, oef_addr="127.0.0.1", oef_port=10000, connection_id=PublicId("fetchai", "oef", "0.1.0"), ) multiplexer = Multiplexer([connection]) multiplexer.connect() multiplexer.disconnect()
def test_connect_twice(): """Test that connecting twice the multiplexer behaves correctly.""" multiplexer = Multiplexer( [DummyConnection(connection_id=DUMMY_CONNECTION_PUBLIC_ID)] ) assert not multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.connect() assert multiplexer.connection_status.is_connected multiplexer.disconnect()
async def test_send_envelope_with_non_registered_connection(): """Test that sending an envelope with an unregistered connection raises an exception.""" connection = DummyConnection(connection_id="dummy") multiplexer = Multiplexer([connection]) multiplexer.connect() envelope = Envelope(to="", sender="", protocol_id="default", message=b"", context=EnvelopeContext(connection_id="this_is_an_unexisting_connection_id")) with pytest.raises(AEAConnectionError, match="No connection registered with id:.*"): await multiplexer._send(envelope) multiplexer.disconnect()
def test_multiplexer_disconnect_all_raises_error(): """Test the case when the multiplexer raises an exception while disconnecting.""" multiplexer = Multiplexer([DummyConnection()]) multiplexer.connect() assert multiplexer.connection_status.is_connected with unittest.mock.patch.object(multiplexer, "_disconnect_all", side_effect=Exception): with pytest.raises(AEAConnectionError, match="Failed to disconnect the multiplexer."): multiplexer.disconnect() # TODO is this what we want? assert multiplexer.connection_status.is_connected
def test_outbox_put_message(): """Tests that an envelope is created from the message is in the queue.""" msg = DefaultMessage(type=DefaultMessage.Type.BYTES, content=b"hello") message_bytes = DefaultSerializer().encode(msg) multiplexer = Multiplexer([DummyConnection()]) outbox = OutBox(multiplexer) inbox = InBox(multiplexer) multiplexer.connect() outbox.put_message("Agent1", "Agent0", DefaultMessage.protocol_id, message_bytes) time.sleep(0.5) assert not inbox.empty( ), "Inbox will not be empty after putting a message." multiplexer.disconnect()
def test_send_envelope_error_is_logged_by_send_loop(): """Test that the AEAConnectionError in the '_send' method is logged by the '_send_loop'.""" connection = DummyConnection(connection_id="dummy") multiplexer = Multiplexer([connection]) multiplexer.connect() envelope = Envelope(to="", sender="", protocol_id="default", message=b"", context=EnvelopeContext(connection_id="this_is_an_unexisting_connection_id")) with unittest.mock.patch.object(aea.mail.base.logger, "error") as mock_logger_error: multiplexer.put(envelope) time.sleep(0.1) mock_logger_error.assert_called_with("No connection registered with id: this_is_an_unexisting_connection_id.") multiplexer.disconnect()
def test_multiplexer(): """Tests if the multiplexer is connected.""" with LocalNode() as node: address_1 = "address_1" multiplexer = Multiplexer([ OEFLocalConnection(address_1, node, connection_id=PublicId("fetchai", "local", "0.1.0")) ]) multiplexer.connect() assert ( multiplexer.is_connected ), "Mailbox cannot connect to the specific Connection(OEFLocalConnection)" multiplexer.disconnect()
def setup_class(cls): """Set the test up""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() # os.chdir(cls.t) port_relay_1 = DEFAULT_PORT + 10 cls.connection_relay_1 = _make_libp2p_connection(port_relay_1) cls.multiplexer_relay_1 = Multiplexer([cls.connection_relay_1]) cls.multiplexer_relay_1.connect() port_relay_2 = DEFAULT_PORT + 100 cls.connection_relay_2 = _make_libp2p_connection(port_relay_2) cls.multiplexer_relay_2 = Multiplexer([cls.connection_relay_2]) cls.multiplexer_relay_2.connect() time.sleep(2) relay_peer_1 = cls.connection_relay_1.node.multiaddrs relay_peer_2 = cls.connection_relay_2.node.multiaddrs cls.connections = [] cls.multiplexers = [] port = port_relay_1 for _ in range(int(DEFAULT_NET_SIZE / 2)): port += 1 conn = _make_libp2p_connection( port=port, relay=False, entry_peers=relay_peer_1 ) mux = Multiplexer([conn]) cls.connections.append(conn) cls.multiplexers.append(mux) mux.connect() port = port_relay_2 for _ in range(int(DEFAULT_NET_SIZE / 2)): port += 1 conn = _make_libp2p_connection( port=port, relay=False, entry_peers=relay_peer_2 ) mux = Multiplexer([conn]) cls.connections.append(conn) cls.multiplexers.append(mux) mux.connect() time.sleep(2)
def test_outbox_put(): """Tests that an envelope is putted into the queue.""" msg = DefaultMessage(type=DefaultMessage.Type.BYTES, content=b"hello") message_bytes = DefaultSerializer().encode(msg) multiplexer = Multiplexer([DummyConnection()]) outbox = OutBox(multiplexer) inbox = InBox(multiplexer) multiplexer.connect() envelope = Envelope(to="Agent1", sender="Agent0", protocol_id=DefaultMessage.protocol_id, message=message_bytes) outbox.put(envelope) time.sleep(0.5) assert not inbox.empty( ), "Inbox must not be empty after putting an envelope" multiplexer.disconnect()
def test_connection(): """Test that two OEF local connection can connect to a local node.""" with LocalNode() as node: local_id_1 = PublicId("fetchai", "local1", "0.1.0") local_id_2 = PublicId("fetchai", "local2", "0.1.0") multiplexer1 = Multiplexer([ OEFLocalConnection("multiplexer1", node, connection_id=local_id_1) ]) multiplexer2 = Multiplexer([ OEFLocalConnection("multiplexer2", node, connection_id=local_id_2) ]) multiplexer1.connect() multiplexer2.connect() multiplexer1.disconnect() multiplexer2.disconnect()