def test_check_public_id_consistency_negative(): """Test ComponentId.check_public_id_consistency raises error when directory does not exists.""" random_dir_name = random_string() with pytest.raises(ValueError, match=f"Directory {random_dir_name} is not valid."): component_configuration = ProtocolConfig("name", "author") component_configuration.check_public_id_consistency( Path(random_dir_name))
def test_from_json_and_to_json(self, protocol_path): """Test the 'from_json' method and 'to_json' work correctly.""" f = open(protocol_path) original_json = yaml.safe_load(f) expected_config = ProtocolConfig.from_json(original_json) assert isinstance(expected_config, ProtocolConfig) expected_json = expected_config.json actual_config = ProtocolConfig.from_json(expected_json) actual_json = actual_config.json assert expected_json == actual_json
def test_dependency_manager_highest_version(): """Test dependency version priority.""" dep_manager = _DependenciesManager() dep_manager.add_component(ProtocolConfig("a_protocol", "author", "0.1.0")) dep_manager.add_component(ProtocolConfig("a_protocol", "author", "0.2.0")) assert len(dep_manager.dependencies_highest_version) == 1 assert list(dep_manager.dependencies_highest_version)[0].version == "0.2.0" assert len(dep_manager.protocols) == 2 assert len(dep_manager.skills) == 0 assert len(dep_manager.contracts) == 0
def test_remove_component_not_exists(): """Test component remove not exists.""" dep_manager = _DependenciesManager() with pytest.raises(ValueError, match=r"Component .* of type .* not present."): dep_manager.remove_component( ProtocolConfig("a_protocol", "author", "0.1.0").component_id)
def setup_class(self): """Setup test.""" self.configuration = ProtocolConfig("name", "author", "0.1.0") self.configuration.build_directory = "test" self.component = Component(configuration=self.configuration) self.directory = Path() self.component._directory = self.directory
def test_multiple_builds_with_component_instance(): """Test multiple calls to the 'build()' method when adding component instances.""" builder = AEABuilder() builder.set_name("aea_1") builder.add_private_key("fetchai") a_protocol = Protocol( ProtocolConfig("a_protocol", "author", "0.1.0"), DefaultMessage ) builder.add_component_instance(a_protocol) # the first call works aea_1 = builder.build() assert isinstance(aea_1, AEA) # the second call fails with pytest.raises(ValueError, match="Cannot build.*"): builder.build() # after reset, it works builder.reset() builder.set_name("aea_1") builder.add_private_key("fetchai") builder.add_component_instance(a_protocol) aea_2 = builder.build() assert isinstance(aea_2, AEA)
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)))
def test_protocols_config(self): """Test the protocol config.""" protocol = Protocol( protocol_id=PublicId.from_str("author/my_own_protocol:0.1.0"), serializer=cast(Serializer, ProtobufSerializer), config=ProtocolConfig(), ) assert protocol.config is not None
def test_can_remove_not_exists_component(): """Test fail on remove component not registered.""" builder = AEABuilder() builder.set_name("aea_1") builder.add_private_key("fetchai") protocol = ProtocolConfig("a_protocol", "author", "0.1.0") with pytest.raises(ValueError): builder._check_can_remove(protocol.component_id)
def test_remove_component_success(): """Test remove registered component.""" dep_manager = _DependenciesManager() protocol = ProtocolConfig("a_protocol", "author", "0.1.0") skill = SkillConfig("skill", "author", "0.1.0", protocols=[protocol.public_id]) dep_manager.add_component(protocol) dep_manager.add_component(skill) dep_manager.remove_component(skill.component_id)
def test_check_aea_version_when_it_fails(): """Test the check for the AEA version when it fails.""" config = ProtocolConfig("name", "author", "0.1.0", aea_version=">0.1.0") with mock.patch.object(aea, "__version__", "0.1.0"): with pytest.raises( ValueError, match="The CLI version is 0.1.0, but package author/name:0.1.0 requires version >0.1.0", ): _check_aea_version(config)
def test_find_component_failed(): """Test fail on compomnent not found.""" builder = AEABuilder() builder.set_name("aea_1") builder.add_private_key("fetchai") a_protocol = Protocol(ProtocolConfig("a_protocol", "author", "0.1.0"), DefaultMessage) with pytest.raises(ValueError, match=r"Package .* not found"): builder._find_component_directory_from_component_id( Path("/some_dir"), a_protocol.component_id)
def test_from_json_and_to_json(self): """Test the 'from_json' method and 'to_json' work correctly.""" f = open( os.path.join(CUR_PATH, "data", "dummy_aea", "protocols", "default", "protocol.yaml")) expected_json = yaml.safe_load(f) config = ProtocolConfig.from_json(expected_json) assert isinstance(config, ProtocolConfig) actual_json = config.json assert expected_json == actual_json
def test_directory_setter(): """Test directory.""" configuration = ProtocolConfig("author", "name", "0.1.0") component = Component(configuration=configuration) with pytest.raises(ValueError): component.directory new_path = Path("new_path") component.directory = new_path assert component.directory == new_path
def _bump_protocol_specification_id(package_path: Path, configuration: ProtocolConfig) -> None: """Bump spec id version.""" spec_id: PublicId = configuration.protocol_specification_id # type: ignore old_version = semver.VersionInfo.parse(spec_id.version) new_version = str(old_version.bump_minor()) new_spec_id = PublicId(spec_id.author, spec_id.name, new_version) configuration.protocol_specification_id = new_spec_id with (package_path / DEFAULT_PROTOCOL_CONFIG_FILE).open("w") as file_output: ConfigLoaders.from_package_type(configuration.package_type).dump( configuration, file_output)
def test_remove_protocol(): """Test add/remove protocol.""" builder = AEABuilder() builder.set_name("aea_1") builder.add_private_key("fetchai") a_protocol = Protocol( ProtocolConfig("a_protocol", "author", "0.1.0"), DefaultMessage ) num_deps = len(builder._package_dependency_manager.all_dependencies) builder.add_component_instance(a_protocol) assert len(builder._package_dependency_manager.all_dependencies) == num_deps + 1 builder.remove_protocol(a_protocol.public_id) assert len(builder._package_dependency_manager.all_dependencies) == num_deps
def test_component_configuration_check_fingerprint_different_fingerprints_no_vendor(): """Test ComponentConfiguration.check_fingerprint when the fingerprints differ for a non-vendor package.""" config = ProtocolConfig("name", "author", "0.1.0") package_dir = Path("path", "to", "dir") error_regex = ( f"Fingerprints for package {package_dir} do not match:\nExpected: {dict()}\nActual: {dict(foo='bar')}\n" + "Please fingerprint the package before continuing: 'aea fingerprint protocol author/name:0.1.0" ) with pytest.raises(ValueError, match=error_regex): with mock.patch( "aea.configurations.base._compute_fingerprint", return_value={"foo": "bar"} ): _compare_fingerprints(config, package_dir, False, PackageType.PROTOCOL)
def test_component_configuration_check_fingerprint_different_fingerprints_vendor(): """Test ComponentConfiguration.check_fingerprint when the fingerprints differ for a vendor package.""" config = ProtocolConfig("name", "author", "0.1.0") package_dir = Path("path", "to", "dir") error_regex = ( f"Fingerprints for package {package_dir} do not match:\nExpected: {dict()}\nActual: {dict(foo='bar')}\n" + "Vendorized projects should not be tampered with, please revert any changes to protocol author/name:0.1.0" ) with pytest.raises(ValueError, match=error_regex): with mock.patch( "aea.configurations.base._compute_fingerprint", return_value={"foo": "bar"} ): _compare_fingerprints(config, package_dir, True, PackageType.PROTOCOL)
def test_remove_component_depends_on_fail(): """Test component remove fails cause dependency.""" dep_manager = _DependenciesManager() protocol = ProtocolConfig("a_protocol", "author", "0.1.0") dep_manager.add_component(protocol) dep_manager.add_component( SkillConfig("skill", "author", "0.1.0", protocols=[protocol.public_id]) ) with pytest.raises( ValueError, match=r"Cannot remove component .* of type .*. Other components depends on it: .*", ): dep_manager.remove_component(protocol.component_id)
def test_component_add_bad_dep(): """Test component load failed cause dependency.""" builder = AEABuilder() builder.set_name("aea_1") builder.add_private_key("fetchai") connection = _make_dummy_connection() connection.configuration.pypi_dependencies = { "something": Dependency("something", "==0.1.0") } builder.add_component_instance(connection) a_protocol = Protocol( ProtocolConfig("a_protocol", "author", "0.1.0"), DefaultMessage ) a_protocol.configuration.pypi_dependencies = { "something": Dependency("something", "==0.2.0") } with pytest.raises( AEAException, match=r"Conflict on package something: specifier set .*" ): builder.add_component_instance(a_protocol)
def setup_class(self): self.configuration = ProtocolConfig("name", "author", "0.1.0") self.component = Component(configuration=self.configuration) self.directory = Path() self.component._directory = self.directory
def ipfs_hashing( package_hashes: Dict[str, str], target_dir: str, package_type: str, package_name: str, ipfs_hash_only: IPFSHashOnly, ): """Hashes a package and its components.""" print("Processing package {} of type {}".format(package_name, package_type)) # load config file to get ignore patterns, dump again immediately to impose ordering if package_type == "agents": config = AgentConfig.from_json( yaml.safe_load(open(Path(target_dir, DEFAULT_AEA_CONFIG_FILE)))) yaml_dump(config.json, open(Path(target_dir, DEFAULT_AEA_CONFIG_FILE), "w")) elif package_type == "connections": config = ConnectionConfig.from_json( yaml.safe_load( open(Path(target_dir, DEFAULT_CONNECTION_CONFIG_FILE)))) yaml_dump(config.json, open(Path(target_dir, DEFAULT_CONNECTION_CONFIG_FILE), "w")) elif package_type == "contracts": config = ContractConfig.from_json( yaml.safe_load(open(Path(target_dir, DEFAULT_CONTRACT_CONFIG_FILE)))) yaml_dump(config.json, open(Path(target_dir, DEFAULT_CONTRACT_CONFIG_FILE), "w")) elif package_type == "protocols": config = ProtocolConfig.from_json( yaml.safe_load(open(Path(target_dir, DEFAULT_PROTOCOL_CONFIG_FILE)))) yaml_dump(config.json, open(Path(target_dir, DEFAULT_PROTOCOL_CONFIG_FILE), "w")) elif package_type == "skills": config = SkillConfig.from_json( yaml.safe_load(open(Path(target_dir, DEFAULT_SKILL_CONFIG_FILE)))) yaml_dump(config.json, open(Path(target_dir, DEFAULT_SKILL_CONFIG_FILE), "w")) config = yaml.safe_load(next(Path(target_dir).glob("*.yaml")).open()) ignore_patterns = config.get("fingerprint_ignore_patterns", []) if package_type != "agents": # hash inner components fingerprints_dict = _compute_fingerprint(Path(target_dir), ignore_patterns) # confirm ipfs only generates same hash: for file_name, ipfs_hash in fingerprints_dict.items(): path = os.path.join(target_dir, file_name) ipfsho_hash = ipfs_hash_only.get(path) if ipfsho_hash != ipfs_hash: print("WARNING, hashes don't match for: {}".format(path)) # update fingerprints file_name = package_type[:-1] + ".yaml" yaml_path = os.path.join(target_dir, file_name) file = open(yaml_path, mode="r") # read all lines at once whole_file = file.read() # close the file file.close() file = open(yaml_path, mode="r") # find and replace # TODO this can be simplified after https://github.com/fetchai/agents-aea/issues/932 existing = "" fingerprint_block = False for line in file: if line.find("fingerprint:") == 0: existing += line fingerprint_block = True elif fingerprint_block: if line.find(" ") == 0: # still inside fingerprint block existing += line else: # fingerprint block has ended break if len(fingerprints_dict) > 0: replacement = "fingerprint:\n" ordered_fingerprints_dict = collections.OrderedDict( sorted(fingerprints_dict.items())) for file_name, ipfs_hash in ordered_fingerprints_dict.items(): replacement += " " + file_name + ": " + ipfs_hash + "\n" else: replacement = "fingerprint: {}\n" whole_file = whole_file.replace(existing, replacement) # close the file file.close() # update fingerprints with open(yaml_path, "w") as f: f.write(whole_file) # hash again to get outer hash (this time all files): # TODO we still need to ignore some files result_list = client.add(target_dir) for result_dict in result_list: if package_name == result_dict["Name"]: key = os.path.join(AUTHOR, package_type, package_name) package_hashes[key] = result_dict["Hash"]
def test_component_configuration_check_fingerprint_bad_directory(): """Test ComponentConfiguration.check_fingerprint when a bad directory is provided.""" config = ProtocolConfig("name", "author", "0.1.0") with pytest.raises(ValueError, match="Directory .* is not valid."): config.check_fingerprint(Path("non_existing_directory"))
def test_configuration_ordered_json(): """Test configuration ordered json.""" configuration = ProtocolConfig("name", "author", "0.1.0") configuration._key_order = ["aea_version"] configuration.ordered_json
async def test_end_to_end_aea_aca(self): # AEA components ledger_apis = LedgerApis({}, FetchAICrypto.identifier) wallet = Wallet({FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE}) identity = Identity( name="my_aea_1", address=wallet.addresses.get(FetchAICrypto.identifier), default_address_key=FetchAICrypto.identifier, ) http_client_connection = HTTPClientConnection( address=self.aea_address, provider_address=self.aca_admin_address, provider_port=self.aca_admin_port, ) resources = Resources() # create AEA aea = AEA(identity, [http_client_connection], wallet, ledger_apis, resources) # Add http protocol to AEA resources http_protocol_configuration = ProtocolConfig.from_json( yaml.safe_load( open( os.path.join( self.cwd, "packages", "fetchai", "protocols", "http", "protocol.yaml", )))) http_protocol = Protocol(http_protocol_configuration, HttpSerializer()) resources.add_protocol(http_protocol) # Request message & envelope request_http_message = HttpMessage( dialogue_reference=("", ""), target=0, message_id=1, performative=HttpMessage.Performative.REQUEST, method="GET", url="http://{}:{}/status".format(self.aca_admin_address, self.aca_admin_port), headers="", version="", bodyy=b"", ) request_envelope = Envelope( to="ACA", sender="AEA", protocol_id=HTTP_PROTOCOL_PUBLIC_ID, message=HttpSerializer().encode(request_http_message), ) # add a simple skill with handler skill_context = SkillContext(aea.context) skill_config = SkillConfig(name="simple_skill", author="fetchai", version="0.1.0") aea_handler = AEAHandler(skill_context=skill_context, name="aea_handler") simple_skill = Skill(skill_config, skill_context, handlers={aea_handler.name: aea_handler}) resources.add_skill(simple_skill) # add error skill to AEA error_skill = Skill.from_dir(os.path.join(AEA_DIR, "skills", "error")) resources.add_skill(error_skill) # start AEA thread t_aea = Thread(target=aea.start) try: t_aea.start() time.sleep(1.0) aea.outbox.put(request_envelope) time.sleep(5.0) assert (aea_handler.handled_message.performative == HttpMessage.Performative.RESPONSE) assert aea_handler.handled_message.version == "" assert aea_handler.handled_message.status_code == 200 assert aea_handler.handled_message.status_text == "OK" assert aea_handler.handled_message.headers is not None assert aea_handler.handled_message.version is not None finally: aea.stop() t_aea.join()
def component_configuration(): """Return a component configuration.""" return ProtocolConfig("a_protocol", "an_author", "0.1.0")
async def test_end_to_end_aea_aca(self): """Test the end to end aea aca interaction.""" # AEA components wallet = Wallet({DEFAULT_LEDGER: DEFAULT_PRIVATE_KEY_FILE}) identity = Identity( name="my_aea_1", address=wallet.addresses.get(DEFAULT_LEDGER), default_address_key=DEFAULT_LEDGER, ) configuration = ConnectionConfig( host=self.aca_admin_address, port=self.aca_admin_port, connection_id=HTTPClientConnection.connection_id, ) http_client_connection = HTTPClientConnection( configuration=configuration, identity=identity, ) resources = Resources() resources.add_connection(http_client_connection) # create AEA aea = AEA(identity, wallet, resources) # Add http protocol to AEA resources http_protocol_configuration = ProtocolConfig.from_json( yaml.safe_load( open( os.path.join( self.cwd, "packages", "fetchai", "protocols", "http", "protocol.yaml", )))) http_protocol = Protocol(http_protocol_configuration, HttpMessage.serializer()) resources.add_protocol(http_protocol) # Request message & envelope request_http_message = HttpMessage( dialogue_reference=("", ""), target=0, message_id=1, performative=HttpMessage.Performative.REQUEST, method="GET", url="http://{}:{}/status".format(self.aca_admin_address, self.aca_admin_port), headers="", version="", body=b"", ) request_http_message.to = "ACA" request_envelope = Envelope( to="ACA", sender="AEA", protocol_id=HttpMessage.protocol_id, message=request_http_message, ) # add a simple skill with handler skill_context = SkillContext(aea.context) skill_config = SkillConfig(name="simple_skill", author="fetchai", version="0.1.0") aea_handler = AEAHandler(skill_context=skill_context, name="aea_handler") simple_skill = Skill(skill_config, skill_context, handlers={aea_handler.name: aea_handler}) resources.add_skill(simple_skill) # add error skill to AEA error_skill = Skill.from_dir(os.path.join(AEA_DIR, "skills", "error"), agent_context=aea.context) resources.add_skill(error_skill) # start AEA thread t_aea = Thread(target=aea.start) try: t_aea.start() time.sleep(1.0) aea.outbox.put(request_envelope) time.sleep(5.0) assert (aea_handler.handled_message.performative == HttpMessage.Performative.RESPONSE) assert aea_handler.handled_message.version == "" assert aea_handler.handled_message.status_code == 200 assert aea_handler.handled_message.status_text == "OK" assert aea_handler.handled_message.headers is not None assert aea_handler.handled_message.version is not None finally: aea.stop() t_aea.join()
def setup_class(cls): """Set the test up.""" cls.node = LocalNode() cls.node.start() cls.agent_name = "MyAgent" cls.private_key_path = os.path.join(CUR_PATH, "data", "fet_private_key.txt") cls.wallet = Wallet({FETCHAI: cls.private_key_path}) cls.ledger_apis = LedgerApis({}, FETCHAI) cls.identity = Identity(cls.agent_name, address=cls.wallet.addresses[FETCHAI]) cls.connection = OEFLocalConnection( cls.agent_name, cls.node, connection_id=LOCAL_CONNECTION_PUBLIC_ID) cls.connections = [cls.connection] cls.temp = tempfile.mkdtemp(prefix="test_aea_resources") cls.resources = Resources(cls.temp) cls.aea = AEA( cls.identity, cls.connections, cls.wallet, cls.ledger_apis, resources=cls.resources, ) default_protocol_id = DefaultMessage.protocol_id cls.default_protocol_configuration = ProtocolConfig.from_json( yaml.safe_load( open(Path(AEA_DIR, "protocols", "default", "protocol.yaml")))) cls.default_protocol = Protocol(default_protocol_id, DefaultSerializer(), cls.default_protocol_configuration) cls.resources.protocol_registry.register(default_protocol_id, 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( dialogue_reference=("", ""), message_id=1, target=0, performative=DefaultMessage.Performative.BYTES, content=b"hello", ) cls.expected_message.counterparty = cls.agent_name 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_protocol_id, message=DefaultSerializer().encode(cls.expected_message), ))
def test_generated_protocol_end_to_end(self): """Test that a generated protocol could be used in exchanging messages between two agents.""" # AEA components ledger_apis = LedgerApis({}, FETCHAI) wallet_1 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE}) wallet_2 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE}) identity_1 = Identity( name="my_aea_1", address=wallet_1.addresses.get(FETCHAI), default_address_key=FETCHAI, ) identity_2 = Identity( name="my_aea_2", address=wallet_2.addresses.get(FETCHAI), default_address_key=FETCHAI, ) oef_connection_1 = OEFConnection( address=identity_1.address, oef_addr=HOST, oef_port=PORT ) oef_connection_2 = OEFConnection( address=identity_2.address, oef_addr=HOST, oef_port=PORT ) resources_1 = Resources() resources_2 = Resources() # add generated protocols to resources generated_protocol_configuration = ProtocolConfig.from_json( yaml.safe_load( open( os.path.join( self.cwd, "tests", "data", "generator", "two_party_negotiation", "protocol.yaml", ) ) ) ) generated_protocol = Protocol( TwoPartyNegotiationMessage.protocol_id, TwoPartyNegotiationSerializer(), generated_protocol_configuration, ) resources_1.protocol_registry.register( TwoPartyNegotiationMessage.protocol_id, generated_protocol ) resources_2.protocol_registry.register( TwoPartyNegotiationMessage.protocol_id, generated_protocol ) # create AEAs aea_1 = AEA(identity_1, [oef_connection_1], wallet_1, ledger_apis, resources_1) aea_2 = AEA(identity_2, [oef_connection_2], wallet_2, ledger_apis, resources_2) inform_number = tuple((1370, 1991, 1, 4, 17, 6)) # message 1 message = TwoPartyNegotiationMessage( message_id=1, dialogue_reference=(str(0), ""), target=0, performative=TwoPartyNegotiationMessage.Performative.INFORM, inform_number=inform_number, ) encoded_message_in_bytes = TwoPartyNegotiationSerializer().encode(message) envelope = Envelope( to=identity_2.address, sender=identity_1.address, protocol_id=TwoPartyNegotiationMessage.protocol_id, message=encoded_message_in_bytes, ) # message 2 reply_message = {1: "number one", 2: "number two", 7: "number seven"} message_2 = TwoPartyNegotiationMessage( message_id=2, dialogue_reference=(str(0), ""), target=1, performative=TwoPartyNegotiationMessage.Performative.INFORM_REPLY, reply_message=reply_message, ) encoded_message_2_in_bytes = TwoPartyNegotiationSerializer().encode(message_2) # add handlers to AEA resources agent_1_handler = Agent1Handler( skill_context=SkillContext(aea_1.context), name="fake_skill" ) resources_1.handler_registry.register( ( PublicId.from_str("fetchai/fake_skill:0.1.0"), TwoPartyNegotiationMessage.protocol_id, ), agent_1_handler, ) agent_2_handler = Agent2Handler( encoded_messsage=encoded_message_2_in_bytes, skill_context=SkillContext(aea_2.context), name="fake_skill", ) resources_2.handler_registry.register( ( PublicId.from_str("fetchai/fake_skill:0.1.0"), TwoPartyNegotiationMessage.protocol_id, ), agent_2_handler, ) # add error skill to AEAs error_skill_1 = Skill.from_dir( os.path.join(AEA_DIR, "skills", "error"), aea_1.context ) resources_1.add_skill(error_skill_1) error_skill_2 = Skill.from_dir( os.path.join(AEA_DIR, "skills", "error"), aea_2.context ) resources_2.add_skill(error_skill_2) # 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.inform_number == message.inform_number ), "Message from Agent 1 to 2: inform_numbers 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.reply_message == message_2.reply_message ), "Message from Agent 1 to 2: reply_messages do not match" time.sleep(2.0) finally: aea_1.stop() aea_2.stop() t_1.join() t_2.join()
def test_protocols_config(self): """Test the protocol config.""" protocol = Protocol(id="test", serializer=cast(Serializer, ProtobufSerializer), config=ProtocolConfig()) assert protocol.config is not None