async def test_send(self): """Test the connect functionality of the webhook connection.""" await self.webhook_connection.connect() assert self.webhook_connection.connection_status.is_connected is True http_message = HttpMessage( dialogue_reference=("", ""), target=0, message_id=1, performative=HttpMessage.Performative.REQUEST, method="get", url="/", headers="", bodyy="", version="", ) envelope = Envelope( to="addr", sender="my_id", protocol_id=PublicId.from_str("fetchai/http:0.3.0"), message=http_message, ) await self.webhook_connection.send(envelope)
def setup_class(cls): """Set the tests up.""" cls.patch = unittest.mock.patch.object(aea.registries.base.logger, "exception") cls.mocked_logger = cls.patch.start() cls.oldcwd = os.getcwd() cls.agent_name = "agent_dir_test" cls.t = tempfile.mkdtemp() cls.agent_folder = os.path.join(cls.t, cls.agent_name) shutil.copytree(os.path.join(CUR_PATH, "data", "dummy_aea"), cls.agent_folder) os.chdir(cls.agent_folder) contract = Contract.from_dir( str(Path(ROOT_DIR, "packages", "fetchai", "contracts", "erc1155"))) cls.registry = ContractRegistry() cls.registry.register(contract.configuration.public_id, cast(Contract, contract)) cls.expected_contract_ids = { PublicId.from_str("fetchai/erc1155:0.3.0"), }
def __init__( self, address: Address, oef_addr: str, oef_port: int = 10000, *args, **kwargs ): """ Initialize. :param address: the address of the agent. :param oef_addr: the OEF IP address. :param oef_port: the OEF port. :param connection_id: the identifier of the connection object. :param restricted_to_protocols: the only supported protocols for this connection. :param excluded_protocols: the excluded protocols for this connection. """ if kwargs.get("connection_id") is None: kwargs["connection_id"] = PublicId("fetchai", "oef", "0.1.0") super().__init__(*args, **kwargs) self._core = AsyncioCore(logger=logger) # type: AsyncioCore self.in_queue = None # type: Optional[asyncio.Queue] self.channel = OEFChannel( address, oef_addr, oef_port, core=self._core, ) # type: ignore self._connection_check_thread = None # type: Optional[Thread]
def __init__(self, provider_addr: str, provider_port: int = 8000, **kwargs): """ Initialize a connection to an SDK or API. :param provider_addr: the provider address. :param provider_port: the provider port. :param kwargs: keyword argument for the parent class. """ if kwargs.get("configuration") is None and kwargs.get( "connection_id") is None: kwargs["connection_id"] = PublicId("fetchai", "p2p_client", "0.1.0") super().__init__(**kwargs) provider_addr = provider_addr provider_port = provider_port self.channel = PeerToPeerChannel( self.address, provider_addr, provider_port, excluded_protocols=self.excluded_protocols) # type: ignore
def test_add_behaviour_dynamically(): """Test that we can add a behaviour dynamically.""" agent_name = "MyAgent" private_key_path = os.path.join(CUR_PATH, "data", DEFAULT_PRIVATE_KEY_FILE) wallet = Wallet({DEFAULT_LEDGER: private_key_path}) resources = Resources() identity = Identity(agent_name, address=wallet.addresses[DEFAULT_LEDGER]) connection = _make_local_connection(identity.address, LocalNode()) agent = AEA( identity, wallet, resources, default_connection=connection.public_id, ) resources.add_connection(connection) resources.add_component( Skill.from_dir(Path(CUR_PATH, "data", "dummy_skill"), agent_context=agent.context)) for skill in resources.get_all_skills(): skill.skill_context.set_agent_context(agent.context) with run_in_thread(agent.start, timeout=5, on_exit=agent.stop): wait_for_condition(lambda: agent.is_running, timeout=10) dummy_skill_id = PublicId("dummy_author", "dummy", "0.1.0") dummy_skill = agent.resources.get_skill(dummy_skill_id) wait_for_condition(lambda: dummy_skill is not None, timeout=10) new_behaviour = DummyBehaviour(name="dummy2", skill_context=dummy_skill.skill_context) dummy_skill.skill_context.new_behaviours.put(new_behaviour) wait_for_condition(lambda: new_behaviour.nb_act_called > 0, timeout=10) wait_for_condition( lambda: len(agent.resources.get_behaviours(dummy_skill_id)) == 2, timeout=10)
def __init__(self, api_key: str, soef_addr: str = "127.0.0.1", soef_port: int = 10001, **kwargs): """ Initialize. :param api_key: the SOEF API key :param soef_addr: the SOEF IP address. :param soef_port: the SOEF port. :param kwargs: the keyword arguments (check the parent constructor) """ if kwargs.get("configuration") is None and kwargs.get( "connection_id") is None: kwargs["connection_id"] = PUBLIC_ID if (kwargs.get("configuration") is None and kwargs.get("excluded_protocols") is None): kwargs["excluded_protocols"] = [] if (kwargs.get("configuration") is None and kwargs.get("restricted_to_protocols") is None): kwargs["restricted_to_protocols"] = [ PublicId.from_str("fetchai/oef_search:0.1.0") ] super().__init__(**kwargs) self.api_key = api_key self.soef_addr = soef_addr self.soef_port = soef_port self.in_queue = None # type: Optional[asyncio.Queue] self.channel = SOEFChannel( self.address, self.api_key, self.soef_addr, self.soef_port, self.excluded_protocols, self.restricted_to_protocols, )
def test_send_message(self): """Test that the messages in the outbox are posted on the output 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), ) self.multiplexer.put(expected_envelope) time.sleep(0.1) with open(self.output_file_path, "rb+") as f: lines = f.readlines() assert len(lines) == 2 line = lines[0] + lines[1] to, sender, protocol_id, message, end = line.strip().split(b",", maxsplit=4) to = to.decode("utf-8") sender = sender.decode("utf-8") protocol_id = PublicId.from_str(protocol_id.decode("utf-8")) assert end in [b"", b"\n"] actual_envelope = Envelope(to=to, sender=sender, protocol_id=protocol_id, message=message) assert expected_envelope == actual_envelope
async def test_messages(self): """Test that at the beginning, the search request returns an empty search result.""" msg = FIPAMessage((str(0), ""), 0, 0, FIPAMessage.Performative.CFP, query=None) msg_bytes = FIPASerializer().encode(msg) envelope = Envelope( to=DEFAULT_OEF, sender=self.address_1, protocol_id=FIPAMessage.protocol_id, message=msg_bytes, ) with pytest.raises(AEAConnectionError): await OEFLocalConnection( self.address_1, self.node, connection_id=PublicId("fetchai", "local", "0.1.0"), ).send(envelope) self.multiplexer1.connect() msg = FIPAMessage( (str(0), str(1)), 0, 0, FIPAMessage.Performative.CFP, query=None ) msg_bytes = FIPASerializer().encode(msg) envelope = Envelope( to="this_address_does_not_exist", sender=self.address_1, protocol_id=FIPAMessage.protocol_id, message=msg_bytes, ) self.multiplexer1.put(envelope) # check the result response_envelope = self.multiplexer1.get(block=True, timeout=5.0) assert response_envelope.protocol_id == OEFMessage.protocol_id assert response_envelope.sender == DEFAULT_OEF result = OEFSerializer().decode(response_envelope.message) assert result.get("type") == OEFMessage.Type.DIALOGUE_ERROR
def test_transaction_is_not_affordable(self): """Test if the transaction is affordable on the ledger.""" tx_message = TransactionMessage( performative=TransactionMessage.Performative. PROPOSE_FOR_SETTLEMENT, skill_callback_ids=[PublicId(AUTHOR, "a_skill", "0.1.0")], tx_id="transaction0", tx_sender_addr="agent_1", tx_counterparty_addr="pk", tx_amount_by_currency_id={"FET": -20}, tx_sender_fee=0, tx_counterparty_fee=0, tx_quantities_by_good_id={"good_id": 10}, ledger_id="off_chain", info={"some_info_key": "some_info_value"}, tx_nonce="Transaction nonce", ) with mock.patch.object(self.ledger_state_proxy.ledger_apis, "token_balance", return_value=0): result = self.ledger_state_proxy.is_affordable_transaction( tx_message=tx_message) assert not result
class TestConnection(Connection): """Test class for Connection.""" connection_id = PublicId.from_str("fetchai/some_connection:0.1.0") def connect(self, *args, **kwargs): """Connect.""" pass def disconnect(self, *args, **kwargs): """Disconnect.""" pass def from_config(self, *args, **kwargs): """From config.""" pass def receive(self, *args, **kwargs): """Receive.""" pass def send(self, *args, **kwargs): """Send.""" pass
def bump_package_version( current_public_id: PublicId, configuration_file_path: Path, type_: str, is_ambiguous: bool = False, ) -> None: """ Bump the version references of the package in the repo. Includes, bumping the package itself. """ ver = semver.VersionInfo.parse(current_public_id.version) new_version = str(ver.bump_minor()) new_public_id = PublicId( current_public_id.author, current_public_id.name, new_version ) for rootdir in DIRECTORIES: for path in Path(rootdir).glob("**/*"): if path.is_file() and str(path).endswith((".py", ".yaml", ".md")): inplace_change( path, current_public_id, new_public_id, type_, is_ambiguous, ) bump_version_in_yaml(configuration_file_path, type_, new_public_id.version)
def _split_component_id_and_config( component_index: int, component_configuration_json: Dict) -> ComponentId: """ Split component id and configuration. :param component_index: the position of the component configuration in the agent config file.. :param component_configuration_json: the JSON object to process. :return: the component id and the configuration object. :raises ValueError: if the component id cannot be extracted. """ # author, name, version, type are mandatory fields missing_fields = {"public_id", "type" }.difference(component_configuration_json.keys()) if len(missing_fields) > 0: raise ValueError( f"There are missing fields in component id {component_index + 1}: {missing_fields}." ) public_id_str = component_configuration_json.pop("public_id") component_type = ComponentType( component_configuration_json.pop("type")) component_public_id = PublicId.from_str(public_id_str) component_id = ComponentId(component_type, component_public_id) return component_id
def setup_class(cls): """Set the test up.""" cls.runner = CliRunner() cls.agent_name = "myagent" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() cls.skill_id = PublicId.from_str("fetchai/error:0.4.0") cls.skill_name = cls.skill_id.name cls.skill_author = cls.skill_id.author cls.skill_version = cls.skill_id.version # copy the 'packages' directory in the parent of the agent folder. shutil.copytree(Path(CUR_PATH, "..", "packages"), Path(cls.t, "packages")) os.chdir(cls.t) result = cls.runner.invoke( cli, [*CLI_LOG_OPTION, "init", "--local", "--author", AUTHOR]) assert result.exit_code == 0 result = cls.runner.invoke( cli, [*CLI_LOG_OPTION, "create", "--local", cls.agent_name], standalone_mode=False, ) # this also by default adds the oef skill and error skill assert result.exit_code == 0 os.chdir(cls.agent_name) # add the error skill again cls.result = cls.runner.invoke( cli, [*CLI_LOG_OPTION, "add", "--local", "skill", str(cls.skill_id)], standalone_mode=False, )
def test_handle_message_signing_ethereum_deprecated(self): """Test message signing for ethereum deprecated.""" message = b"0x11f3f9487724404e3a1fb7252a3226" signing_dialogues = SigningDialogues("agent") signing_msg = SigningMessage( performative=SigningMessage.Performative.SIGN_MESSAGE, dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(), skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),), skill_callback_info={}, terms=Terms( ledger_id=ETHEREUM, sender_address="pk1", counterparty_address="pk2", amount_by_currency_id={"FET": -1}, is_sender_payable_tx_fee=True, quantities_by_good_id={"good_id": 10}, nonce="transaction nonce", ), raw_message=RawMessage(ETHEREUM, message, is_deprecated_mode=True), ) signing_msg.counterparty = "decision_maker" signing_dialogue = signing_dialogues.update(signing_msg) assert signing_dialogue is not None self.decision_maker.message_in_queue.put_nowait(signing_msg) signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2) signing_msg_response.counterparty = signing_msg.counterparty signing_msg_response.is_incoming = True recovered_dialogue = signing_dialogues.update(signing_msg_response) assert recovered_dialogue is not None and recovered_dialogue == signing_dialogue assert ( signing_msg_response.performative == SigningMessage.Performative.SIGNED_MESSAGE ) assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids assert type(signing_msg_response.signed_message) == SignedMessage assert signing_msg_response.signed_message.is_deprecated_mode
def setup_class(cls): """Set the tests up.""" # cls._patch_logger() # noqa: E800 # create temp agent folder cls.oldcwd = os.getcwd() cls.agent_name = "agent_test" + str(random.randint(0, 1000)) # nosec cls.t = tempfile.mkdtemp() cls.agent_folder = os.path.join(cls.t, cls.agent_name) shutil.copytree(os.path.join(CUR_PATH, "data", "dummy_aea"), cls.agent_folder) os.chdir(cls.agent_folder) cls.resources = Resources() cls.resources.add_component( Protocol.from_dir( Path(ROOT_DIR, "packages", "fetchai", "protocols", "default") ) ) cls.resources.add_component( Skill.from_dir( Path(CUR_PATH, "data", "dummy_skill"), agent_context=MagicMock(agent_name="name"), ) ) cls.resources.add_component( Skill.from_dir( Path(ROOT_DIR, "packages", "fetchai", "skills", "error"), agent_context=MagicMock(agent_name="name"), ) ) cls.error_skill_public_id = ERROR_SKILL_PUBLIC_ID cls.dummy_skill_public_id = PublicId.from_str("dummy_author/dummy:0.1.0") cls.contract_public_id = ERC1155_PUBLIC_ID
def setup_class(cls): """Set the tests up.""" cls._patch_logger() # create temp agent folder cls.oldcwd = os.getcwd() cls.agent_name = "agent_test" + str(random.randint(0, 1000)) # nosec cls.t = tempfile.mkdtemp() cls.agent_folder = os.path.join(cls.t, cls.agent_name) shutil.copytree(os.path.join(CUR_PATH, "data", "dummy_aea"), cls.agent_folder) os.chdir(cls.agent_folder) cls.resources = Resources(os.path.join(cls.agent_folder)) cls.resources.add_component( Protocol.from_dir(Path(aea.AEA_DIR, "protocols", "default"))) # cls.resources.add_component(Component.load_from_directory(ComponentType.PROTOCOL, Path(ROOT_DIR, "packages", "fetchai", "protocols", "oef_search"))) cls.resources.add_component( Skill.from_dir(Path(CUR_PATH, "data", "dummy_skill"))) cls.resources.add_component( Skill.from_dir(Path(aea.AEA_DIR, "skills", "error"))) cls.error_skill_public_id = PublicId("fetchai", "error", "0.1.0") cls.dummy_skill_public_id = PublicId.from_str( "dummy_author/dummy:0.1.0") cls.expected_skills = { PublicId("fetchai", "dummy", "0.1.0"), PublicId("fetchai", "error", "0.1.0"), } cls.expected_protocols = { PublicId("fetchai", "default", "0.1.0"), PublicId("fetchai", "oef_search", "0.1.0"), }
# -*- coding: utf-8 -*- # ------------------------------------------------------------------------------ # # Copyright 2018-2019 Fetch.AI Limited # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # ------------------------------------------------------------------------------ """This module contains the implementation of the error skill.""" from aea.configurations.base import PublicId PUBLIC_ID = PublicId.from_str("fetchai/error:0.11.0")
def test_public_id_lt_positive(self): """Test case for json __lt__ method positive result.""" obj1 = PublicId(AUTHOR, "name", "1.0.0") obj2 = PublicId(AUTHOR, "name", "2.0.0") self.assertTrue(obj1 < obj2)
def test_public_id_json_positive(self): """Test case for json property positive result.""" obj = PublicId(AUTHOR, "name", "0.1.0") obj.json
def test_public_id_from_json_positive(self): """Test case for from_json method positive result.""" obj = {"author": AUTHOR, "name": "name", "version": "0.1.0"} PublicId.from_json(obj)
def test_public_id_from_str_not_matching(self, *mocks): """Test case for from_str method regex not matching.""" with self.assertRaises(ValueError): PublicId.from_str("public_id_str")
# -*- coding: utf-8 -*- # ------------------------------------------------------------------------------ # # Copyright 2018-2019 Fetch.AI Limited # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # ------------------------------------------------------------------------------ """This module contains the implementation of the simple oracle skill.""" from aea.configurations.base import PublicId PUBLIC_ID = PublicId.from_str("fetchai/simple_oracle:0.5.0")
class FipaMessage(Message): """A protocol for FIPA ACL.""" protocol_id = PublicId.from_str("fetchai/fipa:0.14.0") protocol_specification_id = PublicId.from_str("fetchai/fipa:0.1.0") Description = CustomDescription Query = CustomQuery class Performative(Message.Performative): """Performatives for the fipa protocol.""" ACCEPT = "accept" ACCEPT_W_INFORM = "accept_w_inform" CFP = "cfp" DECLINE = "decline" END = "end" INFORM = "inform" MATCH_ACCEPT = "match_accept" MATCH_ACCEPT_W_INFORM = "match_accept_w_inform" PROPOSE = "propose" def __str__(self) -> str: """Get the string representation.""" return str(self.value) _performatives = { "accept", "accept_w_inform", "cfp", "decline", "end", "inform", "match_accept", "match_accept_w_inform", "propose", } __slots__: Tuple[str, ...] = tuple() class _SlotsCls: __slots__ = ( "dialogue_reference", "info", "message_id", "performative", "proposal", "query", "target", ) def __init__( self, performative: Performative, dialogue_reference: Tuple[str, str] = ("", ""), message_id: int = 1, target: int = 0, **kwargs: Any, ): """ Initialise an instance of FipaMessage. :param message_id: the message id. :param dialogue_reference: the dialogue reference. :param target: the message target. :param performative: the message performative. """ super().__init__( dialogue_reference=dialogue_reference, message_id=message_id, target=target, performative=FipaMessage.Performative(performative), **kwargs, ) @property def valid_performatives(self) -> Set[str]: """Get valid performatives.""" return self._performatives @property def dialogue_reference(self) -> Tuple[str, str]: """Get the dialogue_reference of the message.""" enforce(self.is_set("dialogue_reference"), "dialogue_reference is not set.") return cast(Tuple[str, str], self.get("dialogue_reference")) @property def message_id(self) -> int: """Get the message_id of the message.""" enforce(self.is_set("message_id"), "message_id is not set.") return cast(int, self.get("message_id")) @property def performative(self) -> Performative: # type: ignore # noqa: F821 """Get the performative of the message.""" enforce(self.is_set("performative"), "performative is not set.") return cast(FipaMessage.Performative, self.get("performative")) @property def target(self) -> int: """Get the target of the message.""" enforce(self.is_set("target"), "target is not set.") return cast(int, self.get("target")) @property def info(self) -> Dict[str, str]: """Get the 'info' content from the message.""" enforce(self.is_set("info"), "'info' content is not set.") return cast(Dict[str, str], self.get("info")) @property def proposal(self) -> CustomDescription: """Get the 'proposal' content from the message.""" enforce(self.is_set("proposal"), "'proposal' content is not set.") return cast(CustomDescription, self.get("proposal")) @property def query(self) -> CustomQuery: """Get the 'query' content from the message.""" enforce(self.is_set("query"), "'query' content is not set.") return cast(CustomQuery, self.get("query")) def _is_consistent(self) -> bool: """Check that the message follows the fipa protocol.""" try: enforce( type(self.dialogue_reference) == tuple, "Invalid type for 'dialogue_reference'. Expected 'tuple'. Found '{}'.".format( type(self.dialogue_reference) ), ) enforce( type(self.dialogue_reference[0]) == str, "Invalid type for 'dialogue_reference[0]'. Expected 'str'. Found '{}'.".format( type(self.dialogue_reference[0]) ), ) enforce( type(self.dialogue_reference[1]) == str, "Invalid type for 'dialogue_reference[1]'. Expected 'str'. Found '{}'.".format( type(self.dialogue_reference[1]) ), ) enforce( type(self.message_id) == int, "Invalid type for 'message_id'. Expected 'int'. Found '{}'.".format( type(self.message_id) ), ) enforce( type(self.target) == int, "Invalid type for 'target'. Expected 'int'. Found '{}'.".format( type(self.target) ), ) # Light Protocol Rule 2 # Check correct performative enforce( type(self.performative) == FipaMessage.Performative, "Invalid 'performative'. Expected either of '{}'. Found '{}'.".format( self.valid_performatives, self.performative ), ) # Check correct contents actual_nb_of_contents = len(self._body) - DEFAULT_BODY_SIZE expected_nb_of_contents = 0 if self.performative == FipaMessage.Performative.CFP: expected_nb_of_contents = 1 enforce( type(self.query) == CustomQuery, "Invalid type for content 'query'. Expected 'Query'. Found '{}'.".format( type(self.query) ), ) elif self.performative == FipaMessage.Performative.PROPOSE: expected_nb_of_contents = 1 enforce( type(self.proposal) == CustomDescription, "Invalid type for content 'proposal'. Expected 'Description'. Found '{}'.".format( type(self.proposal) ), ) elif self.performative == FipaMessage.Performative.ACCEPT_W_INFORM: expected_nb_of_contents = 1 enforce( type(self.info) == dict, "Invalid type for content 'info'. Expected 'dict'. Found '{}'.".format( type(self.info) ), ) for key_of_info, value_of_info in self.info.items(): enforce( type(key_of_info) == str, "Invalid type for dictionary keys in content 'info'. Expected 'str'. Found '{}'.".format( type(key_of_info) ), ) enforce( type(value_of_info) == str, "Invalid type for dictionary values in content 'info'. Expected 'str'. Found '{}'.".format( type(value_of_info) ), ) elif self.performative == FipaMessage.Performative.MATCH_ACCEPT_W_INFORM: expected_nb_of_contents = 1 enforce( type(self.info) == dict, "Invalid type for content 'info'. Expected 'dict'. Found '{}'.".format( type(self.info) ), ) for key_of_info, value_of_info in self.info.items(): enforce( type(key_of_info) == str, "Invalid type for dictionary keys in content 'info'. Expected 'str'. Found '{}'.".format( type(key_of_info) ), ) enforce( type(value_of_info) == str, "Invalid type for dictionary values in content 'info'. Expected 'str'. Found '{}'.".format( type(value_of_info) ), ) elif self.performative == FipaMessage.Performative.INFORM: expected_nb_of_contents = 1 enforce( type(self.info) == dict, "Invalid type for content 'info'. Expected 'dict'. Found '{}'.".format( type(self.info) ), ) for key_of_info, value_of_info in self.info.items(): enforce( type(key_of_info) == str, "Invalid type for dictionary keys in content 'info'. Expected 'str'. Found '{}'.".format( type(key_of_info) ), ) enforce( type(value_of_info) == str, "Invalid type for dictionary values in content 'info'. Expected 'str'. Found '{}'.".format( type(value_of_info) ), ) elif self.performative == FipaMessage.Performative.ACCEPT: expected_nb_of_contents = 0 elif self.performative == FipaMessage.Performative.DECLINE: expected_nb_of_contents = 0 elif self.performative == FipaMessage.Performative.MATCH_ACCEPT: expected_nb_of_contents = 0 elif self.performative == FipaMessage.Performative.END: expected_nb_of_contents = 0 # Check correct content count enforce( expected_nb_of_contents == actual_nb_of_contents, "Incorrect number of contents. Expected {}. Found {}".format( expected_nb_of_contents, actual_nb_of_contents ), ) # Light Protocol Rule 3 if self.message_id == 1: enforce( self.target == 0, "Invalid 'target'. Expected 0 (because 'message_id' is 1). Found {}.".format( self.target ), ) except (AEAEnforceError, ValueError, KeyError) as e: _default_logger.error(str(e)) return False return True
def extract_package_id(match: Match) -> PackageId: package_public_id = match.group(1) package_id = PackageId(PackageType.AGENT, PublicId.from_str(package_public_id)) return package_id
def extract_package_id(match: Match) -> PackageId: package_type, package = match.group(1), match.group(2) package_id = PackageId(PackageType(package_type), PublicId.from_str(package)) return package_id
def test_fetch(self): """Test that the `fetch` method works as expected.""" contract_id = PublicId.from_str("fetchai/erc1155:0.6.0") contract = self.registry.fetch(ComponentId(ComponentType.CONTRACT, contract_id)) assert isinstance(contract, Contract) assert contract.id == contract_id
def test_unregister_by_skill_when_item_not_registered(self): """Test 'unregister_by_skill' in case the item is not registered.""" with pytest.raises( ValueError, match="No component of skill .* present in the registry." ): self.registry.unregister_by_skill(PublicId.from_str("author/skill:0.1.0"))
def test_unregister_when_item_not_registered(self): """Test 'unregister' in case the item is not registered.""" with pytest.raises(ValueError): self.registry.unregister( (PublicId.from_str("author/name:0.1.0"), "component_name") )
# # ------------------------------------------------------------------------------ """This module contains the class to connect to an Oracle contract.""" import logging from typing import Any, Dict from vyper.utils import keccak256 from aea.common import Address, JSONLike from aea.configurations.base import PublicId from aea.contracts.base import Contract from aea.crypto.base import LedgerApi from aea.crypto.ethereum import EthereumApi PUBLIC_ID = PublicId.from_str("fetchai/oracle:0.4.0") CONTRACT_ROLE = keccak256(b"ORACLE_ROLE") _default_logger = logging.getLogger( "aea.packages.fetchai.contracts.oracle.contract") class FetchOracleContract(Contract): """The Fetch oracle contract.""" @classmethod def get_grant_role_transaction( cls, ledger_api: LedgerApi, contract_address: Address, oracle_address: Address, gas: int = 0,
def test_handle_messages_from_two_dialogues_same_agent(self): """Test message signing for unknown.""" message = b"0x11f3f9487724404e3a1fb7252a322656b90ba0455a2ca5fcdcbe6eeee5f8126d" signing_dialogues = SigningDialogues("agent") dialogue_reference = signing_dialogues.new_self_initiated_dialogue_reference() signing_msg = SigningMessage( performative=SigningMessage.Performative.SIGN_MESSAGE, dialogue_reference=dialogue_reference, skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),), skill_callback_info={}, terms=Terms( ledger_id="unknown", sender_address="pk1", counterparty_address="pk2", amount_by_currency_id={"FET": -1}, is_sender_payable_tx_fee=True, quantities_by_good_id={"good_id": 10}, nonce="transaction nonce", ), raw_message=RawMessage("unknown", message), ) signing_msg.counterparty = "decision_maker" signing_dialogue = signing_dialogues.update(signing_msg) assert signing_dialogue is not None self.decision_maker.message_in_queue.put_nowait(signing_msg) signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2) assert signing_msg_response is not None signing_dialogues = SigningDialogues("agent") signing_msg = SigningMessage( performative=SigningMessage.Performative.SIGN_MESSAGE, dialogue_reference=dialogue_reference, skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),), skill_callback_info={}, terms=Terms( ledger_id="unknown", sender_address="pk1", counterparty_address="pk2", amount_by_currency_id={"FET": -1}, is_sender_payable_tx_fee=True, quantities_by_good_id={"good_id": 10}, nonce="transaction nonce", ), raw_message=RawMessage("unknown", message), ) signing_msg.counterparty = "decision_maker" signing_dialogue = signing_dialogues.update(signing_msg) assert signing_dialogue is not None with pytest.raises(Exception): # Exception occurs because the same counterparty sends two identical dialogue references self.decision_maker.message_out_queue.get(timeout=1) # test twice; should work again even from same agent signing_dialogues = SigningDialogues("agent") signing_msg = SigningMessage( performative=SigningMessage.Performative.SIGN_MESSAGE, dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(), skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),), skill_callback_info={}, terms=Terms( ledger_id="unknown", sender_address="pk1", counterparty_address="pk2", amount_by_currency_id={"FET": -1}, is_sender_payable_tx_fee=True, quantities_by_good_id={"good_id": 10}, nonce="transaction nonce", ), raw_message=RawMessage("unknown", message), ) signing_msg.counterparty = "decision_maker" signing_dialogue = signing_dialogues.update(signing_msg) assert signing_dialogue is not None self.decision_maker.message_in_queue.put_nowait(signing_msg) signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2) assert signing_msg_response is not None