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
