def test_compute_multi_inputs():
"""Tests that a compute job with additional Inputs (multiple assets) starts properly."""
setup = Setup()
# Dataset with compute service
compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(compute_ddo.did)
# Another dataset, this time with download service
access_ddo = get_registered_ddo_with_access_service(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(access_ddo.did)
# Setup algorithm meta to run raw algorithm
algorithm_ddo = get_registered_algorithm_ddo_different_provider(
setup.publisher_ocean_instance, setup.publisher_wallet)
_ = setup.publisher_ocean_instance.assets.resolve(algorithm_ddo.did)
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo, access_ddo],
algo_ddo=algorithm_ddo,
)
def simple_compute_ddo():
setup = Setup()
# Dataset with compute service
simple_compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
setup.publisher_ocean_instance.assets.resolve(simple_compute_ddo.did)
yield simple_compute_ddo
def test_update_trusted_algorithms():
setup = Setup()
config = ConfigProvider.get_config()
ddo_address = get_contracts_addresses(
"ganache", config)[MetadataContract.CONTRACT_NAME]
ddo_registry = MetadataContract(ddo_address)
# Setup algorithm meta to run raw algorithm
algorithm_ddo = get_registered_algorithm_ddo(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(algorithm_ddo.did)
# Dataset with compute service
compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance,
setup.publisher_wallet,
trusted_algorithms=[algorithm_ddo.did],
)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(compute_ddo.did)
trusted_algo_list = create_publisher_trusted_algorithms(
[algorithm_ddo.did],
setup.publisher_ocean_instance.config.aquarius_url)
compute_ddo.update_compute_privacy(trusted_algorithms=trusted_algo_list,
allow_all=False,
allow_raw_algorithm=False)
tx_id = setup.publisher_ocean_instance.assets.update(
compute_ddo, setup.publisher_wallet)
tx_receipt = ddo_registry.get_tx_receipt(tx_id)
logs = ddo_registry.event_MetadataUpdated.processReceipt(tx_receipt)
assert logs[0].args.dataToken == compute_ddo.data_token_address
wait_for_update(
setup.publisher_ocean_instance,
compute_ddo.did,
"privacy",
{"publisherTrustedAlgorithms": [algorithm_ddo.did]},
)
compute_ddo_updated = setup.publisher_ocean_instance.assets.resolve(
compute_ddo.did)
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo_updated],
algo_ddo=algorithm_ddo,
)
def asset_with_trusted(algorithm_ddo):
setup = Setup()
# Setup algorithm meta to run raw algorithm
ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance,
setup.publisher_wallet,
trusted_algorithms=[algorithm_ddo.did],
)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(ddo.did)
yield ddo
def test_compute_raw_algo():
setup = Setup()
# Dataset with compute service
compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(compute_ddo.did)
# Setup algorithm meta to run raw algorithm
algorithm_meta = get_algorithm_meta()
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo],
algo_meta=algorithm_meta,
)
def test_compute_trusted_algorithms():
setup = Setup()
# Setup algorithm meta to run raw algorithm
algorithm_ddo = get_registered_algorithm_ddo(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(algorithm_ddo.did)
algorithm_ddo_v2 = get_registered_algorithm_ddo(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(algorithm_ddo_v2.did)
# Dataset with compute service
compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance,
setup.publisher_wallet,
trusted_algorithms=[algorithm_ddo.did],
)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(compute_ddo.did)
# For debugging.
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo],
algo_ddo=algorithm_ddo,
)
# Expect to fail with another algorithm ddo that is not trusted.
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo],
algo_ddo=algorithm_ddo_v2,
expect_failure=True,
expect_failure_message=
f"this algorithm did {algorithm_ddo_v2.did} is not trusted.",
)
def test_trusted_algorithms(publisher_ocean_instance):
"""Tests if the trusted algorithms list is returned correctly."""
publisher = get_publisher_wallet()
algorithm_ddo = get_registered_algorithm_ddo(publisher_ocean_instance, publisher)
wait_for_ddo(publisher_ocean_instance, algorithm_ddo.did)
assert algorithm_ddo is not None
ddo = get_registered_ddo_with_compute_service(
publisher_ocean_instance, publisher, trusted_algorithms=[algorithm_ddo.did]
)
wait_for_ddo(publisher_ocean_instance, ddo.did)
assert ddo is not None
trusted_algorithms = ddo.get_trusted_algorithms()
service = ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
privacy_dict = service.attributes["main"].get("privacy")
assert privacy_dict
assert trusted_algorithms is not None
assert len(trusted_algorithms) >= 1
for index, trusted_algorithm in enumerate(trusted_algorithms):
assert trusted_algorithm["did"] == algorithm_ddo.did
assert "filesChecksum" and "containerSectionChecksum" in trusted_algorithm
assert (
trusted_algorithm["filesChecksum"]
== privacy_dict["publisherTrustedAlgorithms"][index]["filesChecksum"]
)
assert (
trusted_algorithm["containerSectionChecksum"]
== privacy_dict["publisherTrustedAlgorithms"][index][
"containerSectionChecksum"
]
)
assert (
trusted_algorithm["did"]
== privacy_dict["publisherTrustedAlgorithms"][index]["did"]
)
def test_utilitary_functions_for_trusted_algorithms(publisher_ocean_instance):
"""Tests adding/removing trusted algorithms in the DDO metadata."""
publisher = get_publisher_wallet()
algorithm_ddo = get_registered_algorithm_ddo(publisher_ocean_instance,
publisher)
wait_for_ddo(publisher_ocean_instance, algorithm_ddo.did)
assert algorithm_ddo is not None
algorithm_ddo_v2 = get_registered_algorithm_ddo(publisher_ocean_instance,
publisher)
wait_for_ddo(publisher_ocean_instance, algorithm_ddo_v2.did)
assert algorithm_ddo_v2 is not None
algorithm_ddo_v3 = get_registered_algorithm_ddo(publisher_ocean_instance,
publisher)
wait_for_ddo(publisher_ocean_instance, algorithm_ddo_v3.did)
assert algorithm_ddo_v3 is not None
ddo = get_registered_ddo_with_compute_service(
publisher_ocean_instance,
publisher,
trusted_algorithms=[algorithm_ddo.did])
wait_for_ddo(publisher_ocean_instance, ddo.did)
assert ddo is not None
publisher_trusted_algorithms = create_publisher_trusted_algorithms(
[algorithm_ddo.did],
publisher_ocean_instance.config.metadata_cache_uri)
# add a new trusted algorithm to the publisher_trusted_algorithms list
new_publisher_trusted_algorithms = add_publisher_trusted_algorithm(
ddo.did,
algorithm_ddo_v2.did,
publisher_ocean_instance.config.metadata_cache_uri,
)
assert new_publisher_trusted_algorithms is not None
assert len(new_publisher_trusted_algorithms) > len(
publisher_trusted_algorithms)
# add an existing algorithm to publisher_trusted_algorithms list
new_publisher_trusted_algorithms = add_publisher_trusted_algorithm(
ddo.did, algorithm_ddo.did,
publisher_ocean_instance.config.metadata_cache_uri)
assert new_publisher_trusted_algorithms is not None
for _, trusted_algorithm in enumerate(publisher_trusted_algorithms):
assert trusted_algorithm["did"] == algorithm_ddo.did
assert len(new_publisher_trusted_algorithms) == len(
publisher_trusted_algorithms)
# remove an existing algorithm to publisher_trusted_algorithms list
new_publisher_trusted_algorithms = remove_publisher_trusted_algorithm(
ddo.did, algorithm_ddo.did,
publisher_ocean_instance.config.metadata_cache_uri)
assert new_publisher_trusted_algorithms is not None
assert len(new_publisher_trusted_algorithms) < len(
publisher_trusted_algorithms)
# remove a trusted algorithm that does not belong to publisher_trusted_algorithms list
new_publisher_trusted_algorithms = remove_publisher_trusted_algorithm(
ddo.did,
algorithm_ddo_v3.did,
publisher_ocean_instance.config.metadata_cache_uri,
)
assert new_publisher_trusted_algorithms is not None
for trusted_algorithm in publisher_trusted_algorithms:
assert trusted_algorithm["did"] != algorithm_ddo_v3.did
assert len(new_publisher_trusted_algorithms) == len(
publisher_trusted_algorithms)
