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