def test_idr_cache_update_after_catchup(txnPoolNodeSet, looper,
sdk_pool_handle, sdk_wallet_steward,
tconf, tdir, allPluginsPath):
wallet_handle, identifier = sdk_wallet_steward
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper,
txnPoolNodeSet,
node_to_disconnect.name,
stopNode=True)
looper.removeProdable(node_to_disconnect)
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
restarted_node = start_stopped_node(node_to_disconnect, looper, tconf,
tdir, allPluginsPath)
txnPoolNodeSet[-1] = restarted_node
waitNodeDataEquality(looper, restarted_node, *txnPoolNodeSet[:-1])
req_handler = restarted_node.get_req_handler(DOMAIN_LEDGER_ID)
root_hash = req_handler.ts_store.get_equal_or_prev(
get_txn_time(result['result']))
key = domain.make_state_path_for_nym(idr)
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert from_state
deserialized = req_handler.stateSerializer.deserialize(from_state)
assert deserialized
items_after = req_handler.idrCache.get(idr)
assert items_after
def testSendGetNymFailsIfDestIsPassedInHexFormat(looper, sdk_pool_handle,
sdk_wallet_trustee):
# Sometimes hex representation can use only base58 compatible characters
while True:
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
hexEncodedUuidIdentifier = hexlify(
friendlyToRaw(uuidIdentifier)).decode()
if not check_str_is_base58_compatible(hexEncodedUuidIdentifier):
break
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_trustee,
dest=uuidIdentifier,
verkey=abbrevVerkey)
_, s_did = sdk_wallet_trustee
get_nym_req = looper.loop.run_until_complete(
build_get_nym_request(s_did, uuidIdentifier))
get_nym_req = modify_field(get_nym_req, hexEncodedUuidIdentifier,
IDENTIFIER)
req = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
sdk_pool_handle, get_nym_req)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, [req])
e.match('should not contain the following chars')
def provisioned(provisioned_role):
did, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
return (
DIDWallet(
did=did,
role=provisioned_role if provisioned_role else Roles.IDENTITY_OWNER,
verkey=verkey),
provisioned_role is None)
def rotation_verkey(request):
if request.param in (Rotations.none_none, Rotations.none_val):
request.node.add_marker('skip_did_verkey')
verkey = None
if request.param in (Rotations.val_val, Rotations.none_val):
_, verkey_ = createHalfKeyIdentifierAndAbbrevVerkey()
return verkey
def testSendNymSucceedsForOmittedRole(looper, sdk_pool_handle, txnPoolNodeSet,
nym_request, sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {'dest': halfKeyIdentifier, 'verkey': abbrevVerkey}
del nym_request[OPERATION][ROLE]
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(
looper, sdk_wallet_trustee, sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def testSendNymHasInvalidSyntaxIfParametersOrderIsWrong(
looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': TRUST_ANCHOR
}
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def testSendNymFailsIfRoleIsSpecifiedUsingNumericCode(
looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': TRUST_ANCHOR.value
}
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def testSendNymFailsIfAbbrevVerkeysdk_pool_handleesNotContainTilde(
looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey.replace('~', ''),
'role': TRUST_ANCHOR
}
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def test_get_nym_returns_role(
looper, sdk_pool_handle, sdk_wallet_trustee):
current_role = ENDORSER_STRING
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee,
dest=uuidIdentifier, verkey=abbrevVerkey, role=current_role)
get_nym(looper, sdk_pool_handle, sdk_wallet_trustee, createUuidIdentifier())
new_role = ''
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee,
dest=uuidIdentifier, role=new_role, skipverkey=True)
get_nym(looper, sdk_pool_handle, sdk_wallet_trustee, createUuidIdentifier())
def testSendNymFailsIfAbbrevVerkeyContainsNonBase58Characters(
looper, sdk_pool_handle, txnPoolNodeSet, nym_request,
sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey[:6] + '/' + abbrevVerkey[7:],
'role': ENDORSER
}
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(
looper, sdk_wallet_trustee, sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def testSendNymFailsIfAbbrevVerkeyIsHexEncoded(looper, sdk_pool_handle,
txnPoolNodeSet, nym_request,
sdk_wallet_trustee):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': '~' + friendlyToHexStr(abbrevVerkey.replace('~', '')),
'role': ENDORSER
}
nym_request[OPERATION].update(parameters)
request_couple = sdk_sign_and_send_prepared_request(
looper, sdk_wallet_trustee, sdk_pool_handle, json.dumps(nym_request))
sdk_get_and_check_replies(looper, [request_couple])
def test_nym_reply_is_valid(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
_, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_nym_txn(reply['result']['txn'])
def req(request, looper, sdk_pool_handle, sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
if request.param == "ATTRIB":
raw = json.dumps({'answer': 42})
request_json = looper.loop.run_until_complete(
build_attrib_request(identifier,
identifier,
raw=raw,
xhash=None,
enc=None))
elif request.param == "SCHEMA":
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0",
json.dumps(["first", "last"])))
request_json = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
elif request.param == "RS_SCHEMA":
rs_schema = {'@id': "fakeId234e", '@type': "0od"}
request_json = build_rs_schema_request(identifier, rs_schema,
"ISO18023_Drivers_License",
"1.1")
elif request.param == "CLAIM_DEF":
schema_json, _ = sdk_write_schema(looper, sdk_pool_handle,
sdk_wallet_steward)
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(
build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
_, schema_json = looper.loop.run_until_complete(
parse_get_schema_response(json.dumps(reply)))
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag", "CL",
json.dumps({"support_revocation": True})))
request_json = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
elif request.param == "NYM":
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request_json = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request_json))
return Request(**json.loads(req_signed))
def test_nym_resend(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
wallet_handle, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request))
for i in range(2):
result = json.loads(
looper.loop.run_until_complete(
submit_request(sdk_pool_handle, req_signed)))
assert result['op'] == REPLY
def create_new_did(looper, sdk_pool_handle, creator, role, skipverkey=False):
op = {
'type': NYM,
'role': role.value
}
new_did_verkey = None
if skipverkey:
new_did, _ = createHalfKeyIdentifierAndAbbrevVerkey()
op.update({'dest': new_did})
else:
new_did, new_did_verkey = looper.loop.run_until_complete(
create_and_store_my_did(creator.wallet_handle, "{}"))
op.update({'dest': new_did, 'verkey': new_did_verkey})
req = sdk_sign_and_submit_op(looper, sdk_pool_handle, creator.wallet_did, op)
sdk_get_and_check_replies(looper, [req])
return DIDWallet(did=new_did, role=role, verkey=new_did_verkey,
creator=creator, wallet_handle=creator.wallet_handle)
