def then_the_identity_is_created_and_registered(identity_type, context: Context):
given_ctx: CreateContext = context.given
created_registered_identity = context.when_ret_values
purpose = get_purpose(identity_type)
assert_newly_created_registered_identity(given_ctx.seed, given_ctx.key_name, given_ctx.identity_name,
given_ctx.seed_method, created_registered_identity, purpose)
assert_single_owner_doc_is_valid(created_registered_identity, purpose, given_ctx.identity_name)
assert_owner_is_allowed(RESOLVER_CLIENT, Issuer.build(created_registered_identity.did, given_ctx.identity_name),
created_registered_identity.did)
def then_the_key_has_been_removed_from_the_document(context: Context):
given_ctx: RemoveOwnerCtx = context.given
initial_owner_issuer = given_ctx.initial_owner_identity.registered_identity.issuer
doc_with_owner_removed = REGULAR_API.get_register_document(initial_owner_issuer.did)
initial_owner_key = doc_with_owner_removed.public_keys.get(initial_owner_issuer.name)
assert initial_owner_key, 'Initial owner key should still belongs to the doc public keys'
assert not initial_owner_key.revoked, 'Initial owner key should not be revoked'
additional_owner_key = doc_with_owner_removed.public_keys.get(given_ctx.additional_owner_issuer.name)
assert not additional_owner_key, 'Additional owner key should not belong to the doc anymore'
assert_owner_not_allowed_anymore(RESOLVER_CLIENT, given_ctx.additional_owner_issuer, doc_with_owner_removed.did)
assert_owner_is_allowed(RESOLVER_CLIENT, initial_owner_issuer, doc_with_owner_removed.did)
def then_the_identity_document_is_updated_with_the_new_name(identity_type, context: Context):
given_ctx: OverridingIdentityCtx = context.given
updated_registered_identity = context.when_ret_values
purpose = get_purpose(identity_type)
assert given_ctx.initial.registered_identity.key_pair_secrets == updated_registered_identity.key_pair_secrets
assert given_ctx.initial.registered_identity.issuer != updated_registered_identity.issuer
assert given_ctx.initial.registered_identity.issuer.did == updated_registered_identity.issuer.did
assert given_ctx.initial.registered_identity.name != updated_registered_identity.name
assert updated_registered_identity.name == given_ctx.new_identity_name
assert_single_owner_doc_is_valid(updated_registered_identity, purpose, given_ctx.new_identity_name)
owner_issuer = Issuer.build(updated_registered_identity.did, given_ctx.new_identity_name)
assert_owner_is_allowed(RESOLVER_CLIENT, owner_issuer, updated_registered_identity.did)
def then_the_new_owner_key_has_been_added_to_the_document(context: Context):
given_ctx: NewOwnerCtx = context.given
initial_owner_issuer = given_ctx.identity_ctx.registered_identity.issuer
doc_with_additional_owner = REGULAR_API.get_register_document(initial_owner_issuer.did)
initial_owner_key = doc_with_additional_owner.public_keys.get(initial_owner_issuer.name)
assert initial_owner_key, 'Initial owner key should still belongs to the doc public keys'
assert not initial_owner_key.revoked, 'Initial owner key should not be revoked'
additional_owner_key = doc_with_additional_owner.public_keys.get(given_ctx.new_owner_name)
assert additional_owner_key, 'New owner key should belongs to the doc public keys'
assert not additional_owner_key.revoked, 'New owner key should not be revoked'
assert additional_owner_key.base58 == given_ctx.new_owner_public_key_base58, 'New owner key base58 is invalid'
new_owner_issuer = Issuer.build(doc_with_additional_owner.did, given_ctx.new_owner_name)
assert_owner_is_allowed(RESOLVER_CLIENT, new_owner_issuer, doc_with_additional_owner.did)
assert_owner_is_allowed(RESOLVER_CLIENT, initial_owner_issuer, doc_with_additional_owner.did)
def then_the_twin_doc_has_a_new_owner(context: Context):
twin_doc = REGULAR_API.get_register_document(
context.given.registered_twin.did)
REGULAR_API.validate_register_document(twin_doc)
expected_key_pair = KeyPairSecretsHelper.get_key_pair(
context.given.registered_user.key_pair_secrets)
owner_issuer = context.given.registered_twin.issuer
owner_key = twin_doc.public_keys.get(owner_issuer.name)
assert owner_key, 'Twin owner key should still belong to the document'
additional_owner_issuer = Issuer.build(owner_issuer.did,
context.given.new_owner_name)
additional_owner_key = twin_doc.public_keys.get(
additional_owner_issuer.name)
assert additional_owner_key, 'Twin additional owner key not found in the register document'
assert not additional_owner_key.revoked, 'Twin additional owner key should not be revoked'
assert additional_owner_key.base58 == expected_key_pair.public_base58, \
'Twin invalid additional owner public key base58'
assert_owner_is_allowed(RESOLVER_CLIENT, additional_owner_issuer,
twin_doc.did)
assert_owner_is_allowed(RESOLVER_CLIENT, owner_issuer, twin_doc.did)
def assert_new_doc_and_identity(doc: RegisterDocument,
registered_identity: RegisteredIdentity,
identity_ctx: IdentityContext):
REGULAR_API.validate_register_document(doc)
assert_newly_created_registered_identity(identity_ctx.seed,
identity_ctx.key_name,
identity_ctx.issuer_name,
SeedMethod.SEED_METHOD_BIP39,
registered_identity, doc.purpose)
assert_owner_key(doc, identity_ctx.issuer_name, registered_identity)
expected_secrets = get_secrets_by_type(identity_ctx.seed,
identity_ctx.key_name, doc.purpose)
expected_key_pair = KeyPairSecretsHelper.get_key_pair(expected_secrets)
expected_issuer = Issuer.build(
AdvancedIdentityLocalApi.create_identifier(
expected_key_pair.public_bytes), identity_ctx.issuer_name)
assert_owner_key(doc, identity_ctx.issuer_name, registered_identity)
assert registered_identity.key_pair_secrets == expected_secrets, 'User corrupted secrets'
assert registered_identity.issuer == expected_issuer, 'User invalid issuer'
owner_issuer = Issuer.build(registered_identity.did,
identity_ctx.issuer_name)
assert_owner_is_allowed(RESOLVER_CLIENT, owner_issuer,
registered_identity.did)