Beispiel #1
0
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 test_send_claim_def_schema_and_claim_def_in_one_batch(
        looper, tconf, sdk_pool_handle, nodeSet, sdk_wallet_trustee):
    with max_3pc_batch_limits(tconf, size=2) as tconf:
        initial_seq_no = nodeSet[0].domainLedger.size
        wallet_handle, identifier = sdk_wallet_trustee

        # send SCHEMA
        _, schema_json = looper.loop.run_until_complete(
            issuer_create_schema(identifier, "name2", "2.0",
                                 json.dumps(["first", "last"])))
        schema_req_json = looper.loop.run_until_complete(
            build_schema_request(identifier, schema_json))
        schema_req = sdk_sign_and_submit_req(sdk_pool_handle,
                                             sdk_wallet_trustee,
                                             schema_req_json)

        # send CLAIM_DEF
        _, claim_def_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})))
        claim_def_req_json = looper.loop.run_until_complete(
            build_cred_def_request(identifier, claim_def_json))
        claim_def_req_json = modify_field(claim_def_req_json,
                                          initial_seq_no + 1, OPERATION, REF)
        claim_def_req = sdk_sign_and_submit_req(sdk_pool_handle,
                                                sdk_wallet_trustee,
                                                claim_def_req_json)

        # check both are written
        sdk_get_and_check_replies(looper, [schema_req, claim_def_req])
def test_send_get_schema_fails_with_invalid_version(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, send_schema):
    _, did = sdk_wallet_trustee

    request = looper.loop.run_until_complete(build_get_schema_request(did, send_schema))
    request = modify_field(request, '2.0', OPERATION, DATA, VERSION)
    rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
    assert rep[0][1]['result']['seqNo'] is None
def test_send_get_schema_fails_with_invalid_version_syntax(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, send_schema):
    _, did = sdk_wallet_trustee

    request = looper.loop.run_until_complete(build_get_schema_request(did, send_schema))
    request = modify_field(request, 'asd', OPERATION, DATA, VERSION)
    with pytest.raises(RequestNackedException) as e:
        sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
    e.match("Invalid version: 'asd'")
def test_send_get_schema_fails_with_invalid_dest(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, send_schema):
    uuid_identifier = createUuidIdentifier()
    _, did = sdk_wallet_trustee

    request = looper.loop.run_until_complete(build_get_schema_request(did, send_schema))
    request = modify_field(request, uuid_identifier, OPERATION, 'dest')
    rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
    assert rep[0][1]['result']['seqNo'] is None
def testSendGetNymHasInvalidSyntaxIfDestIsEmpty(
        looper, sdk_pool_handle, sdk_wallet_trustee):
    uuidIdentifier = createUuidIdentifier()
    _, 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, '', 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('client request invalid')
def test_send_get_claim_def_with_invalid_signature_not_get_claim(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee,
        added_claim_def_id):
    _, did = sdk_wallet_trustee
    request = looper.loop.run_until_complete(
        build_get_cred_def_request(did, added_claim_def_id))
    request = modify_field(request, 'ABC', 'operation', 'signature_type')
    rep = sdk_get_and_check_replies(looper, [
        sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)
    ])
    assert rep[0][1]['result']['data'] is None
def test_send_claim_def_fails_if_ref_is_not_existing_seqno(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, schema_json):
    wallet_handle, identifier = sdk_wallet_trustee

    _, definition_json = looper.loop.run_until_complete(issuer_create_and_store_credential_def(
        wallet_handle, identifier, schema_json, "some_tag2", "CL", json.dumps({"support_revocation": True})))
    request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
    request = modify_field(request, 999999, OPERATION, REF)
    with pytest.raises(RequestRejectedException) as e:
        sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
    e.match('doesn\'t exist')
def testSendGetNymFailsIfDestIsInvalid(
        looper, sdk_pool_handle, sdk_wallet_trustee):
    uuidIdentifier = createUuidIdentifier()
    invalidIdentifier = uuidIdentifier[:-4]
    _, 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, invalidIdentifier, 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 be one of \[16, 32\]')
def test_update_claim_def_for_same_schema_and_signature_type(
        looper, sdk_pool_handle, nodeSet, sdk_wallet_trustee, schema_json):
    wallet_handle, identifier = sdk_wallet_trustee

    _, definition_json = looper.loop.run_until_complete(issuer_create_and_store_credential_def(
        wallet_handle, identifier, schema_json, "some_tag3", "CL", json.dumps({"support_revocation": True})))
    request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
    sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])

    definition_json = modify_field(definition_json, '999', 'value', 'primary', 'n')
    request = looper.loop.run_until_complete(build_cred_def_request(identifier, definition_json))
    sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request)])
def test_send_get_attr_fails_with_missing_dest(looper, sdk_pool_handle,
                                               sdk_wallet_trustee,
                                               send_raw_attrib):
    _, submitter_did = sdk_wallet_trustee
    req = looper.loop.run_until_complete(
        build_get_attrib_request(submitter_did, submitter_did, attrib_name,
                                 None, None))
    req = modify_field(req, '', 'operation', 'dest')
    request_couple = sdk_sign_and_send_prepared_request(
        looper, sdk_wallet_trustee, sdk_pool_handle, req)
    with pytest.raises(RequestNackedException) as e:
        sdk_get_and_check_replies(looper, [request_couple])
    e.match('should be one of \[16, 32\]')
def test_send_get_claim_def_with_invalid_ref_fails(looper, sdk_pool_handle,
                                                   nodeSet, sdk_wallet_trustee,
                                                   added_claim_def_id):
    _, did = sdk_wallet_trustee
    request = looper.loop.run_until_complete(
        build_get_cred_def_request(did, added_claim_def_id))
    request = modify_field(request, '!@#', 'operation', 'ref')
    with pytest.raises(RequestNackedException) as e:
        sdk_get_and_check_replies(looper, [
            sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee,
                                    request)
        ])
    e.match('expected types \'int\', got \'str\'')