def test_add_trusted_algorithm_no_compute_service(publisher_ocean_instance,
metadata):
"""Tests if the DDO has or not a compute service."""
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
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
assert ddo is not None
create_publisher_trusted_algorithms(
[algorithm_ddo.did],
publisher_ocean_instance.config.metadata_cache_uri)
with pytest.raises(AssertionError):
add_publisher_trusted_algorithm(
ddo.did,
algorithm_ddo.did,
publisher_ocean_instance.config.metadata_cache_uri,
)
def test_ocean_assets_search(publisher_ocean_instance, metadata):
"""Tests that a created asset can be searched successfully."""
identifier = str(uuid.uuid1()).replace("-", "")
metadata_copy = metadata.copy()
metadata_copy["main"]["name"] = identifier
assert len(publisher_ocean_instance.assets.search(identifier)) == 0
publisher = get_publisher_wallet()
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
time.sleep(1) # apparently changes are not instantaneous
assert len(publisher_ocean_instance.assets.search(identifier)) == 1
assert (len(
publisher_ocean_instance.assets.query({
"query_string": {
"query": identifier,
"fields": ["service.attributes.main.name"],
}
})) == 1)
assert (len(
publisher_ocean_instance.assets.query({
"query_string": {
"query": "Gorilla",
"fields": ["service.attributes.main.name"],
}
})) == 0)
def test_values(publisher_ocean_instance, metadata):
"""Tests if the DDO has the address for the data token given by 'values' property."""
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
ddo_values = ddo.values
assert ddo_values is not None
for key, value in ddo_values.items():
assert key == "dataToken"
assert value.startswith("0x")
assert ddo_values[key] is not None
def test_aqua_functions_for_single_ddo(
publisher_ocean_instance, metadata, aquarius_instance
):
"""Tests against single-ddo functions of Aquarius."""
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
aqua_metadata = aquarius_instance.get_asset_metadata(ddo.did)
del aqua_metadata["main"]["datePublished"]
assert aqua_metadata["main"] == ddo.metadata["main"]
assert aqua_metadata["encryptedFiles"] == ddo.metadata["encryptedFiles"]
res = aquarius_instance.get_asset_ddo(ddo.did)
assert res.did == ddo.did, "Aquarius could not resolve the did."
def test_ocean_assets_compute(publisher_ocean_instance):
publisher = get_publisher_wallet()
metadata = get_computing_metadata()
metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ddo = publisher_ocean_instance.assets.create(metadata, publisher)
assert ddo
_ddo = wait_for_ddo(publisher_ocean_instance, ddo.did)
assert _ddo, f"assets.resolve failed for did {ddo.did}"
def test_ocean_assets_compute(publisher_ocean_instance):
"""Tests the creation of an asset with a compute service."""
publisher = get_publisher_wallet()
metadata = get_computing_metadata()
metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ddo = publisher_ocean_instance.assets.create(metadata, publisher)
assert ddo, "DDO None. The ddo is not cached after the creation."
_ddo = wait_for_ddo(publisher_ocean_instance, ddo.did)
assert _ddo, f"assets.resolve failed for did {ddo.did}"
def test_ocean_assets_algorithm(publisher_ocean_instance):
publisher = get_publisher_wallet()
metadata = get_sample_algorithm_ddo()["service"][0]
metadata["attributes"]["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ddo = publisher_ocean_instance.assets.create(metadata["attributes"],
publisher)
assert ddo
_ddo = wait_for_ddo(publisher_ocean_instance, ddo.did)
assert _ddo, f"assets.resolve failed for did {ddo.did}"
def test_ocean_assets_algorithm(publisher_ocean_instance):
"""Tests the creation of an algorithm DDO."""
publisher = get_publisher_wallet()
metadata = get_sample_algorithm_ddo_dict()["service"][0]
metadata["attributes"]["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ddo = publisher_ocean_instance.assets.create(metadata["attributes"],
publisher)
assert ddo, "DDO None. The ddo is not cached after the creation."
_ddo = wait_for_ddo(publisher_ocean_instance, ddo.did)
assert _ddo, f"assets.resolve failed for did {ddo.did}"
assert _ddo.is_consumable() == ConsumableCodes.OK
def ocean_assets_download_destination_file_helper(publisher_ocean_instance,
metadata, tmpdir):
"""Tests downloading to an existing directory."""
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
data_provider = DataServiceProvider
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
sa = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo)
written_path = download_asset_files(
sa.index,
ddo,
publisher,
tmpdir,
ddo.data_token_address,
"test_order_tx_id",
data_provider,
)
assert os.path.exists(written_path)
def test_ocean_assets_download_failure(publisher_ocean_instance, metadata):
"""Tests that downloading from an empty service raises an AssertionError."""
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
data_provider = DataServiceProvider
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
sa = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo)
sa.__dict__["_service_endpoint"] = None
ddo.__dict__["_services"][1] = sa
with pytest.raises(AssertionError):
download_asset_files(
sa.index,
ddo,
publisher,
"test_destination",
ddo.data_token_address,
"test_order_tx_id",
data_provider,
)
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_resolve_asset(publisher_ocean_instance, metadata):
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
blob = json.dumps({
"t": 1,
"url": publisher_ocean_instance.config.metadata_cache_uri
})
asset = publisher_ocean_instance.assets.create(metadata_copy,
publisher,
dt_blob=blob)
wait_for_ddo(publisher_ocean_instance, asset.did)
assert asset is not None, "The asset is not cached."
assert isinstance(asset,
V3Asset), "The asset does not have Asset instance."
# resolve asset from metadata_cache_uri
resolved_asset_from_metadata_cache_uri = resolve_asset(
asset.did,
metadata_cache_uri=publisher_ocean_instance.config.metadata_cache_uri)
assert isinstance(
resolved_asset_from_metadata_cache_uri,
V3Asset), "The resolved asset is not an instance of Asset."
assert (resolved_asset_from_metadata_cache_uri.did == asset.did
), "Resolve asset function call is unsuccessful."
# resolve asset from web3 and token_address
resolved_asset_from_web3_and_token_address = resolve_asset(
asset.did,
web3=publisher_ocean_instance.web3,
token_address=asset.data_token_address,
)
assert isinstance(
resolved_asset_from_web3_and_token_address,
V3Asset), "The resolved asset is not an instance of Asset."
assert (resolved_asset_from_web3_and_token_address.did == asset.did
), "Resolve asset function call is unsuccessful."
def test_download_fails(publisher_ocean_instance):
"""Tests failures of assets download function."""
publisher = get_publisher_wallet()
metadata = get_sample_algorithm_ddo()["service"][0]
metadata["attributes"]["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ddo = publisher_ocean_instance.assets.create(metadata["attributes"],
publisher)
_ddo = wait_for_ddo(publisher_ocean_instance, ddo.did)
assert _ddo, f"assets.resolve failed for did {ddo.did}"
with pytest.raises(AssertionError):
publisher_ocean_instance.assets.download(ddo.did, "", publisher, "",
"", -4)
with pytest.raises(AssertionError):
publisher_ocean_instance.assets.download(ddo.did, "", publisher, "",
"", "string_index")
def test_metadata_contract(publisher_ocean_instance, config):
ocn = publisher_ocean_instance
alice = get_publisher_wallet()
block = ocn.web3.eth.block_number
ddo_address = get_contracts_addresses(
config.address_file, "ganache")[MetadataContract.CONTRACT_NAME]
ddo_registry = MetadataContract(ocn.web3, ddo_address)
# Tested the event properties.
assert (ddo_registry.event_MetadataCreated.abi["name"] ==
MetadataContract.EVENT_METADATA_CREATED)
assert (ddo_registry.event_MetadataUpdated.abi["name"] ==
MetadataContract.EVENT_METADATA_UPDATED)
# Tested get_event_log for create event.
original_ddo = create_asset(ocn, alice)
assert original_ddo, "Create asset failed."
asset_id = original_ddo.asset_id
creation_log = ddo_registry.get_event_log(
ddo_registry.EVENT_METADATA_CREATED, block, asset_id, 30)
assert creation_log, "No ddo created event."
assert creation_log.args.createdBy == alice.address
assert (creation_log.args.createdBy == alice.address
), "The event is not created by the publisher."
assert (creation_log.event == ddo_registry.EVENT_METADATA_CREATED
), "Different event types."
# Tested get_event_log for update event.
ddo = wait_for_ddo(ocn, original_ddo.did)
_ = ocn.assets.update(ddo, alice)
updating_log = ddo_registry.get_event_log(
ddo_registry.EVENT_METADATA_UPDATED, block, asset_id, 30)
assert updating_log, "No ddo updated event."
assert (updating_log.args.updatedBy == alice.address
), "The event is not updated by the publisher."
assert (updating_log.event == ddo_registry.EVENT_METADATA_UPDATED
), "Different event types."
def test_ocean_assets_download_indexes(publisher_ocean_instance, metadata):
"""Tests different values of indexes that raise AssertionError."""
publisher = get_publisher_wallet()
metadata_copy = metadata.copy()
data_provider = DataServiceProvider
ddo = publisher_ocean_instance.assets.create(metadata_copy, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
sa = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo)
config = Config(os.getenv(ENV_CONFIG_FILE))
index = range(3)
if config["util"].getboolean("typecheck"):
with pytest.raises(TypeError):
download_asset_files(
sa.index,
ddo,
publisher,
"test_destination",
ddo.data_token_address,
"test_order_tx_id",
data_provider,
index,
)
else:
with pytest.raises(AssertionError):
download_asset_files(
sa.index,
ddo,
publisher,
"test_destination",
ddo.data_token_address,
"test_order_tx_id",
data_provider,
index,
)
index = -1
with pytest.raises(AssertionError):
download_asset_files(
sa.index,
ddo,
publisher,
"test_destination",
ddo.data_token_address,
"test_order_tx_id",
data_provider,
index,
)
index = 4
with pytest.raises(AssertionError):
download_asset_files(
sa.index,
ddo,
publisher,
"test_destination",
ddo.data_token_address,
"test_order_tx_id",
data_provider,
index,
)
def test_ocean_assets_search(publisher_ocean_instance, metadata):
publisher = get_publisher_wallet()
ddo = publisher_ocean_instance.assets.create(metadata, publisher)
wait_for_ddo(publisher_ocean_instance, ddo.did)
assert len(publisher_ocean_instance.assets.search("Monkey")) > 0
def test_register_asset(publisher_ocean_instance):
"""Test various paths for asset registration."""
ocn = publisher_ocean_instance
ddo_reg = ocn.assets.ddo_registry()
block = ocn.web3.eth.blockNumber
alice = get_publisher_wallet()
bob = get_consumer_wallet()
def _get_num_assets(_minter):
dids = [
add_0x_prefix(did_to_id(a))
for a in ocn.assets.owner_assets(_minter)
]
dids = [a for a in dids if len(a) == 42]
return len([
a for a in dids if DataToken(a).contract_concise.isMinter(_minter)
])
num_assets_owned = _get_num_assets(alice.address)
original_ddo = create_asset(ocn, alice)
assert original_ddo, "create asset failed."
# try to resolve new asset
did = original_ddo.did
asset_id = original_ddo.asset_id
log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_CREATED, block,
asset_id, 30)
assert log, "no ddo created event."
ddo = wait_for_ddo(ocn, did)
assert ddo, "ddo is not found in cache."
ddo_dict = ddo.as_dictionary()
original = original_ddo.as_dictionary()
assert ddo_dict["publicKey"] == original["publicKey"]
assert ddo_dict["authentication"] == original["authentication"]
assert ddo_dict["service"]
assert original["service"]
metadata = ddo_dict["service"][0]["attributes"]
if "datePublished" in metadata["main"]:
metadata["main"].pop("datePublished")
assert (ddo_dict["service"][0]["attributes"]["main"]["name"] ==
original["service"][0]["attributes"]["main"]["name"])
assert ddo_dict["service"][1] == original["service"][1]
# Can't resolve unregistered asset
unregistered_did = DID.did({"0": "0x00112233445566"})
with pytest.raises(ValueError):
ocn.assets.resolve(unregistered_did)
# Raise error on bad did
invalid_did = "did:op:0123456789"
with pytest.raises(ValueError):
ocn.assets.resolve(invalid_did)
meta_data_assets = ocn.assets.search("")
if meta_data_assets:
print("Currently registered assets:")
print(meta_data_assets)
# Publish the metadata
_ = ddo.metadata["main"]["name"]
_name = "updated name"
ddo.metadata["main"]["name"] = _name
assert ddo.metadata["main"]["name"] == _name
with pytest.raises(ValueError):
ocn.assets.update(ddo, bob)
_ = ocn.assets.update(ddo, alice)
log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_UPDATED, block,
asset_id, 30)
assert log, "no ddo updated event"
_asset = wait_for_update(ocn, ddo.did, "name", _name)
assert _asset, "Cannot read asset after update."
assert (_asset.metadata["main"]["name"] == _name
), "updated asset does not have the new updated name !!!"
assert (ocn.assets.owner(
ddo.did) == alice.address), "asset owner does not seem correct."
assert _get_num_assets(alice.address) == num_assets_owned + 1
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)
