def setup_class(cls):
"""Set up the test."""
dummy_skill_path = os.path.join(CUR_PATH, "data", "dummy_skill")
protocol_path = os.path.join(
ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"
)
contract_path = os.path.join(
ROOT_DIR, "packages", "fetchai", "contracts", "erc1155"
)
connection_path = os.path.join(
ROOT_DIR, "packages", "fetchai", "connections", "soef"
)
builder = AEABuilder()
builder.set_name("aea1")
builder.add_private_key("fetchai")
builder.add_protocol(protocol_path)
builder.add_contract(contract_path)
builder.add_connection(connection_path)
builder.add_skill(dummy_skill_path)
cls.aea1 = builder.build()
builder.set_name("aea2")
cls.aea2 = builder.build()
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",
DEFAULT_PRIVATE_KEY_FILE)
builder = AEABuilder()
builder.set_name(agent_name)
builder.add_private_key(DEFAULT_LEDGER, private_key_path)
builder.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "local"))
local_connection_id = OEFLocalConnection.connection_id
builder.set_default_connection(local_connection_id)
builder.add_skill(Path(CUR_PATH, "data", "dummy_skill"))
agent = builder.build(connection_ids=[local_connection_id])
# This is a temporary workaround to feed the local node to the OEF Local connection
# TODO remove it.
local_connection = agent.resources.get_connection(local_connection_id)
local_connection._local_node = node
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
msg.to = agent.identity.address
msg.sender = agent.identity.address
envelope = Envelope(
to=msg.to,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
with run_in_thread(agent.start, timeout=20, on_exit=agent.stop):
wait_for_condition(lambda: agent.is_running, timeout=20)
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: len(handler.handled_messages) > 0,
timeout=20,
error_msg="The message is not inside the handled_messages.",
)
def test_generated_protocol_end_to_end(self):
"""Test that a generated protocol could be used in exchanging messages between two agents."""
agent_name_1 = "my_aea_1"
agent_name_2 = "my_aea_2"
builder_1 = AEABuilder()
builder_1.set_name(agent_name_1)
builder_1.add_private_key(DEFAULT_LEDGER, self.private_key_path_1)
builder_1.set_default_ledger(DEFAULT_LEDGER)
builder_1.set_default_connection(PublicId.from_str("fetchai/oef:0.7.0"))
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa")
)
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search")
)
builder_1.add_component(
ComponentType.PROTOCOL,
Path(PATH_TO_T_PROTOCOL),
skip_consistency_check=True,
)
builder_1.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef")
)
builder_2 = AEABuilder()
builder_2.set_name(agent_name_2)
builder_2.add_private_key(DEFAULT_LEDGER, self.private_key_path_2)
builder_2.set_default_ledger(DEFAULT_LEDGER)
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa")
)
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search")
)
builder_2.set_default_connection(PublicId.from_str("fetchai/oef:0.7.0"))
builder_2.add_component(
ComponentType.PROTOCOL,
Path(PATH_TO_T_PROTOCOL),
skip_consistency_check=True,
)
builder_2.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef")
)
# create AEAs
aea_1 = builder_1.build(connection_ids=[PublicId.from_str("fetchai/oef:0.7.0")])
aea_2 = builder_2.build(connection_ids=[PublicId.from_str("fetchai/oef:0.7.0")])
# dialogues
dialogue_label_1 = DialogueLabel(
(str(1), ""), aea_2.identity.address, aea_1.identity.address
)
aea_1_dialogue = TProtocolDialogue(
dialogue_label_1, aea_1.identity.address, TProtocolDialogue.Role.ROLE_1
)
dialogue_label_2 = DialogueLabel(
(str(1), str(1)), aea_1.identity.address, aea_1.identity.address
)
aea_2_dialogue = TProtocolDialogue(
dialogue_label_2, aea_2.identity.address, TProtocolDialogue.Role.ROLE_2
)
# message 1
message_1 = TProtocolMessage(
message_id=1,
dialogue_reference=(str(1), ""),
target=0,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some bytes",
content_int=42,
content_float=42.7,
content_bool=True,
content_str="some string",
)
message_1.counterparty = aea_2.identity.address
message_1.is_incoming = False
# message 2
message_2 = TProtocolMessage(
message_id=2,
dialogue_reference=(str(1), str(1)),
target=1,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some other bytes",
content_int=43,
content_float=43.7,
content_bool=False,
content_str="some other string",
)
message_2.counterparty = aea_1.identity.address
message_2.is_incoming = False
# add handlers to AEA resources
skill_context_1 = SkillContext(aea_1.context)
skill_1 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"), skill_context_1)
skill_context_1._skill = skill_1
agent_1_handler = Agent1Handler(
skill_context=skill_context_1,
name="fake_handler_1",
dialogue=aea_1_dialogue,
)
aea_1.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_1_handler,
)
skill_context_2 = SkillContext(aea_2.context)
skill_2 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"), skill_context_2)
skill_context_2._skill = skill_2
agent_2_handler = Agent2Handler(
message=message_2,
dialogue=aea_2_dialogue,
skill_context=skill_context_2,
name="fake_handler_2",
)
aea_2.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_2_handler,
)
# Start threads
t_1 = Thread(target=aea_1.start)
t_2 = Thread(target=aea_2.start)
try:
t_1.start()
t_2.start()
time.sleep(1.0)
aea_1_dialogue.update(message_1)
aea_1.outbox.put_message(message_1)
time.sleep(5.0)
assert (
agent_2_handler.handled_message.message_id == message_1.message_id
), "Message from Agent 1 to 2: message ids do not match"
assert (
agent_2_handler.handled_message.dialogue_reference
== message_1.dialogue_reference
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[0]
== message_1.dialogue_reference[0]
), "Message from Agent 1 to 2: dialogue reference[0]s do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[1]
== message_1.dialogue_reference[1]
), "Message from Agent 1 to 2: dialogue reference[1]s do not match"
assert (
agent_2_handler.handled_message.target == message_1.target
), "Message from Agent 1 to 2: targets do not match"
assert (
agent_2_handler.handled_message.performative == message_1.performative
), "Message from Agent 1 to 2: performatives do not match"
assert (
agent_2_handler.handled_message.content_bytes == message_1.content_bytes
), "Message from Agent 1 to 2: content_bytes do not match"
assert (
agent_2_handler.handled_message.content_int == message_1.content_int
), "Message from Agent 1 to 2: content_int do not match"
# assert (
# agent_2_handler.handled_message.content_float == message_1.content_float
# ), "Message from Agent 1 to 2: content_float do not match"
assert (
agent_2_handler.handled_message.content_bool == message_1.content_bool
), "Message from Agent 1 to 2: content_bool do not match"
assert (
agent_2_handler.handled_message.content_str == message_1.content_str
), "Message from Agent 1 to 2: content_str do not match"
assert (
agent_1_handler.handled_message.message_id == message_2.message_id
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference
== message_2.dialogue_reference
), "Message from Agent 2 to 1: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[0]
== message_2.dialogue_reference[0]
), "Message from Agent 2 to 1: dialogue reference[0]s do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[1]
== message_2.dialogue_reference[1]
), "Message from Agent 2 to 1: dialogue reference[1]s do not match"
assert (
agent_1_handler.handled_message.target == message_2.target
), "Message from Agent 2 to 1: targets do not match"
assert (
agent_1_handler.handled_message.performative == message_2.performative
), "Message from Agent 2 to 1: performatives do not match"
assert (
agent_1_handler.handled_message.content_bytes == message_2.content_bytes
), "Message from Agent 2 to 1: content_bytes do not match"
assert (
agent_1_handler.handled_message.content_int == message_2.content_int
), "Message from Agent 2 to 1: content_int do not match"
# assert (
# agent_1_handler.handled_message.content_float == message_2.content_float
# ), "Message from Agent 2 to 1: content_float do not match"
assert (
agent_1_handler.handled_message.content_bool == message_2.content_bool
), "Message from Agent 2 to 1: content_bool do not match"
assert (
agent_1_handler.handled_message.content_str == message_2.content_str
), "Message from Agent 2 to 1: content_str do not match"
time.sleep(2.0)
finally:
aea_1.stop()
aea_2.stop()
t_1.join()
t_2.join()
def test_initialize_aea_programmatically():
"""Test that we can initialize an AEA programmatically."""
with LocalNode() as node:
agent_name = "MyAgent"
private_key_path = os.path.join(CUR_PATH, "data",
DEFAULT_PRIVATE_KEY_FILE)
builder = AEABuilder()
builder.set_name(agent_name)
builder.add_private_key(DEFAULT_LEDGER, private_key_path)
builder.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "local"))
local_connection_id = PublicId.from_str("fetchai/local:0.6.0")
builder.set_default_connection(local_connection_id)
builder.add_skill(Path(CUR_PATH, "data", "dummy_skill"))
aea = builder.build(
connection_ids=[PublicId.from_str("fetchai/local:0.6.0")])
local_connection = aea.resources.get_connection(local_connection_id)
local_connection._local_node = node
expected_message = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
expected_message.counterparty = aea.identity.address
expected_message.sender = aea.identity.address
envelope = Envelope(
to=expected_message.counterparty,
sender=expected_message.sender,
protocol_id=expected_message.protocol_id,
message=expected_message,
)
with run_in_thread(aea.start, timeout=5, on_exit=aea.stop):
wait_for_condition(lambda: aea.is_running, timeout=10)
aea.outbox.put(envelope)
dummy_skill_id = DUMMY_SKILL_PUBLIC_ID
dummy_behaviour_name = "dummy"
dummy_behaviour = aea.resources.get_behaviour(
dummy_skill_id, dummy_behaviour_name)
wait_for_condition(lambda: dummy_behaviour is not None, timeout=10)
wait_for_condition(lambda: dummy_behaviour.nb_act_called > 0,
timeout=10)
# TODO the previous code caused an error:
# _pickle.PicklingError: Can't pickle <class 'tasks.DummyTask'>: import of module 'tasks' failed
dummy_task = DummyTask()
task_id = aea.task_manager.enqueue_task(dummy_task)
async_result = aea.task_manager.get_task_result(task_id)
expected_dummy_task = async_result.get(10.0)
wait_for_condition(
lambda: expected_dummy_task.nb_execute_called > 0, timeout=10)
dummy_handler = aea.resources.get_handler(
DefaultMessage.protocol_id, dummy_skill_id)
dummy_handler_alt = aea.resources._handler_registry.fetch(
(dummy_skill_id, "dummy"))
wait_for_condition(lambda: dummy_handler == dummy_handler_alt,
timeout=10)
wait_for_condition(lambda: dummy_handler is not None, timeout=10)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 1, timeout=10)
wait_for_condition(
lambda: dummy_handler.handled_messages[0] == expected_message,
timeout=10,
)
def test_handle():
"""Tests handle method of an agent."""
with LocalNode() as node:
agent_name = "MyAgent"
private_key_path = os.path.join(CUR_PATH, "data",
DEFAULT_PRIVATE_KEY_FILE)
builder = AEABuilder()
builder.set_name(agent_name)
builder.add_private_key(DEFAULT_LEDGER, private_key_path)
builder.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "local"))
local_connection_id = PublicId.from_str("fetchai/local:0.6.0")
builder.set_default_connection(local_connection_id)
builder.add_skill(Path(CUR_PATH, "data", "dummy_skill"))
aea = builder.build(
connection_ids=[PublicId.from_str("fetchai/local:0.6.0")])
# This is a temporary workaround to feed the local node to the OEF Local connection
# TODO remove it.
local_connection = aea.resources.get_connection(local_connection_id)
local_connection._local_node = node
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
msg.counterparty = aea.identity.address
msg.sender = aea.identity.address
envelope = Envelope(
to=msg.counterparty,
sender=msg.sender,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=msg,
)
with run_in_thread(aea.start, timeout=5):
wait_for_condition(lambda: aea.is_running, timeout=10)
dummy_skill = aea.resources.get_skill(DUMMY_SKILL_PUBLIC_ID)
dummy_handler = dummy_skill.handlers["dummy"]
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 1,
timeout=1,
)
# DECODING ERROR
envelope = Envelope(
to=aea.identity.address,
sender=aea.identity.address,
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
# send envelope via localnode back to agent/bypass `outbox` put consistency checks
aea.outbox._multiplexer.put(envelope)
""" inbox twice cause first message is invalid. generates error message and it accepted """
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 2,
timeout=1,
)
# UNSUPPORTED SKILL
msg = FipaMessage(
performative=FipaMessage.Performative.ACCEPT,
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
)
msg.counterparty = aea.identity.address
msg.sender = aea.identity.address
envelope = Envelope(
to=msg.counterparty,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
# send envelope via localnode back to agent
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 3,
timeout=2,
)
aea.stop()
def test_generated_protocol_end_to_end(self):
"""Test that a generated protocol could be used in exchanging messages between two agents."""
agent_name_1 = "my_aea_1"
agent_name_2 = "my_aea_2"
builder_1 = AEABuilder()
builder_1.set_name(agent_name_1)
builder_1.add_private_key(DEFAULT_LEDGER, self.private_key_path_1)
builder_1.set_default_ledger(DEFAULT_LEDGER)
builder_1.set_default_connection(OEF_CONNECTION_PUBLIC_ID)
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa")
)
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search")
)
builder_1.add_component(
ComponentType.PROTOCOL,
Path(PATH_TO_T_PROTOCOL),
skip_consistency_check=True,
)
builder_1.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef")
)
builder_2 = AEABuilder()
builder_2.set_name(agent_name_2)
builder_2.add_private_key(DEFAULT_LEDGER, self.private_key_path_2)
builder_2.set_default_ledger(DEFAULT_LEDGER)
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa")
)
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search")
)
builder_2.set_default_connection(OEF_CONNECTION_PUBLIC_ID)
builder_2.add_component(
ComponentType.PROTOCOL,
Path(PATH_TO_T_PROTOCOL),
skip_consistency_check=True,
)
builder_2.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef")
)
# create AEAs
aea_1 = builder_1.build(connection_ids=[OEF_CONNECTION_PUBLIC_ID])
aea_2 = builder_2.build(connection_ids=[OEF_CONNECTION_PUBLIC_ID])
# dialogues
def role_from_first_message_1(
message: Message, receiver_address: Address
) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return TProtocolDialogue.Role.ROLE_1
agent_1_dialogues = TProtocolDialogues(
self_address=aea_1.identity.address,
role_from_first_message=role_from_first_message_1,
)
def role_from_first_message_1(
message: Message, receiver_address: Address
) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return TProtocolDialogue.Role.ROLE_2
agent_2_dialogues = TProtocolDialogues(
self_address=aea_2.identity.address,
role_from_first_message=role_from_first_message_1,
)
# messages
message_1, aea_1_dialogue = agent_1_dialogues.create(
counterparty=aea_2.identity.address,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some bytes",
content_int=42,
content_float=42.7,
content_bool=True,
content_str="some string",
)
message_1 = cast(TProtocolMessage, message_1)
message_2, aea_2_dialogue = agent_2_dialogues.create(
counterparty=aea_1.identity.address,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some other bytes",
content_int=43,
content_float=43.7,
content_bool=False,
content_str="some other string",
)
message_2 = cast(TProtocolMessage, message_2)
# add handlers to AEA resources
skill_context_1 = SkillContext(aea_1.context)
skill_1 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"), skill_context_1)
skill_context_1._skill = skill_1
agent_1_handler = Agent1Handler(
skill_context=skill_context_1,
name="fake_handler_1",
dialogues=agent_1_dialogues,
)
aea_1.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_1_handler,
)
skill_context_2 = SkillContext(aea_2.context)
skill_2 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"), skill_context_2)
skill_context_2._skill = skill_2
agent_2_handler = Agent2Handler(
message=message_2,
dialogues=agent_2_dialogues,
skill_context=skill_context_2,
name="fake_handler_2",
)
aea_2.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_2_handler,
)
# Start threads
t_1 = Thread(target=aea_1.start)
t_2 = Thread(target=aea_2.start)
try:
t_1.start()
t_2.start()
time.sleep(1.0)
aea_1.outbox.put_message(message_1)
time.sleep(5.0)
assert (
agent_2_handler.handled_message.message_id == message_1.message_id
), "Message from Agent 1 to 2: message ids do not match"
assert (
agent_2_handler.handled_message.dialogue_reference
== message_1.dialogue_reference
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[0]
== message_1.dialogue_reference[0]
), "Message from Agent 1 to 2: dialogue reference[0]s do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[1]
== message_1.dialogue_reference[1]
), "Message from Agent 1 to 2: dialogue reference[1]s do not match"
assert (
agent_2_handler.handled_message.target == message_1.target
), "Message from Agent 1 to 2: targets do not match"
assert (
agent_2_handler.handled_message.performative == message_1.performative
), "Message from Agent 1 to 2: performatives do not match"
assert (
agent_2_handler.handled_message.content_bytes == message_1.content_bytes
), "Message from Agent 1 to 2: content_bytes do not match"
assert (
agent_2_handler.handled_message.content_int == message_1.content_int
), "Message from Agent 1 to 2: content_int do not match"
# assert (
# agent_2_handler.handled_message.content_float == message_1.content_float # noqa: E800
# ), "Message from Agent 1 to 2: content_float do not match"
assert (
agent_2_handler.handled_message.content_bool == message_1.content_bool
), "Message from Agent 1 to 2: content_bool do not match"
assert (
agent_2_handler.handled_message.content_str == message_1.content_str
), "Message from Agent 1 to 2: content_str do not match"
assert (
agent_1_handler.handled_message.message_id == message_2.message_id
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference
== message_2.dialogue_reference
), "Message from Agent 2 to 1: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[0]
== message_2.dialogue_reference[0]
), "Message from Agent 2 to 1: dialogue reference[0]s do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[1]
== message_2.dialogue_reference[1]
), "Message from Agent 2 to 1: dialogue reference[1]s do not match"
assert (
agent_1_handler.handled_message.target == message_2.target
), "Message from Agent 2 to 1: targets do not match"
assert (
agent_1_handler.handled_message.performative == message_2.performative
), "Message from Agent 2 to 1: performatives do not match"
assert (
agent_1_handler.handled_message.content_bytes == message_2.content_bytes
), "Message from Agent 2 to 1: content_bytes do not match"
assert (
agent_1_handler.handled_message.content_int == message_2.content_int
), "Message from Agent 2 to 1: content_int do not match"
# assert (
# agent_1_handler.handled_message.content_float == message_2.content_float # noqa: E800
# ), "Message from Agent 2 to 1: content_float do not match"
assert (
agent_1_handler.handled_message.content_bool == message_2.content_bool
), "Message from Agent 2 to 1: content_bool do not match"
assert (
agent_1_handler.handled_message.content_str == message_2.content_str
), "Message from Agent 2 to 1: content_str do not match"
time.sleep(2.0)
finally:
aea_1.stop()
aea_2.stop()
t_1.join()
t_2.join()
async def test_handle():
"""Tests handle method of an agent."""
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"))
aea = 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(aea._connections)[0]._local_node = node
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
message_bytes = DefaultSerializer().encode(msg)
envelope = Envelope(
to=aea.identity.address,
sender=aea.identity.address,
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=message_bytes,
)
with run_in_thread(aea.start, timeout=5, on_exit=aea.stop):
wait_for_condition(
lambda: aea._main_loop and aea._main_loop.is_running,
timeout=10)
dummy_skill = aea.resources.get_skill(DUMMY_SKILL_PUBLIC_ID)
dummy_handler = dummy_skill.handlers["dummy"]
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 1,
timeout=1,
)
# DECODING ERROR
envelope = Envelope(
to=aea.identity.address,
sender=aea.identity.address,
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
# send envelope via localnode back to agent
aea.outbox.put(envelope)
""" inbox twice cause first message is invalid. generates error message and it accepted """
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 2,
timeout=1,
)
# UNSUPPORTED SKILL
msg = FipaSerializer().encode(
FipaMessage(
performative=FipaMessage.Performative.ACCEPT,
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
))
envelope = Envelope(
to=aea.identity.address,
sender=aea.identity.address,
protocol_id=FipaMessage.protocol_id,
message=msg,
)
# send envelope via localnode back to agent
aea.outbox.put(envelope)
wait_for_condition(
lambda: len(dummy_handler.handled_messages) == 3,
timeout=1,
)
aea.stop()
def test_generated_protocol_end_to_end(self):
"""Test that a generated protocol could be used in exchanging messages between two agents."""
agent_name_1 = "my_aea_1"
agent_name_2 = "my_aea_2"
builder_1 = AEABuilder()
builder_1.set_name(agent_name_1)
builder_1.add_private_key(FetchAICrypto.identifier,
self.private_key_path_1)
builder_1.set_default_ledger(FetchAICrypto.identifier)
builder_1.set_default_connection(
PublicId.from_str("fetchai/oef:0.3.0"))
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa"))
builder_1.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder_1.add_component(
ComponentType.PROTOCOL,
Path(ROOT_DIR, "tests", "data", "generator", "t_protocol"),
skip_consistency_check=True,
)
builder_1.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef"))
builder_2 = AEABuilder()
builder_2.set_name(agent_name_2)
builder_2.add_private_key(FetchAICrypto.identifier,
self.private_key_path_2)
builder_2.set_default_ledger(FetchAICrypto.identifier)
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "fipa"))
builder_2.add_protocol(
Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))
builder_2.set_default_connection(
PublicId.from_str("fetchai/oef:0.3.0"))
builder_2.add_component(
ComponentType.PROTOCOL,
Path(ROOT_DIR, "tests", "data", "generator", "t_protocol"),
skip_consistency_check=True,
)
builder_2.add_connection(
Path(ROOT_DIR, "packages", "fetchai", "connections", "oef"))
# create AEAs
aea_1 = builder_1.build(
connection_ids=[PublicId.from_str("fetchai/oef:0.3.0")])
aea_2 = builder_2.build(
connection_ids=[PublicId.from_str("fetchai/oef:0.3.0")])
# message 1
message = TProtocolMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some bytes",
content_int=42,
content_float=42.7,
content_bool=True,
content_str="some string",
)
encoded_message_in_bytes = TProtocolSerializer().encode(message)
envelope = Envelope(
to=aea_2.identity.address,
sender=aea_1.identity.address,
protocol_id=TProtocolMessage.protocol_id,
message=encoded_message_in_bytes,
)
# message 2
message_2 = TProtocolMessage(
message_id=2,
dialogue_reference=(str(0), ""),
target=1,
performative=TProtocolMessage.Performative.PERFORMATIVE_PT,
content_bytes=b"some other bytes",
content_int=43,
content_float=43.7,
content_bool=False,
content_str="some other string",
)
encoded_message_2_in_bytes = TProtocolSerializer().encode(message_2)
# add handlers to AEA resources]
skill_context_1 = SkillContext(aea_1.context)
skill_1 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"),
skill_context_1)
skill_context_1._skill = skill_1
agent_1_handler = Agent1Handler(skill_context=skill_context_1,
name="fake_handler_1")
aea_1.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_1_handler,
)
skill_context_2 = SkillContext(aea_2.context)
skill_2 = Skill(SkillConfig("fake_skill", "fetchai", "0.1.0"),
skill_context_2)
skill_context_2._skill = skill_2
agent_2_handler = Agent2Handler(
encoded_messsage=encoded_message_2_in_bytes,
skill_context=skill_context_2,
name="fake_handler_2",
)
aea_2.resources._handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
TProtocolMessage.protocol_id,
),
agent_2_handler,
)
# Start threads
t_1 = Thread(target=aea_1.start)
t_2 = Thread(target=aea_2.start)
try:
t_1.start()
t_2.start()
time.sleep(1.0)
aea_1.outbox.put(envelope)
time.sleep(5.0)
assert (agent_2_handler.handled_message.message_id ==
message.message_id
), "Message from Agent 1 to 2: message ids do not match"
assert (
agent_2_handler.handled_message.dialogue_reference ==
message.dialogue_reference
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[0] ==
message.dialogue_reference[0]
), "Message from Agent 1 to 2: dialogue reference[0]s do not match"
assert (
agent_2_handler.handled_message.dialogue_reference[1] ==
message.dialogue_reference[1]
), "Message from Agent 1 to 2: dialogue reference[1]s do not match"
assert (agent_2_handler.handled_message.target == message.target
), "Message from Agent 1 to 2: targets do not match"
assert (agent_2_handler.handled_message.performative ==
message.performative
), "Message from Agent 1 to 2: performatives do not match"
assert (agent_2_handler.handled_message.content_bytes ==
message.content_bytes
), "Message from Agent 1 to 2: content_bytes do not match"
assert (agent_2_handler.handled_message.content_int ==
message.content_int
), "Message from Agent 1 to 2: content_int do not match"
# floats do not seem to lose some precision when serialised then deserialised using protobuf
# assert agent_2_handler.handled_message.content_float == message.content_float, "Message from Agent 1 to 2: content_float do not match"
assert (agent_2_handler.handled_message.content_bool ==
message.content_bool
), "Message from Agent 1 to 2: content_bool do not match"
assert (agent_2_handler.handled_message.content_str ==
message.content_str
), "Message from Agent 1 to 2: content_str do not match"
assert (
agent_1_handler.handled_message.message_id ==
message_2.message_id
), "Message from Agent 1 to 2: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference ==
message_2.dialogue_reference
), "Message from Agent 2 to 1: dialogue references do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[0] ==
message_2.dialogue_reference[0]
), "Message from Agent 2 to 1: dialogue reference[0]s do not match"
assert (
agent_1_handler.handled_message.dialogue_reference[1] ==
message_2.dialogue_reference[1]
), "Message from Agent 2 to 1: dialogue reference[1]s do not match"
assert (agent_1_handler.handled_message.target == message_2.target
), "Message from Agent 2 to 1: targets do not match"
assert (agent_1_handler.handled_message.performative ==
message_2.performative
), "Message from Agent 2 to 1: performatives do not match"
assert (agent_1_handler.handled_message.content_bytes ==
message_2.content_bytes
), "Message from Agent 2 to 1: content_bytes do not match"
assert (agent_1_handler.handled_message.content_int ==
message_2.content_int
), "Message from Agent 2 to 1: content_int do not match"
# floats do not seem to lose some precision when serialised then deserialised using protobuf
# assert agent_1_handler.handled_message.content_float == message_2.content_float, "Message from Agent 2 to 1: content_float do not match"
assert (agent_1_handler.handled_message.content_bool ==
message_2.content_bool
), "Message from Agent 2 to 1: content_bool do not match"
assert (agent_1_handler.handled_message.content_str ==
message_2.content_str
), "Message from Agent 2 to 1: content_str do not match"
time.sleep(2.0)
finally:
aea_1.stop()
aea_2.stop()
t_1.join()
t_2.join()
