def test_no_handlers_registered(): """Test no handlers are registered for message processing.""" agent_name = "MyAgent" builder = AEABuilder() private_key_path = os.path.join(CUR_PATH, "data", DEFAULT_PRIVATE_KEY_FILE) builder.set_name(agent_name) builder.add_private_key(DEFAULT_LEDGER, private_key_path) # local_connection_id = PublicId.from_str("fetchai/stub:0.4.0") # builder.set_default_connection(local_connection_id) aea = builder.build() with patch.object(aea._get_error_handler().context._logger, "warning") as mock_logger: msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = aea.identity.address envelope = Envelope( to=aea.identity.address, sender=aea.identity.address, protocol_id=DefaultMessage.protocol_id, message=msg, ) with patch.object(aea.filter, "get_active_handlers", return_value=[]): aea._handle(envelope) mock_logger.assert_any_call( f"Cannot handle envelope: no active handler registered for the protocol_id='{DefaultMessage.protocol_id}'." )
def _handle_unidentified_dialogue(self, fipa_msg: FipaMessage) -> None: """ Handle an unidentified dialogue. Respond to the sender with a default message containing the appropriate error information. :param msg: the message :return: None """ self.context.logger.info( "received invalid fipa message={}, unidentified dialogue.".format( fipa_msg)) default_dialogues = cast(DefaultDialogues, self.context.default_dialogues) default_msg = DefaultMessage( performative=DefaultMessage.Performative.ERROR, dialogue_reference=default_dialogues. new_self_initiated_dialogue_reference(), error_code=DefaultMessage.ErrorCode.INVALID_DIALOGUE, error_msg="Invalid dialogue.", error_data={"fipa_message": fipa_msg.encode()}, ) default_msg.counterparty = fipa_msg.counterparty assert (default_dialogues.update(default_msg) is not None), "DefaultDialogue not constructed." self.context.outbox.put_message(message=default_msg)
def test_reception_a(self): """Test that the connection receives what has been enqueued in the input file.""" msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = "any" expected_envelope = Envelope( to="any", sender="any", protocol_id=DefaultMessage.protocol_id, message=msg, ) with open(self.input_file_path, "ab+") as f: write_envelope(expected_envelope, f) actual_envelope = self.multiplexer.get(block=True, timeout=3.0) assert expected_envelope.to == actual_envelope.to assert expected_envelope.sender == actual_envelope.sender assert expected_envelope.protocol_id == actual_envelope.protocol_id msg = DefaultMessage.serializer.decode(actual_envelope.message) msg.counterparty = actual_envelope.to assert expected_envelope.message == msg
def test_outbox_put(): """Tests that an envelope is putted into the queue.""" agent_address = "Agent0" receiver_address = "Agent1" msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = receiver_address dummy_connection = _make_dummy_connection() multiplexer = Multiplexer([dummy_connection]) outbox = OutBox(multiplexer, agent_address) inbox = InBox(multiplexer) multiplexer.connect() envelope = Envelope( to=receiver_address, sender=agent_address, protocol_id=DefaultMessage.protocol_id, message=msg, ) outbox.put(envelope) time.sleep(0.5) assert not inbox.empty(), "Inbox must not be empty after putting an envelope" multiplexer.disconnect()
def send_unsupported_protocol(self, envelope: Envelope) -> None: """ Handle the received envelope in case the protocol is not supported. :param envelope: the envelope :return: None """ self.context.logger.warning( "Unsupported protocol: {}. You might want to add a handler for this protocol." .format(envelope.protocol_id)) encoded_protocol_id = base64.b85encode( str.encode(str(envelope.protocol_id))) encoded_envelope = base64.b85encode(envelope.encode()) reply = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.ERROR, error_code=DefaultMessage.ErrorCode.UNSUPPORTED_PROTOCOL, error_msg="Unsupported protocol.", error_data={ "protocol_id": encoded_protocol_id, "envelope": encoded_envelope, }, ) reply.counterparty = envelope.sender reply.sender = self.context.agent_address self.context.outbox.put_message(message=reply)
def send_unsupported_skill(self, envelope: Envelope) -> None: """ Handle the received envelope in case the skill is not supported. :param envelope: the envelope :return: None """ if envelope.skill_id is None: self.context.logger.warning( "Cannot handle envelope: no active handler registered for the protocol_id='{}'." .format(envelope.protocol_id)) else: self.context.logger.warning( "Cannot handle envelope: no active handler registered for the protocol_id='{}' and skill_id='{}'." .format(envelope.protocol_id, envelope.skill_id)) encoded_envelope = base64.b85encode(envelope.encode()) reply = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.ERROR, error_code=DefaultMessage.ErrorCode.UNSUPPORTED_SKILL, error_msg="Unsupported skill.", error_data={"envelope": encoded_envelope}, ) reply.counterparty = envelope.sender reply.sender = self.context.agent_address self.context.outbox.put_message(message=reply)
def _send_default_message(self, content: Dict) -> None: """ Send a default message to Alice. :param content: the content of the message. :return: None """ # context strategy = cast(FaberStrategy, self.context.strategy) default_dialogues = cast(DefaultDialogues, self.context.default_dialogues) # default message message = DefaultMessage( dialogue_reference=default_dialogues.new_self_initiated_dialogue_reference(), performative=DefaultMessage.Performative.BYTES, content=json.dumps(content).encode("utf-8"), ) message.counterparty = strategy.alice_aea_address # default dialogue default_dialogue = default_dialogues.update(message) assert ( default_dialogue is not None ), "faber -> http_handler -> _send_default_message(): something went wrong when sending a default message." # send context = EnvelopeContext(connection_id=P2P_CONNECTION_PUBLIC_ID) self.context.outbox.put_message(message=message, context=context)
def test_error_handler_is_not_set(): """Test stop on no error handler presents.""" agent_name = "my_agent" private_key_path = os.path.join(CUR_PATH, "data", DEFAULT_PRIVATE_KEY_FILE) wallet = Wallet({DEFAULT_LEDGER: private_key_path}) identity = Identity(agent_name, address=wallet.addresses[DEFAULT_LEDGER]) resources = Resources() context_namespace = {"key1": 1, "key2": 2} agent = AEA(identity, wallet, resources, **context_namespace) msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = agent.identity.address envelope = Envelope( to=agent.identity.address, sender=agent.identity.address, protocol_id=DefaultMessage.protocol_id, message=msg, ) with patch.object(agent, "stop") as mocked_stop: agent._handle(envelope) mocked_stop.assert_called()
def _send_message(self, content: Dict) -> None: # message & envelope message = DefaultMessage( performative=DefaultMessage.Performative.BYTES, content=json.dumps(content).encode("utf-8"), ) message.counterparty = self.alice_id context = EnvelopeContext(connection_id=OEF_CONNECTION_PUBLIC_ID) self.context.outbox.put_message(message=message, context=context)
def test_react(): """Tests income messages.""" with LocalNode() as node: agent_name = "MyAgent" private_key_path = os.path.join(CUR_PATH, "data", "fet_private_key.txt") wallet = Wallet({FETCHAI: private_key_path}) identity = Identity(agent_name, address=wallet.addresses[FETCHAI]) ledger_apis = LedgerApis({}, FETCHAI) connection = OEFLocalConnection( identity.address, node, connection_id=LOCAL_CONNECTION_PUBLIC_ID) connections = [connection] resources = Resources(str(Path(CUR_PATH, "data", "dummy_aea"))) msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = identity.address message_bytes = DefaultSerializer().encode(msg) envelope = Envelope( to=identity.address, sender=identity.address, protocol_id=DefaultMessage.protocol_id, message=message_bytes, ) agent = AEA(identity, connections, wallet, ledger_apis, resources, is_programmatic=False) t = Thread(target=agent.start) try: t.start() time.sleep(1.0) agent.outbox.put(envelope) time.sleep(2.0) default_protocol_public_id = DefaultMessage.protocol_id dummy_skill_public_id = DUMMY_SKILL_PUBLIC_ID handler = agent.resources.handler_registry.fetch_by_protocol_and_skill( default_protocol_public_id, dummy_skill_public_id) assert handler is not None, "Handler is not set." assert (msg in handler.handled_messages ), "The message is not inside the handled_messages." except Exception: raise finally: agent.stop() t.join()
def test_react(): """Tests income messages.""" with LocalNode() as node: agent_name = "MyAgent" private_key_path = os.path.join(CUR_PATH, "data", "fet_private_key.txt") builder = AEABuilder() builder.set_name(agent_name) builder.add_private_key(FETCHAI, private_key_path) builder.add_protocol( Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search")) builder.add_connection( Path(ROOT_DIR, "packages", "fetchai", "connections", "local")) builder.set_default_connection( PublicId.from_str("fetchai/local:0.1.0")) builder.add_skill(Path(CUR_PATH, "data", "dummy_skill")) agent = builder.build( connection_ids=[PublicId.from_str("fetchai/local:0.1.0")]) # This is a temporary workaround to feed the local node to the OEF Local connection # TODO remove it. list(agent._connections)[0]._local_node = node msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = agent.identity.address message_bytes = DefaultSerializer().encode(msg) envelope = Envelope( to=agent.identity.address, sender=agent.identity.address, protocol_id=DefaultMessage.protocol_id, message=message_bytes, ) with run_in_thread(agent.start, timeout=20, on_exit=agent.stop): wait_for_condition( lambda: agent._main_loop and agent._main_loop.is_running, timeout=10) agent.outbox.put(envelope) default_protocol_public_id = DefaultMessage.protocol_id dummy_skill_public_id = DUMMY_SKILL_PUBLIC_ID handler = agent.resources.get_handler(default_protocol_public_id, dummy_skill_public_id) assert handler is not None, "Handler is not set." wait_for_condition( lambda: msg in handler.handled_messages, timeout=10, error_msg="The message is not inside the handled_messages.", ) agent.stop()
def test_react(): """Tests income messages.""" with LocalNode() as node: agent_name = "MyAgent" private_key_path = os.path.join(CUR_PATH, "data", "fet_private_key.txt") builder = AEABuilder() builder.set_name(agent_name) builder.add_private_key(FETCHAI, private_key_path) builder.add_connection( Path(ROOT_DIR, "packages", "fetchai", "connections", "local")) builder.add_skill(Path(CUR_PATH, "data", "dummy_skill")) agent = builder.build( connection_ids=[PublicId.from_str("fetchai/local:0.1.0")]) # This is a temporary workaround to feed the local node to the OEF Local connection # TODO remove it. list(agent._connections)[0]._local_node = node msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg.counterparty = agent.identity.address message_bytes = DefaultSerializer().encode(msg) envelope = Envelope( to=agent.identity.address, sender=agent.identity.address, protocol_id=DefaultMessage.protocol_id, message=message_bytes, ) t = Thread(target=agent.start) try: t.start() time.sleep(1.0) agent.outbox.put(envelope) time.sleep(2.0) default_protocol_public_id = DefaultMessage.protocol_id dummy_skill_public_id = DUMMY_SKILL_PUBLIC_ID handler = agent.resources.get_handler(default_protocol_public_id, dummy_skill_public_id) assert handler is not None, "Handler is not set." assert (msg in handler.handled_messages ), "The message is not inside the handled_messages." except Exception: raise finally: agent.stop() t.join()
def test_envelope_message_bytes(): """Test the property Envelope.message_bytes.""" message = DefaultMessage(DefaultMessage.Performative.BYTES, content=b"message") envelope = Envelope( to="to", sender="sender", protocol_id=PublicId("author", "name", "0.1.0"), message=message, ) expected_message_bytes = message.encode() actual_message_bytes = envelope.message_bytes assert expected_message_bytes == actual_message_bytes
async def test_outbox_negative(): """Test InBox OutBox objects.""" connection_1 = _make_dummy_connection() connections = [connection_1] multiplexer = AsyncMultiplexer(connections, loop=asyncio.get_event_loop()) msg = DefaultMessage(performative=DefaultMessage.Performative.BYTES, content=b"",) context = EnvelopeContext(connection_id=connection_1.connection_id) envelope = Envelope( to="to", sender="sender", protocol_id=msg.protocol_id, message=b"", context=context, ) try: await multiplexer.connect() outbox = OutBox(multiplexer, "default_address") assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put(envelope) assert ( str(execinfo.value) == "Only Message type allowed in envelope message field when putting into outbox." ) assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put_message("") assert str(execinfo.value) == "Provided message not of type Message." assert outbox.empty() with pytest.raises(ValueError) as execinfo: outbox.put_message(msg) assert ( str(execinfo.value) == "Provided message has message.counterparty not set." ) assert outbox.empty() msg.counterparty = "to" with pytest.raises(ValueError) as execinfo: outbox.put_message(msg) assert str(execinfo.value) == "Provided message has message.sender not set." finally: await multiplexer.disconnect()
def test_check_consistency_raises_exception_when_type_not_recognized(): """Test that we raise exception when the type of the message is not recognized.""" message = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) # mock the __eq__ method such that any kind of matching is going to fail. with mock.patch.object(DefaultMessage.Performative, "__eq__", return_value=False): assert not message._is_consistent()
def on_dialogue_error( self, answer_id: int, dialogue_id: int, origin: Address ) -> None: """ On dialogue error event handler. :param answer_id: the answer id. :param dialogue_id: the dialogue id. :param origin: the message sender. :return: None """ assert self.in_queue is not None assert self.loop is not None msg = DefaultMessage( performative=DefaultMessage.Performative.ERROR, dialogue_reference=(str(answer_id), ""), target=TARGET, message_id=MESSAGE_ID, error_code=DefaultMessage.ErrorCode.INVALID_DIALOGUE, error_msg="Destination not available", error_data={}, # TODO: add helper info ) msg_bytes = DefaultSerializer().encode(msg) envelope = Envelope( to=self.address, sender=DEFAULT_OEF, protocol_id=OefSearchMessage.protocol_id, message=msg_bytes, ) asyncio.run_coroutine_threadsafe( self.in_queue.put(envelope), self.loop ).result()
def test_envelope_echoed_back_node_agent(self): addr_1 = self.connection_client_1.address addr_n = self.connection_node_2.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) original_envelope = Envelope( to=addr_n, sender=addr_1, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(msg), ) self.multiplexer_client_1.put(original_envelope) delivered_envelope = self.multiplexer_node_2.get(block=True, timeout=10) assert delivered_envelope is not None delivered_envelope.to = addr_1 delivered_envelope.sender = addr_n self.multiplexer_node_2.put(delivered_envelope) echoed_envelope = self.multiplexer_client_1.get(block=True, timeout=5) assert echoed_envelope is not None assert echoed_envelope.to == original_envelope.sender assert delivered_envelope.sender == original_envelope.to assert delivered_envelope.protocol_id == original_envelope.protocol_id assert delivered_envelope.message == original_envelope.message
def test_envelope_routed(self): addr_1 = self.connection_client_1.address addr_2 = self.connection_client_2.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) envelope = Envelope( to=addr_2, sender=addr_1, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(msg), ) self.multiplexer_client_1.put(envelope) delivered_envelope = self.multiplexer_client_2.get(block=True, timeout=20) assert delivered_envelope is not None assert delivered_envelope.to == envelope.to assert delivered_envelope.sender == envelope.sender assert delivered_envelope.protocol_id == envelope.protocol_id assert delivered_envelope.message == envelope.message
async def test_connection_twice_return_none(): """Test that connecting twice works.""" with LocalNode() as node: address = "address" connection = _make_local_connection(address, node) await connection.connect() await node.connect(address, connection._reader) message = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) message_bytes = DefaultSerializer().encode(message) expected_envelope = Envelope( to=address, sender=address, protocol_id=DefaultMessage.protocol_id, message=message_bytes, ) await connection.send(expected_envelope) actual_envelope = await connection.receive() assert expected_envelope == actual_envelope await connection.disconnect()
def test_communication_server_client(self): """Test that envelopes can be sent from a server to a client.""" msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) msg_bytes = DefaultSerializer().encode(msg) expected_envelope = Envelope( to=self.client_addr_1, sender=self.server_addr, protocol_id=DefaultMessage.protocol_id, message=msg_bytes, ) self.server_multiplexer.put(expected_envelope) actual_envelope = self.client_1_multiplexer.get(block=True, timeout=5.0) assert expected_envelope == actual_envelope expected_envelope = Envelope( to=self.client_addr_2, sender=self.server_addr, protocol_id=DefaultMessage.protocol_id, message=msg_bytes, ) self.server_multiplexer.put(expected_envelope) actual_envelope = self.client_2_multiplexer.get(block=True, timeout=5.0) assert expected_envelope == actual_envelope
def _handle_unidentified_dialogue(self, msg: FipaMessage) -> None: """ Handle an unidentified dialogue. Respond to the sender with a default message containing the appropriate error information. :param msg: the message :return: None """ self.context.logger.info("[{}]: unidentified dialogue.".format( self.context.agent_name)) default_msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.ERROR, error_code=DefaultMessage.ErrorCode.INVALID_DIALOGUE, error_msg="Invalid dialogue.", error_data={"fipa_message": FipaSerializer().encode(msg)}, ) self.context.outbox.put_message( to=msg.counterparty, sender=self.context.agent_address, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(default_msg), )
def test_reception(self): """Test that the connection receives what has been enqueued in the input file.""" msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) expected_envelope = Envelope( to="any", sender="any", protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(msg), ) encoded_envelope = "{},{},{},{},".format( expected_envelope.to, expected_envelope.sender, expected_envelope.protocol_id, expected_envelope.message.decode("utf-8"), ) encoded_envelope = encoded_envelope.encode("utf-8") with open(self.input_file_path, "ab+") as f: f.write(encoded_envelope) f.flush() actual_envelope = self.multiplexer.get(block=True, timeout=3.0) assert expected_envelope == actual_envelope
async def _handle_agent_message(self, envelope: Envelope) -> None: """ Forward an envelope to the right agent. :param envelope: the envelope :return: None """ destination = envelope.to if destination not in self._out_queues.keys(): msg = DefaultMessage( performative=DefaultMessage.Performative.ERROR, dialogue_reference=("", ""), target=TARGET, message_id=MESSAGE_ID, error_code=DefaultMessage.ErrorCode.INVALID_DIALOGUE, error_msg="Destination not available", error_data={}, # TODO: reference incoming message. ) msg_bytes = DefaultSerializer().encode(msg) error_envelope = Envelope( to=envelope.sender, sender=DEFAULT_OEF, protocol_id=DefaultMessage.protocol_id, message=msg_bytes, ) await self._send(error_envelope) return else: await self._send(envelope)
def send_unsupported_protocol(self, envelope: Envelope) -> None: """ Handle the received envelope in case the protocol is not supported. :param envelope: the envelope :return: None """ self.context.logger.warning("Unsupported protocol: {}".format( envelope.protocol_id)) encoded_protocol_id = base64.b85encode( str.encode(str(envelope.protocol_id))) reply = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.ERROR, error_code=DefaultMessage.ErrorCode.UNSUPPORTED_PROTOCOL, error_msg="Unsupported protocol.", error_data={"protocol_id": encoded_protocol_id}, ) self.context.outbox.put_message( to=envelope.sender, sender=self.context.agent_address, protocol_id=DefaultMessage.protocol_id, message=DefaultSerializer().encode(reply), )
def test_connection_is_established(self): """Test the stub connection is established and then bad formatted messages.""" assert self.connection.is_connected msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) encoded_envelope = "{}{}{}{}{}{}{}{}".format( "any", SEPARATOR, "any", SEPARATOR, DefaultMessage.protocol_id, SEPARATOR, DefaultMessage.serializer.encode(msg).decode("utf-8"), SEPARATOR, ) encoded_envelope = base64.b64encode(encoded_envelope.encode("utf-8")) envelope = _process_line(encoded_envelope) if envelope is not None: self.connection._put_envelopes([envelope]) assert (self.connection.in_queue.empty() ), "The inbox must be empty due to bad encoded message"
def test_send_receive_envelope(self): """Run the echo skill sequence.""" self.add_item("skill", "fetchai/echo:0.5.0") process = self.run_agent() is_running = self.is_running(process) assert is_running, "AEA not running within timeout!" # add sending and receiving envelope from input/output files sender = "sender" default_dialogues = DefaultDialogues(sender) message_content = b"hello" message = DefaultMessage( performative=DefaultMessage.Performative.BYTES, dialogue_reference=default_dialogues. new_self_initiated_dialogue_reference(), content=message_content, ) sent_envelope = Envelope( to=self.agent_name, sender=sender, protocol_id=message.protocol_id, message=message, ) self.send_envelope_to_agent(sent_envelope, self.agent_name) time.sleep(2.0) received_envelope = self.read_envelope_from_agent(self.agent_name) received_message = DefaultMessage.serializer.decode( received_envelope.message) assert sent_envelope.message.content == received_message.content
def dummy_default_message( cls, dialogue_reference: Tuple[str, str] = ("", ""), message_id: int = 1, target: int = 0, performative: DefaultMessage.Performative = DefaultMessage.Performative.BYTES, content: Union[str, bytes] = "hello world!", ) -> Message: """ Construct simple message, all arguments are optional. :param dialogue_reference: the dialogue reference. :param message_id: the message id. :param target: the message target. :param performative: the message performative. :param content: string or bytes payload. :return: Message """ if isinstance(content, str): content = content.encode("utf-8") return DefaultMessage( dialogue_reference=dialogue_reference, message_id=message_id, target=target, performative=performative, content=content, )
def test_envelope_echoed_back(self): addr_1 = self.connection1.node.address addr_2 = self.connection2.node.address msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) original_envelope = Envelope( to=addr_2, sender=addr_1, protocol_id=DefaultMessage.protocol_id, message=msg, ) self.multiplexer1.put(original_envelope) delivered_envelope = self.multiplexer2.get(block=True, timeout=10) assert delivered_envelope is not None delivered_envelope.to = addr_1 delivered_envelope.sender = addr_2 self.multiplexer2.put(delivered_envelope) echoed_envelope = self.multiplexer1.get(block=True, timeout=5) assert echoed_envelope is not None assert echoed_envelope.to == original_envelope.sender assert delivered_envelope.sender == original_envelope.to assert delivered_envelope.protocol_id == original_envelope.protocol_id assert delivered_envelope.message != original_envelope.message msg = DefaultMessage.serializer.decode(delivered_envelope.message) assert original_envelope.message == msg
def test_star_routing_connectivity(self): addrs = [conn.node.address for conn in self.connections] msg = DefaultMessage( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) for source in range(len(self.multiplexers)): for destination in range(len(self.multiplexers)): if destination == source: continue envelope = Envelope( to=addrs[destination], sender=addrs[source], protocol_id=DefaultMessage.protocol_id, message=msg, ) self.multiplexers[source].put(envelope) delivered_envelope = self.multiplexers[destination].get( block=True, timeout=10) assert delivered_envelope is not None assert delivered_envelope.to == envelope.to assert delivered_envelope.sender == envelope.sender assert delivered_envelope.protocol_id == envelope.protocol_id assert delivered_envelope.message != envelope.message msg = DefaultMessage.serializer.decode( delivered_envelope.message) assert envelope.message == msg
def setup_class(cls): """Set the test up.""" cls.node = LocalNode() cls.node.start() cls.agent_name = "MyAgent" cls.private_key_pem_path = os.path.join(CUR_PATH, "data", "priv.pem") cls.wallet = Wallet({'default': cls.private_key_pem_path}) cls.ledger_apis = LedgerApis({}) cls.connection = OEFLocalConnection(cls.agent_name, cls.node) cls.connections = [cls.connection] cls.temp = tempfile.mkdtemp(prefix="test_aea_resources") cls.resources = Resources(cls.temp) cls.aea = AEA(cls.agent_name, cls.connections, cls.wallet, cls.ledger_apis, resources=cls.resources) cls.default_protocol_configuration = ProtocolConfig.from_json( yaml.safe_load(open(Path(AEA_DIR, "protocols", "default", "protocol.yaml")))) cls.default_protocol = Protocol("default", DefaultSerializer(), cls.default_protocol_configuration) cls.resources.protocol_registry.register(("default", None), cls.default_protocol) cls.error_skill = Skill.from_dir(Path(AEA_DIR, "skills", "error"), cls.aea.context) cls.dummy_skill = Skill.from_dir(Path(CUR_PATH, "data", "dummy_skill"), cls.aea.context) cls.resources.add_skill(cls.dummy_skill) cls.resources.add_skill(cls.error_skill) cls.expected_message = DefaultMessage(type=DefaultMessage.Type.BYTES, content=b"hello") cls.t = Thread(target=cls.aea.start) cls.t.start() time.sleep(0.5) cls.aea.outbox.put(Envelope(to=cls.agent_name, sender=cls.agent_name, protocol_id="default", message=DefaultSerializer().encode(cls.expected_message)))