def test_did_validate():
test_did = did_generate_random()
did_id = did_to_id(test_did)
did_validate(test_did)
did_validate(f'{test_did}/test')
did_validate(f'{test_did}01021A2A/test')
test_did = (did_id, did_id)
with pytest.raises(TypeError):
did_validate(test_did)
assert (not is_did(test_did))
test_did = 'test-text'
with pytest.raises(ValueError, match='must start'):
did_validate(test_did)
assert (not is_did(test_did))
test_did = 'did'
with pytest.raises(ValueError, match='must start'):
did_validate(test_did)
assert (not is_did(test_did))
test_did = f'did:extra-long:{did_id}'
with pytest.raises(ValueError, match='"id" must have only'):
did_validate(test_did)
assert (not is_did(test_did))
test_did = f'did:valid:0x01A2B3C'
with pytest.raises(ValueError,
match='path should only have hex characters'):
did_validate(test_did)
assert (not is_did(test_did))
def test_did_parse():
test_did = did_generate_random()
did_id = did_to_id(test_did)
# basic parse
value = did_parse(test_did)
assert (value['method'] == 'dep')
assert (f'0x{value["id"]}' == did_id)
assert (value['id_hex'] == did_id)
assert (value['fragment'] is None)
assert (value['path'] is None)
# test path
test_path = secrets.token_hex(32)
value = did_parse(f'{test_did}/{test_path}')
assert (value['method'] == 'dep')
assert (f'0x{value["id"]}' == did_id)
assert (value['id_hex'] == did_id)
assert (value['fragment'] == '')
assert (value['path'] == test_path)
# test fragment
test_path = secrets.token_hex(32)
test_fragment = secrets.token_urlsafe(32)
value = did_parse(f'{test_did}/{test_path}#{test_fragment}')
assert (value['method'] == 'dep')
assert (f'0x{value["id"]}' == did_id)
assert (value['id_hex'] == did_id)
assert (value['fragment'] == test_fragment)
assert (value['path'] == test_path)
def test_contract_did_methods(convex_network, convex_accounts):
register_account = convex_accounts[1]
auto_topup_account(convex_network, register_account)
query_address = register_account.address
did = did_generate_random()
ddo = f'test - ddo - {did}'
contract = DIDContract(convex_network.convex)
assert (contract)
assert (contract.resolve_address('starfish-test.did'))
assert (contract.address)
result = contract.register_did(did, ddo, register_account)
assert (result)
assert (result == did)
result = contract.resolve(did, query_address)
assert (result)
assert (result == ddo)
result = contract.owner(did, query_address)
assert (result)
assert (result == query_address)
def test_ddo_get_did_from_ddo():
did = did_generate_random()
test_url = 'http://localhost'
ddo = DDO.create(test_url, service_list=['meta', 'trust'], did=did)
assert(ddo)
assert(ddo.did == did)
assert(DDO.get_did_from_ddo(ddo) == did)
assert(DDO.get_did_from_ddo(ddo.as_text) == did)
def __init__(self, ddo: DDO = None) -> None:
if ddo is None:
did = did_generate_random()
ddo = DDO(did)
AgentBase.__init__(self, ddo=ddo)
self._memory = {'listing': {}, 'asset': {}, 'purchase': {}}
def test_asset_create_asset_provenance_invoke():
agent_did = did_generate_random()
job_id = secrets.token_hex(32)
inputs_text = json.dumps({'asset_list': 'json'})
asset = AssetBase(json.dumps(ASSET_METADATA))
assert (asset)
asset = create_asset_provenance_invoke(asset, agent_did, job_id, None,
inputs_text)
assert (asset.metadata['provenance'])
def test_asset_id():
asset = AssetBase(json.dumps(ASSET_METADATA), did=TEST_DID)
assert (asset)
with pytest.raises(ValueError):
asset_id = decode_to_asset_id(asset.did)
test_did = did_generate_random()
asset_id = secrets.token_hex(32)
asset_did = f'{test_did}/{asset_id}'
asset = AssetBase(json.dumps(ASSET_METADATA), did=asset_did)
assert (asset)
def test_network_resolve_agent(config, ethereum_network, ethereum_accounts):
local_agent = config['agents']['surfer']
ddo = ethereum_network.resolve_agent(local_agent['url'])
did = did_generate_random()
ddo = DDO.create(local_agent['url'])
ddo_text = ddo.as_text
register_account = ethereum_accounts[0]
ethereum_network.register_did(register_account, did, ddo_text)
ddo = ethereum_network.resolve_agent(did)
assert (ddo)
def test_convex_network_did(convex_network, convex_accounts):
register_account = convex_accounts[0]
auto_topup_account(convex_network, register_account)
did = did_generate_random()
ddo = f'test - ddo - {did}'
result = convex_network.register_did(register_account, did, ddo)
assert (result)
assert (result == did)
result = convex_network.resolve_did(did, register_account.address)
assert (result)
assert (result == ddo)
def test_provenance_create_publish():
# minimum allowed
provenance = Provenance()
result = provenance.create_publish
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'publish')
assert_was_generated_by(result, activity_id)
assert ('agent' not in result)
assert ('wasAssociatedWith' not in result)
# with agent_did
agent_did = did_generate_random()
provenance = Provenance(agent_did)
result = provenance.create_publish
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'publish')
assert_was_generated_by(result, activity_id)
assert_agent(result, agent_did)
assert_was_associated_with(result, activity_id, agent_did)
# with agent did and activity_id
agent_did = did_generate_random()
activity_id = 'abc-123-test'
provenance = Provenance(agent_did=agent_did, activity_id=activity_id)
result = provenance.create_publish
#print(json.dumps(result, indent=4))
assert_prefix(result)
assert_activity(result, activity_id, 'publish')
assert_was_generated_by(result, activity_id)
assert_agent(result, agent_did)
assert_was_associated_with(result, activity_id, agent_did)
def test_provenance_create_import():
# minimum allowed
provenance = Provenance()
result = provenance.create_import
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'import')
assert_was_generated_by(result, activity_id)
assert ('agent' not in result)
assert ('wasAssociatedWith' not in result)
# with agent_did
agent_did = did_generate_random()
provenance = Provenance(agent_did=agent_did)
result = provenance.create_import
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'import')
assert_was_generated_by(result, activity_id)
assert_agent(result, agent_did)
assert_was_associated_with(result, activity_id, agent_did)
# with agent did and activity_id
agent_did = did_generate_random()
activity_id = 'abc-123-test'
provenance = Provenance(agent_did=agent_did, activity_id=activity_id)
result = provenance.create_import
assert_prefix(result)
assert_activity(result, activity_id, 'import')
assert_was_generated_by(result, activity_id)
assert_agent(result, agent_did)
assert_was_associated_with(result, activity_id, agent_did)
def __init__(self, did=None, service=None):
if did is None:
did = did_generate_random()
self._did = did
self._service = {}
if service:
if not isinstance(service, (tuple, list)):
raise TypeError('Service data must be a tuple or list')
for item in service:
service_type = item['type']
name = DDO._supported_service_name_from_type(service_type)
if not name:
name = service_type.lower()
self._service[name] = item
def test_01_connect_to_remote_agent(convex_network, config, convex_accounts):
register_account = convex_accounts[0]
did = did_generate_random()
assert(did)
ddo = {
'name': 'Test ddo',
'value': secrets.token_hex(64)
}
convex_network.register_did(register_account, did, json.dumps(ddo))
resolve_ddo = convex_network.resolve_did(did)
assert(resolve_ddo)
found_ddo = json.loads(resolve_ddo)
assert(found_ddo == ddo)
def test_decode_to_asset_id():
asset_id = secrets.token_hex(32)
test_did = did_generate_random()
# decode did/asset_id
did = f'{test_did}/{asset_id}'
assert (asset_id == decode_to_asset_id(did))
assert (is_asset_did(did))
assert (asset_did_validate(did))
# decode did/asset_id with leading 0x
did = f'{test_did}/0x{asset_id}'
assert (asset_id == decode_to_asset_id(did))
assert (is_asset_did(did))
assert (asset_did_validate(did))
# decode asset_id
assert (asset_id == decode_to_asset_id(asset_id))
# decode asset_id with leading 0x
assert (asset_id == decode_to_asset_id(f'0x{asset_id}'))
# fail decode with only did
with pytest.raises(ValueError, match='Unable to get an asset_id'):
assert (decode_to_asset_id(test_did))
with pytest.raises(ValueError, match='does not have an asset_id'):
assert (asset_did_validate(test_did))
assert (not is_asset_did(test_did))
# fail decode with invalid asset_id length is too long
did = f'{test_did}/{asset_id}12A3B4C'
with pytest.raises(ValueError, match='asset_id is not valid '):
assert (decode_to_asset_id(did))
with pytest.raises(ValueError, match='has an invalid asset_id'):
assert (asset_did_validate(did))
# passes did valdiaton but fails asset_did validation
did = f'{test_did}/00112233445566778899AA'
assert (decode_to_asset_id(did))
with pytest.raises(ValueError, match='has an invalid asset_id'):
assert (asset_did_validate(did))
assert (not is_asset_did(did))
def test_contract_did_full_ddo(convex_network, convex_accounts):
register_account = convex_accounts[1]
auto_topup_account(convex_network, register_account)
query_address = register_account.address
did = did_generate_random()
now = datetime.datetime.now()
ddo = {
'@context':
'https://w3id.org/did/v1',
'id':
did,
'created':
now.isoformat(sep=' '),
'service': [{
'type': 'DEP.Invoke.v1',
'serviceEndpoint': 'http://127.0.0.1:9999/api/v1/invoke'
}, {
'type': 'DEP.Meta.v1',
'serviceEndpoint': 'http://127.0.0.1:9999/api/v1/meta'
}, {
'type': 'DEP.Storage.v1',
'serviceEndpoint': 'http://127.0.0.1:9999/api/v1/assets'
}, {
'type': 'DEP.Auth.v1',
'serviceEndpoint': 'http://127.0.0.1:9999/api/v1/auth'
}]
}
contract = DIDContract(convex_network.convex)
assert (contract)
assert (contract.resolve_address('starfish-test.did'))
assert (contract.address)
result = contract.register_did(did, json.dumps(ddo), register_account)
assert (result)
assert (result == did)
result = contract.resolve(did, query_address)
assert (result)
assert (result == json.dumps(ddo))
def test_provenance_create_invoke():
# test minimum allowed for create_invoke
provenance = Provenance()
result = provenance.create_invoke
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'invoke')
assert_was_generated_by(result, activity_id)
assert_entity(result)
assert ('agent' not in result)
assert ('wasAssociatedWith' not in result)
#test all values set for create_invoke
agent_did = did_generate_random()
activity_id = 'job-id-123-abc'
asset_list = []
for index in range(0, 4):
asset_id = secrets.token_hex(32)
asset_list.append(f'{agent_did}/{asset_id}')
inputs_text = json.dumps({'asset_list': 'json'})
provenance = Provenance(agent_did=agent_did,
activity_id=activity_id,
asset_list=asset_list,
inputs_text=inputs_text)
result = provenance.create_invoke
assert_prefix(result)
activity_id = get_activity_id(result)
assert_activity(result, activity_id, 'invoke', inputs_text)
assert_was_generated_by(result, activity_id)
assert_entity(result, asset_list)
assert_agent(result, agent_did)
assert_was_associated_with(result, activity_id, agent_did)
assert_was_derived_from(result, asset_list)
def test_did_registry_contract(ethereum_network, config, ethereum_accounts):
"""
Register and find a ddo based on a did
"""
did_registry_contract = ethereum_network.get_contract('DIDRegistry')
did = did_generate_random()
local_agent = config['agents']['surfer']
ddo = DDO.create('http://localhost', did=did)
ddo_text = ddo.as_text
register_account = ethereum_accounts[0]
tx_hash = did_registry_contract.register(register_account, did, ddo_text)
receipt = did_registry_contract.wait_for_receipt(tx_hash)
block_number = did_registry_contract.get_block_number(did)
assert (receipt.blockNumber == block_number)
saved_ddo_text = did_registry_contract.get_value(did)
assert (ddo_text == saved_ddo_text)
def test_did_to_id():
test_did = did_generate_random()
did_id = did_to_id(test_did)
value = did_parse(test_did)
assert (value['id_hex'] == did_id)
def test_contract_did_long_string(convex_network, convex_accounts):
big_data = '''
{
"activity": {
"21bac5c9": {
"dep:inputs": {
"$": "{\"date_from\": \"2020-01-01\", \"user_id\": \"7HZQ9P\"}",
"type": "xsd:string"
},
"prov:type": {
"$": "dep:invoke",
"type": "xsd:string"
}
}
},
"agent": {
"did:dep:118d107119d8d293f7b25701730545abe9db8e5c633a995b295166c32e97dccc": {
"prov:type": {
"$": "dep:service-provider",
"type": "xsd:string"
}
}
},
"entity": {
"dep:this": {
"prov:type": {
"$": "dep:asset",
"type": "xsd:string"
}
},
"did:dep:118d107119d8d293f7b25701730545abe9db8e5c633a995b295166c32e97dccc/4d96cd618a3971424c048d417cc759cdaebd0da3d465f94feb5d2f25796ce739": {
"prov:type": {
"$": "dep:asset",
"type": "xsd:string"
}
}
},
"prefix": {
"dep": "http://datacraft.sg",
"prov": "http://www.w3.org/ns/prov#",
"xsd": "http://www.w3.org/2001/XMLSchema#"
},
"wasAssociatedWith": {
"_:assoc_1": {
"prov:activity": "21bac5c9",
"prov:agent": "did:dep:118d107119d8d293f7b25701730545abe9db8e5c633a995b295166c32e97dccc"
}
},
"wasDerivedFrom": {
"_:derived_1": {
"prov:generatedEntity": "dep:this",
"prov:usedEntity": "did:dep:118d107119d8d293f7b25701730545abe9db8e5c633a995b295166c32e97dccc/4d96cd618a3971424c048d417cc759cdaebd0da3d465f94feb5d2f25796ce739"
}
},
"wasGeneratedBy": {
"_:gen_1": {
"prov:activity": "21bac5c9",
"prov:entity": "dep:this"
}
}
}
'''
register_account = convex_accounts[1]
query_address = register_account.address
auto_topup_account(convex_network, register_account)
did = did_generate_random()
contract = DIDContract(convex_network.convex)
assert (contract)
assert (contract.resolve_address('starfish-test.did'))
assert (contract.address)
result = contract.register_did(did, big_data, register_account)
assert (result)
assert (result == did)
result = contract.resolve(did, query_address)
assert (result)
assert (result == big_data)
import logging
import json
import pytest
from starfish.asset import (AssetBase, create_asset_provenance_publish,
create_asset_provenance_invoke)
from starfish.network.did import (did_to_id, id_to_did, decode_to_asset_id,
did_generate_random)
ASSET_METADATA = {
'name': 'Asset',
'type': 'dataset',
}
TEST_DID = did_generate_random()
def test_init(metadata):
asset = AssetBase(json.dumps(ASSET_METADATA))
assert (asset)
assert (isinstance(asset, AssetBase))
def test_metadata():
asset = AssetBase(json.dumps(ASSET_METADATA))
assert (asset)
assert (asset.metadata == ASSET_METADATA)
def test_data():
def test_ddo_basic_init():
did = did_generate_random()
ddo = DDO(did)
assert(ddo)
assert(ddo.did == did)
def test_asset_create_asset_provenance_publish():
agent_did = did_generate_random()
asset = AssetBase(json.dumps(ASSET_METADATA))
assert (asset)
asset = create_asset_provenance_publish(asset, agent_did)
assert (asset.metadata['provenance'])
