def test_pay_for_service_insufficient_balance(publisher_ocean_instance): """Tests if balance is lower than the purchased amount.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) token = ocn.create_data_token("DataToken1", "DT1", from_wallet=alice, blob="foo_blob") with pytest.raises(InsufficientBalance): ocn.assets.pay_for_service( ocn.web3, 10000000000000, token.address, asset.did, 0, ZERO_ADDRESS, alice, alice.address, )
def test_ddo_address_utilities(): sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample_with_credentials.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) ddo = V3Asset(json_filename=sample_ddo_path) assert ddo.allowed_addresses == ["0x123", "0x456a"] ddo.add_address_to_allow_list("0xAbc12") assert ddo.allowed_addresses == ["0x123", "0x456a", "0xabc12"] ddo.remove_address_from_allow_list("0xAbc12") assert ddo.allowed_addresses == ["0x123", "0x456a"] ddo.remove_address_from_allow_list("0x123") assert ddo.allowed_addresses == ["0x456a"] ddo.remove_address_from_allow_list("0x456a") assert ddo.allowed_addresses == [] assert ddo.denied_addresses == ["0x2222", "0x333"] # does not exist ddo.remove_address_from_deny_list("0xasfaweg") assert ddo.denied_addresses == ["0x2222", "0x333"] ddo.add_address_to_deny_list("0xasfaweg") assert ddo.denied_addresses == ["0x2222", "0x333", "0xasfaweg"] ddo = V3Asset() assert ddo.allowed_addresses == [] ddo.add_address_to_allow_list("0xAbc12") assert ddo.allowed_addresses == ["0xabc12"] # double adding ddo.add_address_to_allow_list("0xAbc12") assert ddo.allowed_addresses == ["0xabc12"]
def test_ddo_dict(): """Tests DDO creation from dictionary.""" sample_ddo_path = get_resource_path("ddo", "ddo_sample_algorithm.json") assert sample_ddo_path.exists(), f"{sample_ddo_path} does not exist!" ddo1 = DDO(json_filename=sample_ddo_path) assert len(ddo1.public_keys) == 3 assert ddo1.did == "did:op:8d1b4d73e7af4634958f071ab8dfe7ab0df14019"
def test_account_properties_from_file(alice_account): key_file = get_resource_path("keys", "key_file_2.json") account = Account(key_file=key_file, password="******", address="0x0") assert json.loads( account.key)["id"] == "0902d04b-f26e-5c1f-e3ae-78d2c1cb16e7" assert account.private_key is None assert account.key == account._encrypted_key assert account.key_file == str(key_file)
def create_asset(ocean, publisher, encrypt=False): """Helper function for asset creation based on ddo_sa_sample.json.""" sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") assert sample_ddo_path.exists(), "{} does not exist!".format( sample_ddo_path) asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) return ocean.assets.create(asset.metadata, publisher, [], encrypt=encrypt)
def test_config_from_filename(): """Tests that a Config object can be set from a filename.""" config_file_name = get_resource_path("config", "test_config.ini") config = Config(filename=config_file_name) assert config.aquarius_url == "https://custom-aqua.url" assert config.artifacts_path is not None assert config.metadata_store_url == config.aquarius_url assert config.provider_address == "0x00bd138abd70e2f00903268f3db08f2d25677c9e" assert isinstance(config.gas_limit, int)
def test_config_filename_given_file_exists_wellformed_content(): """Test creating a Config object. Setup: filename given, file exists, content is well-formed Expect: success """ config_file_name = get_resource_path("config", "test_config.ini") config = Config(filename=config_file_name) assert config.metadata_cache_uri == "https://custom-aqua.url" assert config.provider_address == "0x00bd138abd70e2f00903268f3db08f2d25677c9e" assert isinstance(config.gas_limit, int)
def create_asset(ocean, publisher): sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") assert sample_ddo_path.exists(), "{} does not exist!".format( sample_ddo_path) asset = DDO(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) my_secret_store = "http://myownsecretstore.com" auth_service = ServiceDescriptor.authorization_service_descriptor( my_secret_store) return ocean.assets.create(asset.metadata, publisher, [auth_service])
def test_config_filename_not_given_file_exists_wellformed_content(monkeypatch): """Test creating a Config object. Setup: filename not given, default file exists, content is well-formed Expect: success. Uses config file at ENV_CONFIG_FILE. """ config_file_name = get_resource_path("config", "test_config.ini") monkeypatch.setenv(ENV_CONFIG_FILE, str(config_file_name)) config = Config() assert config.provider_address == "0x00bd138abd70e2f00903268f3db08f2d25677c9e"
def test_create_asset_with_owner_address(publisher_ocean_instance): """Tests that an asset can be created with owner address.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) assert ocn.assets.create( asset.metadata, alice, [], owner_address=alice.address ), "Asset creation failed with the specified owner address."
def test_create_asset_without_dt_address(publisher_ocean_instance): """Tests creation of the asset which has not the data token address.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) assert ocn.assets.create( asset.metadata, alice, [], data_token_address=None ), "Asset creation failed with the specified datatoken address."
def test_ddo_unlisting(): sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) ddo = V3Asset(json_filename=sample_ddo_path) assert ddo.is_listed ddo.unlist() assert not ddo.is_listed ddo.list() assert ddo.is_listed
def test_ddo_retiring(): sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) ddo = V3Asset(json_filename=sample_ddo_path) assert not ddo.is_retired ddo.retire() assert ddo.is_retired assert ddo.is_consumable() == ConsumableCodes.ASSET_DISABLED ddo.unretire() assert not ddo.is_retired
def test_ddo_credentials_disabled(): sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample_disabled.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) ddo = V3Asset(json_filename=sample_ddo_path) assert ddo.is_disabled assert not ddo.is_enabled ddo.enable() assert not ddo.is_disabled assert ddo.is_enabled ddo.disable() assert ddo.is_consumable() == ConsumableCodes.ASSET_DISABLED
def test_create_asset_without_dt_address(publisher_ocean_instance): """Tests creation of the asset which has not the data token address.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = DDO(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) my_secret_store = "http://myownsecretstore.com" auth_service = ServiceDescriptor.authorization_service_descriptor( my_secret_store) assert ocn.assets.create(asset.metadata, alice, [auth_service], data_token_address=None)
def get_ddo_sample(datatoken_address): did = f"did:op:{remove_0x_prefix(datatoken_address)}" sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") assert sample_ddo_path.exists(), "{} does not exist!".format( sample_ddo_path) asset = DDO(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) checksum_dict = dict() for service in asset.services: checksum_dict[str(service.index)] = checksum(service.main) asset.add_proof(checksum_dict, get_publisher_wallet()) asset._did = did return asset
def test_ddo_credentials_addresses_both(): """Tests DDO credentials when both deny and allow lists exist on the asset.""" sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample_with_credentials.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) ddo = V3Asset(json_filename=sample_ddo_path) address_credential = AddressCredential(ddo) assert address_credential.get_addresses_of_class("allow") == ["0x123", "0x456a"] assert address_credential.get_addresses_of_class("deny") == ["0x2222", "0x333"] assert ( address_credential.validate_access({"type": "address", "value": "0x111"}) == ConsumableCodes.CREDENTIAL_NOT_IN_ALLOW_LIST ) assert ( address_credential.validate_access({"type": "address", "value": "0x456A"}) == ConsumableCodes.OK )
def test_create_asset_with_address(publisher_ocean_instance): """Tests that an asset can be created with specific DT address.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) token = ocn.create_data_token("DataToken1", "DT1", from_wallet=alice, blob="foo_blob") assert ocn.assets.create( asset.metadata, alice, [], data_token_address=token.address ), "Asset creation failed with the specified datatoken address."
def test_verify_order_tx(alice_address, bob_address, alice_ocean, alice_wallet): """Tests verify_order_tx function.""" alice_w3 = alice_ocean.web3.eth.blockNumber token = alice_ocean.create_data_token( "DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob" ) token.mint(alice_address, to_base_18(100.0), from_wallet=alice_wallet) token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet) transfer_tx_id = token.transfer( bob_address, to_base_18(5.0), from_wallet=alice_wallet ) with pytest.raises(AssertionError): # dummy tx id token.verify_order_tx( alice_w3, "0x0", "some_did", "some_index", "some_amount", alice_address ) transfer_tx_id = token.transfer( bob_address, to_base_18(5.0), from_wallet=alice_wallet ) with pytest.raises(AssertionError): # tx id is from transfer, not order token.verify_order_tx( alice_w3, transfer_tx_id, "some_did", "some_index", "some_amount", alice_address, ) sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = DDO(json_filename=sample_ddo_path) order_tx_id = token.startOrder( alice_address, to_base_18(1.0), 1, ZERO_ADDRESS, alice_wallet ) with pytest.raises(AssertionError): # the wrong asset did, this is a sample token.verify_order_tx( alice_w3, order_tx_id, asset.did, "some_index", "some_amount", alice_address )
def test_ddo_dict(): """Tests DDO creation from dictionary.""" sample_ddo_path = get_resource_path("ddo", "ddo_sample_algorithm.json") assert sample_ddo_path.exists(), f"{sample_ddo_path} does not exist!" ddo1 = V3Asset(json_filename=sample_ddo_path) assert ddo1.did == "did:op:8d1b4d73e7af4634958f071ab8dfe7ab0df14019" ddo1.add_proof({"checksum": "test"}, get_publisher_wallet()) ddo_dict = ddo1.as_dictionary() assert ddo_dict["publicKey"][0]["id"] == ddo1.did assert ddo_dict["publicKey"][0]["owner"] == get_publisher_wallet().address assert ddo_dict["publicKey"][0]["type"] == "EthereumECDSAKey" assert ddo_dict["authentication"][0] == { "type": "RsaSignatureAuthentication2018", "publicKey": ddo1.did, }
def test_create_asset_with_address(publisher_ocean_instance): """Tests that an asset can be created with specific DT address.""" ocn = publisher_ocean_instance alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = DDO(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) my_secret_store = "http://myownsecretstore.com" auth_service = ServiceDescriptor.authorization_service_descriptor( my_secret_store) token = ocn.create_data_token("DataToken1", "DT1", from_wallet=alice, blob="foo_blob") assert ocn.assets.create(asset.metadata, alice, [auth_service], data_token_address=token.address)
def test_ddo_credentials_addresses_no_access_list(): """Tests DDO credentials when neither deny, nor allow lists exist on the asset.""" sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample_with_credentials.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) # if "allow" OR "deny" exist, we need a credential, # so remove both to test the behaviour of no credential supplied ddo = V3Asset(json_filename=sample_ddo_path) address_credential = AddressCredential(ddo) ddo.credentials.pop("allow") ddo.credentials.pop("deny") assert address_credential.validate_access() == ConsumableCodes.OK # test that we can use another credential if address is not required assert ( ddo.is_consumable( {"type": "somethingelse", "value": "test"}, with_connectivity_check=False ) == ConsumableCodes.OK )
def test_verify_order_tx(alice_address, bob_address, alice_ocean, alice_wallet): """Tests verify_order_tx function.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) transfer_tx_id = token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) with pytest.raises(TimeExhausted): with patch("ocean_lib.models.data_token.DataToken.get_tx_receipt" ) as mock: # dummy tx id which is not found in the chain # catches TimeExhausted exception from web3 mock.side_effect = TimeExhausted() token.verify_order_tx("0x0", "some_did", "some_index", "some_amount", alice_address) transfer_tx_id = token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) with pytest.raises(AssertionError): # tx id is from transfer, not order token.verify_order_tx(transfer_tx_id, "some_did", "some_index", "some_amount", alice_address) sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) order_tx_id = token.startOrder(alice_address, to_wei(1), 1, ZERO_ADDRESS, alice_wallet) with pytest.raises(AssertionError): # the wrong asset did, this is a sample token.verify_order_tx(order_tx_id, asset.did, "some_index", "some_amount", alice_address)
def test_InsufficientBalance(publisher_ocean_instance): alice = get_publisher_wallet() sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4()) token = publisher_ocean_instance.create_data_token("DataToken1", "DT1", from_wallet=alice, blob="foo_blob") with pytest.raises(InsufficientBalance): publisher_ocean_instance.assets.pay_for_service( publisher_ocean_instance.web3, to_wei("12345678999999.9"), token.address, asset.did, 0, ZERO_ADDRESS, alice, alice.address, )
def test_ddo_credentials_addresses_only_deny(): """Tests DDO credentials when only the deny list exists on the asset.""" sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample_with_credentials.json") assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path) # remove allow to test the behaviour of deny ddo = V3Asset(json_filename=sample_ddo_path) ddo.credentials.pop("allow") address_credential = AddressCredential(ddo) assert address_credential.get_addresses_of_class("allow") == [] assert address_credential.get_addresses_of_class("deny") == ["0x2222", "0x333"] assert ( address_credential.validate_access({"type": "address", "value": "0x111"}) == ConsumableCodes.OK ) assert ( address_credential.validate_access({"type": "address", "value": "0x333"}) == ConsumableCodes.CREDENTIAL_IN_DENY_LIST ) credential = {"type": "address", "value": ""} with pytest.raises(MalformedCredential): address_credential.validate_access(credential)