def test_component_id_same_prefix():
"""Test ComponentId.same_prefix"""
component_id_1 = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.1.0"))
component_id_2 = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.2.0"))
assert component_id_1.same_prefix(component_id_2)
def setup_class(cls):
"""Set up the test."""
cls.expected_custom_component_configuration = dict(foo="bar")
cls.agent_config = AgentConfig(
agent_name="agent_name",
author="author",
version="0.1.0",
default_routing={
str(cls.old_protocol_id): str(cls.old_connection_id)
},
default_connection=str(cls.old_connection_id),
)
cls.agent_config.protocols = {cls.old_protocol_id}
cls.agent_config.contracts = {cls.old_contract_id}
cls.agent_config.connections = {cls.old_connection_id}
cls.agent_config.skills = {cls.old_skill_id}
cls.agent_config.component_configurations[ComponentId(
ComponentType.PROTOCOL,
cls.old_protocol_id)] = cls.expected_custom_component_configuration
cls.agent_config.component_configurations[ComponentId(
ComponentType.CONTRACT,
cls.old_contract_id)] = cls.expected_custom_component_configuration
cls.agent_config.component_configurations[ComponentId(
ComponentType.CONNECTION, cls.old_connection_id
)] = cls.expected_custom_component_configuration
cls.agent_config.component_configurations[ComponentId(
ComponentType.SKILL,
cls.old_skill_id)] = cls.expected_custom_component_configuration
replace_component_ids(cls.agent_config, cls.replacements)
def test_register_when_component_id_mismatch(self):
"""Test AgentComponentRegistry.register when the component ids mismatch."""
component_id_1 = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.1.0"))
component_id_2 = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.2.0"))
component_mock = MagicMock(component_id=component_id_1)
with pytest.raises(
ValueError,
match="Component id '.*' is different to the id '.*' specified."
):
self.registry.register(component_id_2, component_mock)
self.registry._registered_keys = set()
def setup(self):
"""Set up the tests."""
self.aea_config_path = Path(CUR_PATH, "data", "dummy_aea",
DEFAULT_AEA_CONFIG_FILE)
self.loader = ConfigLoaders.from_package_type(PackageType.AGENT)
self.aea_config: AgentConfig = self.loader.load(
self.aea_config_path.open())
self.dummy_skill_component_id = ComponentId(ComponentType.SKILL,
DUMMY_SKILL_PUBLIC_ID)
self.new_dummy_skill_config = {
"behaviours": {
"dummy": {
"args": dict(behaviour_arg_1=42)
}
},
"handlers": {
"dummy": {
"args": dict(handler_arg_1=42)
}
},
"models": {
"dummy": {
"args": dict(model_arg_1=42)
}
},
}
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_override_ledger_configurations_positive():
"""Test override ledger configurations function util with fields to override."""
new_chain_id = "some_chain"
agent_config = MagicMock()
agent_config.component_configurations = {
ComponentId(ComponentType.CONNECTION, LEDGER_CONNECTION): {
"config": {"ledger_apis": {DEFAULT_LEDGER: {"chain_id": new_chain_id}}}
}
}
old_configurations = deepcopy(LedgerApis.ledger_api_configs)
expected_configurations = deepcopy(old_configurations[DEFAULT_LEDGER])
expected_configurations["chain_id"] = new_chain_id
try:
_override_ledger_configurations(agent_config)
actual_configurations = LedgerApis.ledger_api_configs.get("fetchai")
assert expected_configurations == actual_configurations
finally:
# this is important - _ovveride_ledger_configurations does
# side-effect to LedgerApis.ledger_api_configs
LedgerApis.ledger_api_configs = old_configurations
assert (
LedgerApis.ledger_api_configs[DEFAULT_LEDGER]["chain_id"]
== DEFAULT_CHAIN_ID
)
def is_item_present(
path: str,
agent_config: AgentConfig,
item_type: str,
item_public_id: PublicId,
is_vendor: bool = True,
with_version: bool = False,
) -> bool:
"""
Check if item is already present in AEA.
Optionally, consider the check also with the version.
:param path: path to look for packages.
:param agent_config: agent config
:param item_type: type of an item.
:param item_public_id: PublicId of an item.
:param is_vendor: flag for vendorized path (True by default).
:param with_version: if true, consider also the package version.
:return: boolean is item present.
"""
item_path = Path(
get_package_path(path, item_type, item_public_id, is_vendor=is_vendor))
registered_item_public_id = get_item_public_id_by_author_name(
agent_config, item_type, item_public_id.author, item_public_id.name)
is_item_registered_no_version = registered_item_public_id is not None
does_path_exist = Path(item_path).exists()
if item_public_id.package_version.is_latest or not with_version:
return is_item_registered_no_version and does_path_exist
# the following makes sense because public id is not latest
component_id = ComponentId(ComponentType(item_type), item_public_id)
component_is_registered = component_id in agent_config.package_dependencies
return component_is_registered and does_path_exist
def __init__(self, ctx: Context, item_type: str,
item_public_id: PublicId) -> None:
"""
Init item upgrader.
:param ctx: context
:param item_type: str, type of the package
:param item_public_id: item to upgrade.
"""
self.ctx = ctx
self.ctx.set_config("with_dependencies", True)
self.item_type = item_type
self.item_public_id = item_public_id
self.component_id = ComponentId(self.item_type, self.item_public_id)
self.current_item_public_id = self.get_current_item()
(
self.in_requirements,
self.deps_can_be_removed,
self.deps_can_not_be_removed,
) = self.get_dependencies()
self.dependencies: Set[PackageId] = set()
self.dependencies.update(self.deps_can_be_removed)
self.dependencies.update(self.deps_can_not_be_removed)
self._current_aea_version = aea.__version__
def test_find_import_order():
"""Test find import order works on cycle dependency."""
builder = AEABuilder()
builder.set_name("aea_1")
builder.add_private_key("fetchai")
_old_load = ComponentConfiguration.load
def _new_load(*args, **kwargs):
skill_config = _old_load(*args, **kwargs)
skill_config.skills = [Mock()]
return skill_config
with patch.object(ComponentConfiguration, "load", _new_load):
with pytest.raises(
AEAException,
match=r"Cannot load skills, there is a cyclic dependency."):
builder._find_import_order(
[
ComponentId(ComponentType.SKILL,
PublicId("dummy_author", "dummy", "0.1.0")),
],
Path(os.path.join(CUR_PATH, "data", "dummy_aea")),
True,
)
def test_fetch(self):
"""Test that the `fetch` method works as expected."""
contract_id = ERC1155_PUBLIC_ID
contract = self.registry.fetch(
ComponentId(ComponentType.CONTRACT, contract_id))
assert isinstance(contract, Contract)
assert contract.id == contract_id
def remove_skill(self, public_id: PublicId) -> "AEABuilder":
"""
Remove protocol.
:param public_id: the public id of the skill
:return: the AEABuilder
"""
self.remove_component(ComponentId(ComponentType.SKILL, public_id))
return self
def remove_connection(self, public_id: PublicId) -> "AEABuilder":
"""
Remove a connection.
:param public_id: the public id of the connection
:return: the AEABuilder
"""
self.remove_component(ComponentId(ComponentType.CONNECTION, public_id))
return self
def remove_connection(self, connection_id: ConnectionId) -> None:
"""
Remove a connection from the set of resources.
:param connection_id: the connection id for the connection to be removed.
:return: None
"""
self._component_registry.unregister(
ComponentId(ComponentType.CONNECTION, connection_id))
def remove_contract(self, contract_id: ContractId) -> None:
"""
Remove a contract from the set of resources.
:param contract_id: the contract id for the contract to be removed.
:return: None
"""
self._component_registry.unregister(
ComponentId(ComponentType.CONTRACT, contract_id))
def test_component_id_from_json():
"""Test ComponentId.from_json."""
json_data = {
"type": "connection",
"author": "author",
"name": "name",
"version": "1.0.0",
}
assert ComponentId.from_json(json_data).json == json_data
def _override_ledger_configurations(agent_config: AgentConfig) -> None:
"""Override LedgerApis configurations with agent override configurations."""
ledger_component_id = ComponentId(ComponentType.CONNECTION,
LEDGER_CONNECTION)
if ledger_component_id not in agent_config.component_configurations:
return
ledger_apis_config = agent_config.component_configurations[
ledger_component_id]["config"].get("ledger_apis", {})
recursive_update(LedgerApis.ledger_api_configs, ledger_apis_config)
def remove_protocol(self, protocol_id: ProtocolId) -> None:
"""
Remove a protocol from the set of resources.
:param protocol_id: the protocol id for the protocol to be removed.
:return: None
"""
self._component_registry.unregister(
ComponentId(ComponentType.PROTOCOL, protocol_id))
def remove_contract(self, public_id: PublicId) -> "AEABuilder":
"""
Remove protocol.
:param public_id: the public id of the contract
:return: the AEABuilder
"""
self.remove_component(ComponentId(ComponentType.CONTRACT, public_id))
return self
def _remove_from_config(self) -> None:
"""Remove item from agent config."""
current_item = self.get_current_item()
logger.debug("Removing the {} from {}".format(self.item_type,
DEFAULT_AEA_CONFIG_FILE))
self.agent_items.remove(current_item)
self.agent_config.component_configurations.pop(
ComponentId(self.item_type, current_item), None)
self.ctx.dump_agent_config()
def get_connection(self, connection_id: PublicId) -> Optional[Connection]:
"""
Get connection for given connection id.
:param connection_id: the connection id
:return: a matching connection, if present, else None
"""
connection = self._component_registry.fetch(
ComponentId(ComponentType.CONNECTION, connection_id))
return cast(Connection, connection)
def get_protocol(self, protocol_id: ProtocolId) -> Optional[Protocol]:
"""
Get protocol for given protocol id.
:param protocol_id: the protocol id
:return: a matching protocol, if present, else None
"""
protocol = self._component_registry.fetch(
ComponentId(ComponentType.PROTOCOL, protocol_id))
return cast(Protocol, protocol)
def get_contract(self, contract_id: ContractId) -> Optional[Contract]:
"""
Get contract for given contract id.
:param contract_id: the contract id
:return: a matching contract, if present, else None
"""
contract = self._component_registry.fetch(
ComponentId(ComponentType.CONTRACT, contract_id))
return cast(Contract, contract)
def get_skill(self, skill_id: SkillId) -> Optional[Skill]:
"""
Get the skill for a given skill id.
:param skill_id: the skill id
:return: a matching skill, if present, else None
"""
skill = self._component_registry.fetch(
ComponentId(ComponentType.SKILL, skill_id))
return cast(Skill, skill)
def test_get_latest_component_id_from_prefix():
"""Test the utility to get the latest concrete version id."""
agent_config = MagicMock()
expected_component_id = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.1.0"))
agent_config.package_dependencies = {expected_component_id}
result = get_latest_component_id_from_prefix(
agent_config, expected_component_id.component_prefix)
assert result == expected_component_id
def test_register_when_component_is_already_registered(self):
"""Test AgentComponentRegistry.register when the component is already registered."""
component_id = ComponentId(ComponentType.PROTOCOL,
PublicId("author", "name", "0.1.0"))
component_mock = MagicMock(component_id=component_id)
self.registry._registered_keys.add(component_id)
with pytest.raises(ValueError,
match=r"Component already registered with item id"):
self.registry.register(component_id, component_mock)
self.registry._registered_keys = set()
def test_from_dir():
"""Test Connection.from_dir"""
dummy_connection_dir = os.path.join(CUR_PATH, "data", "dummy_connection")
identity = MagicMock()
identity.name = "agent_name"
crypto_store = MagicMock()
connection = Connection.from_dir(dummy_connection_dir, identity, crypto_store)
assert isinstance(connection, Connection)
assert connection.component_id == ComponentId(
ComponentType.CONNECTION, PublicId("fetchai", "dummy", "0.1.0")
)
def test_unregister_when_no_item_registered(self):
"""Test AgentComponentRegistry.register when the item was not registered."""
component_id = ComponentId(
ComponentType.PROTOCOL, PublicId("author", "name", "0.1.0")
)
component_mock = MagicMock(component_id=component_id)
self.registry.register(component_id, component_mock)
self.registry._registered_keys.remove(component_id)
with pytest.raises(ValueError, match="No item registered with item id '.*'"):
self.registry.unregister(component_id)
self.registry._registered_keys.add(component_id)
self.registry.unregister(component_id)
def get_component_directory(package_id: PackageId) -> Path:
"""Return path for package."""
try:
return AEABuilder.find_component_directory_from_component_id(
Path("."),
ComponentId(str(package_id.package_type), package_id.public_id),
)
except ValueError:
raise click.ClickException(
f"Can not find folder for the package: {package_id.package_type} {package_id.public_id}"
)
def _override_ledger_configurations(agent_config: AgentConfig) -> None:
"""Override LedgerApis configurations with agent override configurations."""
ledger_component_id = ComponentId(ComponentType.CONNECTION,
PublicId.from_str(LEDGER_CONNECTION))
prefix_to_component_configuration = {
key.component_prefix: value
for key, value in agent_config.component_configurations.items()
}
if ledger_component_id.component_prefix not in prefix_to_component_configuration:
return
ledger_apis_config = prefix_to_component_configuration[
ledger_component_id.component_prefix]["config"].get("ledger_apis", {})
recursive_update(LedgerApis.ledger_api_configs, ledger_apis_config)
def test_custom_configuration_updated(self):
"""Test default routing updated."""
component_protocol_id = ComponentId(ComponentType.PROTOCOL,
self.new_protocol_id)
component_contract_id = ComponentId(ComponentType.CONTRACT,
self.new_contract_id)
component_connection_id = ComponentId(ComponentType.CONNECTION,
self.new_connection_id)
component_skill_id = ComponentId(ComponentType.SKILL,
self.new_skill_id)
assert (
self.agent_config.component_configurations[component_protocol_id]
== self.expected_custom_component_configuration)
assert (
self.agent_config.component_configurations[component_contract_id]
== self.expected_custom_component_configuration)
assert (
self.agent_config.component_configurations[component_connection_id]
== self.expected_custom_component_configuration)
assert (self.agent_config.component_configurations[component_skill_id]
== self.expected_custom_component_configuration)
