def setup_all(): config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) network = Web3Helper.get_network_name() wallet = get_ganache_wallet() if network in ["ganache", "development"] and wallet: print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print( f"sender balance: {Web3Helper.from_wei(Web3Helper.get_ether_balance(wallet.address))}" ) assert Web3Helper.from_wei(Web3Helper.get_ether_balance( wallet.address)) > 10 from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(get_ocean_token_address(network)) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if Web3Helper.from_wei(Web3Helper.get_ether_balance( w.address)) < 2: Web3Helper.send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)
def test_ocean_exchange(publisher_ocean_instance): """Tests various flows of DataToken exchanges.""" ocn = publisher_ocean_instance alice_wallet = get_publisher_wallet() bob_wallet = get_consumer_wallet() dt = ocn.create_data_token("DataToken1", "DT1", alice_wallet, blob="http://example.com") dt.mint_tokens(bob_wallet.address, 100.0, alice_wallet) ox = OceanExchange(ocn.OCEAN_address, _get_exchange_address(), ocn.config) rate = 0.9 x_id = ox.create(dt.address, rate, bob_wallet) dt.approve_tokens(ox._exchange_address, 20, bob_wallet) # create with invalid token address with pytest.raises(ValueError): ox.create(ox.ocean_address, 0.9, bob_wallet) # TODO: Enable this ValueError handling when the ERC20 check is added in FixedRateExchange.create solidity function # with pytest.raises(ValueError): # ox.create(ox._exchange_address, 0.9, bob_wallet) # create with negative rate, should fail with pytest.raises(AssertionError): _ = ox.create(dt.address, rate * -1.0, bob_wallet) # create using 0 rate with pytest.raises(AssertionError): _ = ox.create(dt.address, 0.0, bob_wallet) ############## # get_quote base_token_amount = ox.get_quote(2.0, exchange_id=x_id) assert ( base_token_amount == 2.0 * rate ), f"unexpected quote of base token {base_token_amount}, should be {2.0*rate}." ############# # test buying datatokens # Alice is buying from exchange owned by bob assert (ox.buy_at_fixed_rate( 2.0, alice_wallet, max_OCEAN_amount=base_token_amount, data_token=dt.address, exchange_owner=bob_wallet.address, ) is True), "buy datatokens failed" assert (ox.buy_at_fixed_rate(2.0, alice_wallet, max_OCEAN_amount=base_token_amount, exchange_id=x_id) is True), "buy datatokens failed" print("-------- all good --------")
def test_block_confirmations(): alice_wallet = get_publisher_wallet() bob_address = get_consumer_wallet().address # Send transaction first, start dummy tx thread second # else risk race condition: out of order nonce web3 = alice_wallet.web3 tx = { "from": alice_wallet.address, "to": bob_address, "value": 1, "chainId": web3.eth.chain_id, "gasPrice": get_gas_price(web3), } tx["gas"] = web3.eth.estimate_gas(tx) raw_tx = alice_wallet.sign_tx(tx) tx_hash = web3.eth.send_raw_transaction(raw_tx) # Start thread that sends dummy transactions dummy_tx_thread = StoppableThread(target=send_dummy_transactions, args=(alice_wallet, bob_address)) dummy_tx_thread.start() poll_interval = BLOCK_NUMBER_POLL_INTERVAL[1337] wait_for_transaction_receipt_and_block_confirmations( web3, tx_hash, block_confirmations=0, block_number_poll_interval=poll_interval) wait_for_transaction_receipt_and_block_confirmations( web3, tx_hash, block_confirmations=1, block_number_poll_interval=poll_interval) wait_for_transaction_receipt_and_block_confirmations( web3, tx_hash, block_confirmations=6, block_number_poll_interval=poll_interval) wait_for_transaction_receipt_and_block_confirmations( web3, tx_hash, block_confirmations=27, block_number_poll_interval=poll_interval) dummy_tx_thread.stop() dummy_tx_thread.join()
def setup_all(request): # a test can skip setup_all() via decorator "@pytest.mark.nosetup_all" if "nosetup_all" in request.keywords: return config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) wallet = get_ganache_wallet() if not wallet: return addresses_file = config.address_file if not os.path.exists(addresses_file): return with open(addresses_file) as f: network_addresses = json.load(f) print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print(f"sender balance: {from_wei(get_ether_balance(wallet.address))}") assert (from_wei(get_ether_balance(wallet.address)) > 10), "Ether balance less than 10." from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(address=network_addresses["development"]["Ocean"]) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if from_wei(get_ether_balance(w.address)) < 2: send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.mint(wallet.address, amt_distribute_base, from_wallet=wallet) OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)
def setup_all(request, config, web3): # a test can skip setup_all() via decorator "@pytest.mark.nosetup_all" if "nosetup_all" in request.keywords: return wallet = get_ganache_wallet() if not wallet: return addresses_file = config.address_file if not os.path.exists(addresses_file): return with open(addresses_file) as f: network_addresses = json.load(f) print(f"sender: {wallet.key}, {wallet.address}, {wallet.keys_str()}") print( f"sender balance: {from_wei(get_ether_balance(web3, wallet.address))}") assert get_ether_balance( web3, wallet.address) >= to_wei(10), "Ether balance less than 10." from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(web3, address=network_addresses["development"]["Ocean"]) amt_distribute = to_wei(1000) for w in (get_publisher_wallet(), get_consumer_wallet()): if get_ether_balance(web3, w.address) < to_wei(2): send_ether(wallet, w.address, to_wei(4)) if OCEAN_token.balanceOf(w.address) < to_wei(100): OCEAN_token.mint(wallet.address, amt_distribute, from_wallet=wallet) OCEAN_token.transfer(w.address, amt_distribute, from_wallet=wallet)
def test_search_exchange_by_data_token(publisher_ocean_instance): """Tests searching exchanges which have matching data token address.""" ocn = publisher_ocean_instance alice_wallet = get_publisher_wallet() bob_wallet = get_consumer_wallet() dt = ocn.create_data_token("DataToken1", "DT1", alice_wallet, blob=ocn.config.metadata_cache_uri) dt.mint(bob_wallet.address, to_wei(100), alice_wallet) dt.approve(ocn.exchange._exchange_address, to_wei(100), alice_wallet) exchange_id1 = ocn.exchange.create(dt.address, to_wei("0.1"), alice_wallet) exchange_id2 = ocn.exchange.create(dt.address, to_wei("0.1"), bob_wallet) logs = ocn.exchange.search_exchange_by_data_token(dt.address) assert logs[0].args.dataToken == dt.address assert logs[1].args.dataToken == dt.address assert exchange_id1 == logs[0].args.exchangeId assert alice_wallet.address == logs[0].args.exchangeOwner assert exchange_id2 == logs[1].args.exchangeId assert bob_wallet.address == logs[1].args.exchangeOwner
def test_market_flow(): pub_wallet = get_publisher_wallet() publisher_ocean = get_publisher_ocean_instance() consumer_ocean = get_consumer_ocean_instance() # Register Asset asset = get_registered_ddo(publisher_ocean, pub_wallet) assert isinstance(asset, Asset) assert asset.data_token_address consumer_wallet = get_consumer_wallet() service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS) sa = ServiceAgreement.from_json(service.as_dictionary()) # Mint data tokens and assign to publisher dt = publisher_ocean.get_data_token(asset.data_token_address) mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet) ###### # Give the consumer some datatokens so they can order the service try: tx_id = dt.transfer_tokens(consumer_wallet.address, 10, pub_wallet) dt.verify_transfer_tx(tx_id, pub_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise ###### # Place order for the download service order_requirements = consumer_ocean.assets.order(asset.did, consumer_wallet.address, sa.index) ###### # Pay for the service _order_tx_id = consumer_ocean.assets.pay_for_service( order_requirements.amount, order_requirements.data_token_address, asset.did, service.index, '0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9', consumer_wallet) ###### # Download the asset files asset_folder = consumer_ocean.assets.download( asset.did, sa.index, consumer_wallet, _order_tx_id, consumer_ocean.config.downloads_path) assert len(os.listdir(asset_folder)) > 1 orders = consumer_ocean.get_user_orders(consumer_wallet.address, asset.asset_id) assert orders, f'no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}' orders = consumer_ocean.get_user_orders( consumer_wallet.address, consumer_ocean.web3.toChecksumAddress(asset.asset_id)) assert orders, f'no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}' orders = consumer_ocean.get_user_orders(consumer_wallet.address) assert orders, f'no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}'
def test_market_flow(order_type): """Tests that an order is correctly placed on the market. The parameter implicit_none sends the payload with an empty key as the delegated consumer. The parameter explicit_none sends None as the delegated consumer, explicitly.""" pub_wallet = get_publisher_wallet() publisher_ocean = get_publisher_ocean_instance() consumer_ocean = get_consumer_ocean_instance() # Register Asset asset = get_registered_ddo(publisher_ocean, get_metadata(), pub_wallet) assert isinstance(asset, Asset) assert asset.data_token_address consumer_wallet = get_consumer_wallet() service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS) sa = ServiceAgreement.from_json(service.as_dictionary()) # Mint data tokens and assign to publisher dt = publisher_ocean.get_data_token(asset.data_token_address) mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet) ###### # Give the consumer some datatokens so they can order the service try: tx_id = dt.transfer_tokens(consumer_wallet.address, 10.0, pub_wallet) dt.verify_transfer_tx(tx_id, pub_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise ###### # Place order for the download service order_requirements = consumer_ocean.assets.order(asset.did, consumer_wallet.address, sa.index) ###### # Pay for the service args = [ order_requirements.amount, order_requirements.data_token_address, asset.did, service.index, "0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9", consumer_wallet, ] if order_type == "explicit_none": args.append(None) _order_tx_id = consumer_ocean.assets.pay_for_service(*args) ###### # Download the asset files asset_folder = consumer_ocean.assets.download( asset.did, sa.index, consumer_wallet, _order_tx_id, consumer_ocean.config.downloads_path, ) assert len(os.listdir(asset_folder)) >= 1 if order_type == "explicit_none": # no need to continue, order worked return orders = consumer_ocean.get_user_orders(consumer_wallet.address, asset.asset_id) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders( consumer_wallet.address, consumer_ocean.web3.toChecksumAddress(asset.asset_id)) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders(consumer_wallet.address) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}"
def test_payer_market_flow(): """Tests that an order can be placed for a delegated consumer, other than the payer.""" pub_wallet = get_publisher_wallet() publisher_ocean = get_publisher_ocean_instance() consumer_ocean = get_consumer_ocean_instance() another_consumer_ocean = get_another_consumer_ocean_instance( use_provider_mock=True) # Register Asset asset = get_registered_ddo(publisher_ocean, get_metadata(), pub_wallet) assert isinstance(asset, Asset) assert asset.data_token_address another_consumer_wallet = get_another_consumer_wallet() consumer_wallet = get_consumer_wallet() service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS) sa = ServiceAgreement.from_json(service.as_dictionary()) # Mint data tokens and assign to publisher dt = publisher_ocean.get_data_token(asset.data_token_address) mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet) ###### # Give the consumer some datatokens so they can order the service try: tx_id = dt.transfer_tokens(consumer_wallet.address, 10.0, pub_wallet) dt.verify_transfer_tx(tx_id, pub_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise ###### # Place order for the download service order_requirements = consumer_ocean.assets.order( asset.did, another_consumer_wallet.address, sa.index) ###### # Pay for the service and have another_consumer_wallet as consumer _order_tx_id = consumer_ocean.assets.pay_for_service( order_requirements.amount, order_requirements.data_token_address, asset.did, service.index, "0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9", consumer_wallet, another_consumer_wallet.address, ) asset_folder = None assert asset_folder is None if asset_folder is None: # Download the asset files asset_folder = another_consumer_ocean.assets.download( asset.did, sa.index, another_consumer_wallet, _order_tx_id, another_consumer_ocean.config.downloads_path, ) assert len(os.listdir(asset_folder)) >= 1 orders = consumer_ocean.get_user_orders(consumer_wallet.address, asset.asset_id) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders( consumer_wallet.address, consumer_ocean.web3.toChecksumAddress(asset.asset_id)) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders(consumer_wallet.address) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}"
def test_ocean_exchange(publisher_ocean_instance): """Tests various flows of DataToken exchanges.""" ocn = publisher_ocean_instance alice_wallet = get_publisher_wallet() bob_wallet = get_consumer_wallet() dt = ocn.create_data_token("DataToken1", "DT1", alice_wallet, blob="http://example.com") dt.mint(bob_wallet.address, to_wei(100), alice_wallet) ox = OceanExchange( ocn.web3, ocn.OCEAN_address, _get_exchange_address(publisher_ocean_instance.config), ocn.config, ) rate = to_wei("0.9") x_id = ox.create(dt.address, rate, bob_wallet) dt.approve(ox._exchange_address, to_wei(20), bob_wallet) # create with invalid token address with pytest.raises(ValueError): ox.create(ox.ocean_address, rate, bob_wallet) # TODO: Enable this ValueError handling when the ERC20 check is added in FixedRateExchange.create solidity function # with pytest.raises(ValueError): # ox.create(ox._exchange_address, 0.9, bob_wallet) # create with negative rate, should fail with pytest.raises(AssertionError): _ = ox.create(dt.address, -rate, bob_wallet) # create using 0 rate with pytest.raises(AssertionError): _ = ox.create(dt.address, 0, bob_wallet) ############## # get_quote base_token_amount = ox.get_quote(to_wei(2), exchange_id=x_id) expected_base_token_amount = to_wei("1.8") # 2 * 9 assert ( base_token_amount == expected_base_token_amount ), f"unexpected quote of {pretty_ether_and_wei(base_token_amount, 'OCEAN')}, should be {pretty_ether_and_wei(expected_base_token_amount, 'OCEAN')}." ############# # test buying datatokens # Alice is buying from exchange owned by bob assert (ox.buy_at_fixed_rate( to_wei(2), alice_wallet, max_OCEAN_amount=base_token_amount, data_token=dt.address, exchange_owner=bob_wallet.address, ) is True), "buy datatokens failed" assert (ox.buy_at_fixed_rate( to_wei(2), alice_wallet, max_OCEAN_amount=base_token_amount, exchange_id=x_id, ) is True), "buy datatokens failed" rate = to_wei(1) assert ox.setRate(rate, bob_wallet, exchange_id=x_id) # re-evaluate with new rate base_token_amount = ox.get_quote(to_wei(2), exchange_id=x_id) expected_base_token_amount = to_wei(2) assert ( base_token_amount == expected_base_token_amount ), f"unexpected quote of {pretty_ether_and_wei(base_token_amount, 'OCEAN')} base tokens, should be {pretty_ether_and_wei(expected_base_token_amount, 'OCEAN')}."
def test_compute_flow(): ###### # setup pub_wallet = get_publisher_wallet() p_ocean_instance = get_publisher_ocean_instance() c_ocean_instance = get_consumer_ocean_instance() cons_ocn = c_ocean_instance consumer_wallet = get_consumer_wallet() ###### # Publish Assets # Dataset with compute service sample_ddo_path = get_resource_path('ddo', 'ddo_with_compute_service.json') old_ddo = Asset(json_filename=sample_ddo_path) metadata = old_ddo.metadata metadata['main']['files'][0]['checksum'] = str(uuid.uuid4()) service = old_ddo.get_service(ServiceTypes.CLOUD_COMPUTE) compute_service = ServiceDescriptor.compute_service_descriptor( service.attributes, DataServiceProvider.get_url(p_ocean_instance.config)) block = p_ocean_instance.web3.eth.blockNumber compute_ddo = p_ocean_instance.assets.create( metadata, pub_wallet, service_descriptors=[compute_service], ) did = compute_ddo.did ddo_reg = p_ocean_instance.assets.ddo_registry() log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_CREATED, block, compute_ddo.asset_id, 30) assert log, f'no ddo created event.' ddo = wait_for_ddo(p_ocean_instance, compute_ddo.did) assert ddo, f'resolve did {compute_ddo.did} failed.' _compute_ddo = p_ocean_instance.assets.resolve(compute_ddo.did) # algorithm with download service algorithm_ddo_path = get_resource_path('ddo', 'ddo_sample_algorithm.json') algo_main = Asset(json_filename=algorithm_ddo_path).metadata['main'] algo_meta_dict = algo_main['algorithm'].copy() algo_meta_dict['url'] = algo_main['files'][0]['url'] algorithm_meta = AlgorithmMetadata(algo_meta_dict) ###### # Mint tokens for dataset and assign to publisher dt = p_ocean_instance.get_data_token(compute_ddo.data_token_address) mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet) ###### # Give the consumer some datatokens so they can order the service try: tx_id = dt.transfer_tokens(consumer_wallet.address, 10, pub_wallet) dt.verify_transfer_tx(tx_id, pub_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise ###### # Order compute service from the dataset asset order_requirements = cons_ocn.assets.order( compute_ddo.did, consumer_wallet.address, service_type=ServiceTypes.CLOUD_COMPUTE) ###### # Start the order on-chain using the `order` requirements from previous step service = compute_ddo.get_service(ServiceTypes.CLOUD_COMPUTE) _order_tx_id = cons_ocn.assets.pay_for_service( order_requirements.amount, order_requirements.data_token_address, compute_ddo.did, service.index, '0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9', consumer_wallet) ###### job_id = cons_ocn.compute.start(did, consumer_wallet, _order_tx_id, nonce=order_requirements.nonce, algorithm_meta=algorithm_meta) assert job_id, f'expected a job id, got {job_id}' status = cons_ocn.compute.status(did, job_id, consumer_wallet) print(f'got job status: {status}') assert status and status[ 'ok'], f'something not right about the compute job, got status: {status}' status = cons_ocn.compute.stop(did, job_id, consumer_wallet) print(f'got job status after requesting stop: {status}') assert status, f'something not right about the compute job, got status: {status}'
def __init__(self): """Initialise shared variables.""" self.publisher_wallet = get_publisher_wallet() self.consumer_wallet = get_consumer_wallet() self.publisher_ocean_instance = get_publisher_ocean_instance() self.consumer_ocean_instance = get_consumer_ocean_instance()
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_ddo_on_chain(): config = ConfigProvider.get_config() ddo_address = get_contracts_addresses( "ganache", config)[MetadataContract.CONTRACT_NAME] dtfactory_address = get_contracts_addresses( "ganache", config)[DTFactory.CONTRACT_NAME] ddo_registry = MetadataContract(ddo_address) wallet = get_publisher_wallet() web3 = Web3Provider.get_web3() dtfactory = DTFactory(dtfactory_address) tx_id = dtfactory.createToken("", "dt1", "dt1", 1000, wallet) dt = DataToken(dtfactory.get_token_address(tx_id)) # test create ddo asset = get_ddo_sample(dt.address) old_name = asset.metadata["main"]["name"] txid = ddo_registry.create( asset.asset_id, b"", lzma.compress(web3.toBytes(text=asset.as_text())), wallet) assert ddo_registry.verify_tx(txid), f"create ddo failed: txid={txid}" logs = ddo_registry.event_MetadataCreated.processReceipt( ddo_registry.get_tx_receipt(txid)) assert logs, f"no logs found for create ddo tx {txid}" log = logs[0] assert add_0x_prefix(log.args.dataToken) == asset.asset_id # read back the asset ddo from the event log ddo_text = web3.toText(lzma.decompress(log.args.data)) assert ddo_text == asset.as_text(), "ddo text does not match original." _asset = Asset(json_text=ddo_text) assert _asset.did == asset.did, "did does not match." name = _asset.metadata["main"]["name"] assert name == old_name, f"name does not match: {name} != {old_name}" # test_update ddo asset.metadata["main"]["name"] = "updated name for test" txid = ddo_registry.update( asset.asset_id, b"", lzma.compress(web3.toBytes(text=asset.as_text())), wallet) assert ddo_registry.verify_tx(txid), f"update ddo failed: txid={txid}" logs = ddo_registry.event_MetadataUpdated.processReceipt( ddo_registry.get_tx_receipt(txid)) assert logs, f"no logs found for update ddo tx {txid}" log = logs[0] assert add_0x_prefix(log.args.dataToken) == asset.asset_id # read back the asset ddo from the event log ddo_text = web3.toText(lzma.decompress(log.args.data)) assert ddo_text == asset.as_text(), "ddo text does not match original." _asset = Asset(json_text=ddo_text) assert (_asset.metadata["main"]["name"] == "updated name for test" ), "name does not seem to be updated." assert DataToken(asset.asset_id).contract_concise.isMinter(wallet.address) # test update fails from wallet other than the original publisher bob = get_consumer_wallet() try: txid = ddo_registry.update( asset.asset_id, b"", lzma.compress(web3.toBytes(text=asset.as_text())), bob) assert ddo_registry.verify_tx( txid) is False, f"update ddo failed: txid={txid}" logs = ddo_registry.event_MetadataUpdated.processReceipt( ddo_registry.get_tx_receipt(txid)) assert ( not logs ), f"should be no logs for MetadataUpdated, but seems there are some logs: tx {txid}, logs {logs}" except ValueError: print("as expected, only owner can update a published ddo.") # test ddoOwner assert DataToken(asset.asset_id).contract_concise.isMinter( wallet.address ), (f"ddo owner does not match the expected publisher address {wallet.address}, " f"owner is {DataToken(asset.asset_id).contract_concise.minter(wallet.address)}" )
def test_register_asset(publisher_ocean_instance): 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, f'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, f'no ddo created event.' ddo = wait_for_ddo(ocn, did) 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 try: ocn.assets.update(ddo, bob) assert False, f'this asset update should fail, but did not.' except Exception: pass _ = ocn.assets.update(ddo, alice) log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_UPDATED, block, asset_id, 30) assert log, f'no ddo updated event' _asset = wait_for_update(ocn, ddo.did, 'name', _name) assert _asset, f'Cannot read asset after update.' assert _asset.metadata['main'][ 'name'] == _name, f'updated asset does not have the new updated name !!!' assert ocn.assets.owner( ddo.did) == alice.address, f'asset owner does not seem correct.' assert _get_num_assets(alice.address) == num_assets_owned + 1
def test_market_flow(): """Tests that an order is correctly placed on the market. The parameter implicit_none sends the payload with an empty key as the delegated consumer. The parameter explicit_none sends None as the delegated consumer, explicitly.""" pub_wallet = get_publisher_wallet() publisher_ocean = get_publisher_ocean_instance() consumer_ocean = get_consumer_ocean_instance() # Register asset asset = get_registered_ddo(publisher_ocean, get_metadata(), pub_wallet) assert isinstance(asset, V3Asset) assert asset.data_token_address, "The asset does not have a token address." consumer_wallet = get_consumer_wallet() service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS) sa = Service.from_json(service.as_dictionary()) # Mint data tokens and assign to publisher dt = publisher_ocean.get_data_token(asset.data_token_address) mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet) ###### # Give the consumer some datatokens so they can order the service try: tx_id = dt.transfer(consumer_wallet.address, to_wei(10), pub_wallet) dt.verify_transfer_tx(tx_id, pub_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise ###### # Place order for the download service order_requirements = consumer_ocean.assets.order(asset.did, consumer_wallet.address, sa.index) ###### # Pay for the service args = [ consumer_ocean.web3, order_requirements.amount, order_requirements.data_token_address, asset.did, service.index, "0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9", consumer_wallet, sa.get_c2d_address(), ] _order_tx_id = consumer_ocean.assets.pay_for_service(*args) ###### # Download the asset files asset_folder = consumer_ocean.assets.download( asset.did, sa.index, consumer_wallet, _order_tx_id, consumer_ocean.config.downloads_path, ) assert len(os.listdir(asset_folder)) >= 1, "The asset folder is empty." orders = consumer_ocean.get_user_orders(consumer_wallet.address, asset.asset_id) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders( consumer_wallet.address, consumer_ocean.web3.toChecksumAddress(asset.asset_id)) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" orders = consumer_ocean.get_user_orders(consumer_wallet.address) assert ( orders ), f"no orders found using the order history: datatoken {asset.asset_id}, consumer {consumer_wallet.address}" ###### # Publisher can get the urls of the asset asset_urls = DataServiceProvider.get_asset_urls(asset.did, str(service.index), "http://172.15.0.4:8030", pub_wallet) assert len(asset_urls) == 3 for url in asset_urls: assert "10_Monkey_Species_Small" in url