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.getDomainReqHandler()
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 test_send_different_nyms_succeeds_when_batched(
be, do, poolNodesStarted, newStewardCli):
be(newStewardCli)
idr_1, verkey_1 = createHalfKeyIdentifierAndAbbrevVerkey()
idr_2, verkey_2 = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': idr_1,
'verkey': verkey_1
}
# request 1
newStewardCli.enterCmd(
"send NYM dest={dest} verkey={verkey}".format(
dest=idr_1, verkey=verkey_1))
parameters = {
'dest': idr_2,
'verkey': verkey_2
}
# two different nyms, batched, both should be written
# request 2
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=10)
parameters = {
'dest': idr_1,
'verkey': verkey_1
}
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
parameters = {
'dest': idr_2,
'verkey': verkey_2
}
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
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 testSendNymFailsIfRoleIsUnknown(be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': 'SUPERVISOR'
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymSucceedsForOmittedRole(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey
}
be(trusteeCli)
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=2)
def testSendNymFailsIfRoleIsUnknown(be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': 'SUPERVISOR'
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
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 testSendGetNymSucceedsForExistingUuidDest(be, do, poolNodesStarted,
trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {'dest': uuidIdentifier, 'verkey': abbrevVerkey}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect=CURRENT_VERKEY_FOR_NYM,
within=2)
def testSendNymSucceedsForOmittedRole(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey
}
be(trusteeCli)
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=2)
def testSendGetNymHasInvalidSyntaxIfUnknownParameterIsPassed(
be, do, poolNodesStarted, trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {'dest': uuidIdentifier, 'extra': 42}
be(trusteeCli)
do('send GET_NYM dest={dest} extra={extra}',
mapper=parameters,
expect=INVALID_SYNTAX,
within=2)
def testSendNymFailsIfAbbrevVerkeyContainsNonBase58Characters(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey[:6] + '/' + abbrevVerkey[7:],
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendGetNymSucceedsForExistingUuidDest(
be, do, poolNodesStarted, trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {
'dest': uuidIdentifier,
'verkey': abbrevVerkey
}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
def testSendGetNymHasInvalidSyntaxIfUnknownParameterIsPassed(
be, do, poolNodesStarted, trusteeCli):
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {
'dest': uuidIdentifier,
'extra': 42
}
be(trusteeCli)
do('send GET_NYM dest={dest} extra={extra}',
mapper=parameters, expect=INVALID_SYNTAX, within=2)
def testSendNymFailsIfAbbrevVerkeyDoesNotContainTilde(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey.replace('~', ''),
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymHasInvalidSyntaxIfParametersOrderIsWrong(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM verkey={verkey} role={role} dest={dest}',
mapper=parameters, expect=INVALID_SYNTAX, within=2)
def testSendNymFailsIfRoleIsSpecifiedUsingNumericCode(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.value
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymFailsIfAbbrevVerkeyDoesNotContainTilde(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey.replace('~', ''),
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymFailsIfAbbrevVerkeyContainsNonBase58Characters(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey[:6] + '/' + abbrevVerkey[7:],
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymHasInvalidSyntaxIfParametersOrderIsWrong(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM verkey={verkey} role={role} dest={dest}',
mapper=parameters, expect=INVALID_SYNTAX, within=2)
def testSendNymSucceedsForHalfKeyIdentifierAndAbbrevVerkey(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=2)
def testSendNymFailsIfRoleIsSpecifiedUsingNumericCode(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.value
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=ERROR, within=2)
def testSendNymSucceedsForHalfKeyIdentifierAndAbbrevVerkey(
be, do, poolNodesStarted, trusteeCli):
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey,
'role': Roles.TRUST_ANCHOR.name
}
be(trusteeCli)
do('send NYM dest={dest} role={role} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=2)
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 test_send_different_nyms_succeeds_when_batched(be, do, poolNodesStarted,
newStewardCli):
be(newStewardCli)
idr_1, verkey_1 = createHalfKeyIdentifierAndAbbrevVerkey()
idr_2, verkey_2 = createHalfKeyIdentifierAndAbbrevVerkey()
parameters = {'dest': idr_1, 'verkey': verkey_1}
# request 1
newStewardCli.enterCmd("send NYM dest={dest} verkey={verkey}".format(
dest=idr_1, verkey=verkey_1))
parameters = {'dest': idr_2, 'verkey': verkey_2}
# two different nyms, batched, both should be written
# request 2
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters,
expect=NYM_ADDED,
within=10)
parameters = {'dest': idr_1, 'verkey': verkey_1}
do('send GET_NYM dest={dest}',
mapper=parameters,
expect=CURRENT_VERKEY_FOR_NYM,
within=2)
parameters = {'dest': idr_2, 'verkey': verkey_2}
do('send GET_NYM dest={dest}',
mapper=parameters,
expect=CURRENT_VERKEY_FOR_NYM,
within=2)
def test_send_same_nyms_only_first_gets_written(
be, do, poolNodesStarted, newStewardCli):
be(newStewardCli)
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
_, anotherAbbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
# request 1
newStewardCli.enterCmd(
"send NYM {dest}={nym} verkey={verkey}". format(
dest=TARGET_NYM,
nym=halfKeyIdentifier,
verkey=abbrevVerkey))
parameters = {
'dest': halfKeyIdentifier,
'verkey': anotherAbbrevVerkey
}
# "enterCmd" does not immediately send to server, second request with same NYM
# and different verkey should not get written to ledger.
# request 2
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=10)
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey
}
# check that second request didn't write to ledger and first verkey is
# written
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
def test_send_same_nyms_only_first_gets_written(
be, do, poolNodesStarted, newStewardCli):
be(newStewardCli)
halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
_, anotherAbbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
# request 1
newStewardCli.enterCmd(
"send NYM {dest}={nym} verkey={verkey}". format(
dest=TARGET_NYM,
nym=halfKeyIdentifier,
verkey=abbrevVerkey))
parameters = {
'dest': halfKeyIdentifier,
'verkey': anotherAbbrevVerkey
}
# "enterCmd" does not immediately send to server, second request with same NYM
# and different verkey should not get written to ledger.
# request 2
do('send NYM dest={dest} verkey={verkey}',
mapper=parameters, expect=NYM_ADDED, within=10)
parameters = {
'dest': halfKeyIdentifier,
'verkey': abbrevVerkey
}
# check that second request didn't write to ledger and first verkey is
# written
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
def testSendAttribSucceedsForExistingDidDest(be, do, poolNodesStarted,
localTrusteeCli):
seed = randomSeed()
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey(seed=seed)
userCli = localTrusteeCli
addNym(be, do, userCli, idr=idr, verkey=verkey)
newKey(be, do, userCli, seed=seed.decode())
sendAttribParameters = {'dest': idr, 'raw': json.dumps({'name': 'Alice'})}
be(userCli)
do('send ATTRIB dest={dest} raw={raw}',
mapper=sendAttribParameters,
expect=ATTRIBUTE_ADDED,
within=2)
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 == "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 testSendAttribSucceedsForExistingDidDest(
be, do, poolNodesStarted, localTrusteeCli):
seed = randomSeed()
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey(seed=seed)
userCli = localTrusteeCli
addNym(be, do, userCli, idr=idr, verkey=verkey)
newKey(be, do, userCli, seed=seed.decode())
sendAttribParameters = {
'dest': idr,
'raw': json.dumps({
'name': 'Alice'
})
}
be(userCli)
do('send ATTRIB dest={dest} raw={raw}',
mapper=sendAttribParameters, expect=ATTRIBUTE_ADDED, within=2)
def testSendGetNymFailsIfDestIsPassedInHexFormat(be, do, poolNodesStarted,
trusteeCli):
# 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
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {'dest': hexEncodedUuidIdentifier}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect="should not contain the following chars",
within=2)
def test_get_nym_returns_role(
be, do, poolNodesStarted, trusteeCli):
current_role = Roles.TRUST_ANCHOR
uuidIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey()
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey,
role=current_role)
parameters = {
'dest': uuidIdentifier,
'verkey': abbrevVerkey,
'role': current_role
}
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM_WITH_ROLE, within=2)
new_role = ''
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey,
role=new_role)
do('send GET_NYM dest={dest}',
mapper=parameters, expect=CURRENT_VERKEY_FOR_NYM, within=2)
def testSendGetNymFailsIfDestIsPassedInHexFormat(
be, do, poolNodesStarted, trusteeCli):
# 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
addNym(be, do, trusteeCli, idr=uuidIdentifier, verkey=abbrevVerkey)
parameters = {
'dest': hexEncodedUuidIdentifier
}
be(trusteeCli)
do('send GET_NYM dest={dest}',
mapper=parameters,
expect="should not contain the following chars",
within=2)
