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)