def testStewardCannotAddNodeWithOutFullFieldsSet(looper, tdir, tconf, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward): """ The case: Steward accidentally sends the NODE txn without full fields set. The expected result: Steward gets NAck response from the pool. """ new_node_name = "Epsilon" new_steward_wallet_handle = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, alias='New steward' + randomString( 3), role=STEWARD_STRING) sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof = \ prepare_new_node_data(tconf, tdir, new_node_name) _, steward_did = new_steward_wallet_handle node_request = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name=new_node_name, clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, bls_key=bls_key, sigseed=sigseed, key_proof=key_proof)) # case from the ticket request_json = json.loads(node_request) request_json['operation'][DATA][NODE_PORT + ' '] = \ request_json['operation'][DATA][NODE_PORT] del request_json['operation'][DATA][NODE_PORT] node_request1 = json.dumps(request_json) request_couple = sdk_sign_and_send_prepared_request(looper, new_steward_wallet_handle, sdk_pool_handle, node_request1) with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'missed fields - node_port' in e._excinfo[1].args[0] for fn in (NODE_IP, CLIENT_IP, NODE_PORT, CLIENT_PORT): request_json = json.loads(node_request) del request_json['operation'][DATA][fn] node_request2 = json.dumps(request_json) request_couple = sdk_sign_and_send_prepared_request(looper, new_steward_wallet_handle, sdk_pool_handle, node_request2) # wait NAcks with exact message. it does not works for just 'is missed' # because the 'is missed' will check only first few cases with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'missed fields' in e._excinfo[1].args[0]
def test_get_txn_response_as_expected(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward): seed = randomString(32) wh, _ = sdk_wallet_steward # filling nym request and getting steward did # if role == None, we are adding client nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, None, None)) # sending request using 'sdk_' functions request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_steward, sdk_pool_handle, nym_request) result1 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] seqNo = get_seq_no(result1) _, steward_did = sdk_wallet_steward request = sdk_build_get_txn_request(looper, steward_did, seqNo) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) result2 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] assert result1 == result2['data']
def test_hook_pre_send_reply(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client): def hook_add_field(*args, **kwargs): kwargs['committed_txns'][0][foo] = foo register_hook(txnPoolNodeSet, NodeHooks.PRE_SEND_REPLY, hook_add_field) # Reply on request signed_reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1) reqs = sdk_send_signed_requests(sdk_pool_handle, signed_reqs) reply = sdk_get_and_check_replies(looper, reqs)[0] assert foo in reply[1][f.RESULT.nm] assert reply[1][f.RESULT.nm][foo] == foo # Reply on repeated request reqs = sdk_send_signed_requests(sdk_pool_handle, signed_reqs) reply = sdk_get_and_check_replies(looper, reqs)[0] assert foo in reply[1][f.RESULT.nm] assert reply[1][f.RESULT.nm][foo] == foo # Reply on get_txn request _, did = sdk_wallet_client request = sdk_build_get_txn_request( looper, did, reply[1][f.RESULT.nm][TXN_METADATA][f.SEQ_NO.nm]) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, request) reply = sdk_get_and_check_replies(looper, [request_couple])[0] assert foo in reply[1][f.RESULT.nm]['data'] assert reply[1][f.RESULT.nm]['data'][foo] == foo
def testLoggingTxnStateForInvalidRequest( looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, logsearch): logsPropagate, _ = logsearch(files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsReject, _ = logsearch(files=['replica.py'], funcs=['consume_req_queue_for_pre_prepare'], msgs=['encountered exception.*while processing.*will reject']) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, "name", STEWARD_STRING)) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'Only Steward is allowed to do these transactions' in e._excinfo[1].args[0] request = json.loads(nym_request) req_id = str(request[f.REQ_ID.nm]) digest = get_key_from_req(request) assert any(digest in record.getMessage() for record in logsPropagate) assert any(req_id in record.getMessage() for record in logsReject)
def test_dirty_read(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client): """ Tests the case when read request comes before write request is not executed on some nodes """ slow_nodes = list(txnPoolNodeSet)[2:4] for node in slow_nodes: logger.debug("Making node {} slow".format(node)) make_node_slow(node) received_replies = sdk_send_random_and_check(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, 1) result = received_replies[0][1]["result"] seq_no = get_seq_no(result) _, did = sdk_wallet_client req = sdk_build_get_txn_request(looper, did, seq_no) request = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, req) received_replies = sdk_get_and_check_replies(looper, [request]) results = [str(get_payload_data(reply['result'][DATA])) for _, reply in received_replies] assert len(set(results)) == 1
def test_get_txn_for_existing_seq_no(looper, txnPoolNodeSet, sdk_wallet_steward, sdk_pool_handle): _, steward_did = sdk_wallet_steward for i in range(2): request = sdk_build_get_txn_request(looper, steward_did, 1) # Check with and without ledger id request_json = json.loads(request) if i: request_json['operation']['ledgerId'] = 1 request = json.dumps(request_json) sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request)
def sdk_add_attribute_and_check(looper, sdk_pool_handle, sdk_wallet_handle, attrib, dest=None): _, s_did = sdk_wallet_handle t_did = dest or s_did attrib_req = looper.loop.run_until_complete( build_attrib_request(s_did, t_did, None, attrib, None)) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_handle, sdk_pool_handle, attrib_req) sdk_get_and_check_replies(looper, [request_couple]) return request_couple
def set_verkey(looper, sdk_pool_handle, sdk_wallet_sender, dest, verkey): wh, _ = sdk_wallet_sender nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_sender, None, None, TRUST_ANCHOR_STRING, dest, verkey, False if verkey else True)) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_sender, sdk_pool_handle, nym_request) sdk_get_and_check_replies(looper, [request_couple]) return wh, new_did
def test_add_node_with_existing_data(looper, txnPoolNodeSet, tdir, tconf, sdk_pool_handle, sdk_wallet_stewards): alias = randomString(5) new_node_name = "Node-" + alias steward_wallet_handle = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_stewards[0], alias="Steward-" + alias, role='STEWARD') # Setting already existing HAs existing_ha = txnPoolNodeSet[0].nodeReg[txnPoolNodeSet[-1].name] existing_cli_ha = txnPoolNodeSet[0].cliNodeReg[txnPoolNodeSet[-1].name + 'C'] # Check for existing alias node_request = create_specific_node_request( looper, steward_wallet_handle, tconf, tdir, txnPoolNodeSet[0].name) request_couple = sdk_sign_and_send_prepared_request(looper, steward_wallet_handle, sdk_pool_handle, node_request) sdk_get_bad_response(looper, [request_couple], RequestRejectedException, "Node's alias must be unique") # Check for existing node HAs node_request = create_specific_node_request( looper, steward_wallet_handle, tconf, tdir, new_node_name, new_node_ip=existing_ha[0], new_node_port=existing_ha[1]) request_couple = sdk_sign_and_send_prepared_request(looper, steward_wallet_handle, sdk_pool_handle, node_request) sdk_get_bad_response(looper, [request_couple], RequestRejectedException, "Node's nodestack addresses must be unique") # Check for existing client HAs node_request = create_specific_node_request( looper, steward_wallet_handle, tconf, tdir, new_node_name, new_client_ip=existing_cli_ha[0], new_client_port=existing_cli_ha[1]) request_couple = sdk_sign_and_send_prepared_request(looper, steward_wallet_handle, sdk_pool_handle, node_request) sdk_get_bad_response(looper, [request_couple], RequestRejectedException, "Node's clientstack addresses must be unique")
def sdk_get_validator_info(looper, steward_wallet, sdk_pool_handle, seed=None): # filling validator_info request and getting steward did seed = seed or randomString(32) validator_info_request, did = looper.loop.run_until_complete( prepare_validator_info_request(steward_wallet, seed)) # sending request using 'sdk_' functions request_couple = sdk_sign_and_send_prepared_request(looper, steward_wallet, sdk_pool_handle, validator_info_request) # waiting for replies return sdk_get_and_check_multiply_replies(looper, request_couple)
def testSendNymSucceedsForStewardRole(looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): halfKeyIdentifier, abbrevVerkey = createHalfKeyIdentifierAndAbbrevVerkey() parameters = { 'dest': halfKeyIdentifier, 'verkey': abbrevVerkey, 'role': STEWARD } 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 testSendNymFailsIfIdentifierContainsNonBase58Characters( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): uuidIdentifier = createUuidIdentifier() parameters = { 'dest': uuidIdentifier[:5] + '/' + uuidIdentifier[6:], '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 testSendNymFailsIfAbbrevVerkeySizeIs17Bytes(looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): parameters = { 'dest': rawToFriendly(randombytes(16)), 'verkey': '~' + rawToFriendly(randombytes(17)), '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 sdk_node_theta_added(looper, txnPoolNodeSet, tdir, tconf, sdk_pool_handle, sdk_wallet_trustee, allPluginsPath, node_config_helper_class, testNodeClass, name=None): new_steward_name = "testClientSteward" + randomString(3) new_node_name = name or "Theta" new_steward_wallet = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee, alias=new_steward_name, role=STEWARD_STRING) sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort = \ prepare_new_node_data(tconf, tdir, new_node_name, configClass=node_config_helper_class) # filling node request _, steward_did = new_steward_wallet node_request = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name=new_node_name, clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, bls_key=bls_key, sigseed=sigseed, services=[VALIDATOR])) # sending request using 'sdk_' functions request_couple = sdk_sign_and_send_prepared_request(looper, new_steward_wallet, sdk_pool_handle, node_request) # waitng for replies sdk_get_and_check_replies(looper, [request_couple]) new_node = create_and_start_new_node(looper, new_node_name, tdir, sigseed, (nodeIp, nodePort), (clientIp, clientPort), tconf, True, allPluginsPath, testNodeClass, configClass=node_config_helper_class) txnPoolNodeSet.append(new_node) looper.run(checkNodesConnected(txnPoolNodeSet)) sdk_pool_refresh(looper, sdk_pool_handle) return new_steward_wallet, new_node
def testSendNymHasInvalidSyntaxForUuidIdentifierAndEmptyVerkey( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): parameters = { 'dest': createUuidIdentifier(), 'verkey': '', '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_bad_response(looper, [request_couple], RequestNackedException, 'Neither a full verkey nor an abbreviated one')
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 testSendNymHasInvalidSyntaxIfIdentifierIsEmpty( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): _, fullVerkey = createUuidIdentifierAndFullVerkey() parameters = { 'dest': '', 'verkey': fullVerkey, '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 testSendNymFailsForCryptonymIdentifierAndFullVerkey( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): cryptonym = createCryptonym() _, fullVerkey = createUuidIdentifierAndFullVerkey() parameters = {'dest': cryptonym, 'verkey': fullVerkey, '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 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 test_create_did_without_endorser_fails(looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle): wh, alias, sender_did, sender_verkey = nym_txn_data nym_request = looper.loop.run_until_complete( build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE)) request_couple = sdk_sign_and_send_prepared_request( looper, (wh, sender_did), sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException, match='is not found in the Ledger'): sdk_get_and_check_replies(looper, [request_couple])
def testSendNymFailsIfFullVerkeyContainsTilde( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): uuidIdentifier, fullVerkey = createUuidIdentifierAndFullVerkey() parameters = { 'dest': uuidIdentifier, 'verkey': '~' + fullVerkey, '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 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 testSendNodeSuccessIfDataContainsUnknownField(looper, sdk_pool_handle, nodeSet, sdk_node_theta_added, node_request): node_request['operation']['data'][SERVICES] = [] node_request['operation']['data']['extra'] = 42 steward_wallet, node = sdk_node_theta_added request_couple = sdk_sign_and_send_prepared_request( looper, steward_wallet, sdk_pool_handle, json.dumps(node_request)) sdk_get_bad_response(looper, [request_couple], RequestRejectedException, 'not found in authorized map') ensurePoolIsOperable(looper, sdk_pool_handle, steward_wallet)
def add_ne_node(looper, sdk_pool_handle, steward_wallet_handle): new_node_name = randomString(7) nodeSigner = SimpleSigner() dest = nodeSigner.identifier (nodeIp, nodePort), (clientIp, clientPort) = genHa(2) _, steward_did = steward_wallet_handle node_request = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name=new_node_name, destination=dest, clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, services=[VALIDATOR])) request_couple = sdk_sign_and_send_prepared_request(looper, steward_wallet_handle, sdk_pool_handle, node_request) sdk_get_and_check_replies(looper, [request_couple]) return dest, new_node_name
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 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_demote_nonexisted(looper, txnPoolNodeSet, sdk_pool_handle, tdir, tconf, sdk_wallet_new_steward): dst, name = add_ne_node(looper, sdk_pool_handle, sdk_wallet_new_steward) assert dst sdk_pool_refresh(looper, sdk_pool_handle) assert len(txnPoolNodeSet[0].nodeReg) == len(txnPoolNodeSet) + 1 _, st_did = sdk_wallet_new_steward node_request = looper.loop.run_until_complete( prepare_node_request(st_did, destination=dst, new_node_name=name, services=[])) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_new_steward, sdk_pool_handle, node_request) sdk_get_and_check_replies(looper, [request_couple])
def testSendNodeFailsIfNodeIpContainsTrailingSpace(looper, sdk_pool_handle, nodeSet, sdk_node_theta_added, node_request): node_request['operation']['data'][NODE_IP] = '122.62.52.13 ' steward_wallet, node = sdk_node_theta_added request_couple = sdk_sign_and_send_prepared_request( looper, steward_wallet, sdk_pool_handle, json.dumps(node_request)) sdk_get_bad_response(looper, [request_couple], RequestNackedException, 'invalid network ip address') ensurePoolIsOperable(looper, sdk_pool_handle, steward_wallet)
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_create_did_without_endorser_need_to_be(looper, txnPoolNodeSet, nym_txn_data, sdk_pool_handle, sdk_wallet_trustee): change_auth_rule(looper, sdk_pool_handle, sdk_wallet_trustee, constraint=AuthConstraint(role='*', sig_count=1, off_ledger_signature=False)) wh, alias, sender_did, sender_verkey = nym_txn_data nym_request = looper.loop.run_until_complete( build_nym_request(sender_did, sender_did, sender_verkey, alias, NEW_ROLE)) request_couple = sdk_sign_and_send_prepared_request(looper, (wh, sender_did), sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException, match='is not found in the Ledger'): sdk_get_and_check_replies(looper, [request_couple])
def testSendNymFailsIfFullVerkeyIsHexEncoded(looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): uuidIdentifier, fullVerkey = createUuidIdentifierAndFullVerkey() parameters = { 'dest': uuidIdentifier, 'verkey': friendlyToHexStr(fullVerkey), '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 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 test_client_get_request_not_discard_in_view_change_integration( txnPoolNodeSet, looper, sdk_pool_handle, sdk_wallet_client): ''' Check that client requests sent in view change will discard. ''' for node in txnPoolNodeSet: node.master_replica._consensus_data.waiting_for_new_view = True _, steward_did = sdk_wallet_client request = sdk_build_get_txn_request(looper, steward_did, 1) sdk_request = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, request) sdk_get_and_check_replies(looper, [sdk_request])
def testSendNymFailsForCryptonymIdentifierAndMatchedAbbrevVerkey( looper, sdk_pool_handle, txnPoolNodeSet, nym_request, sdk_wallet_trustee): cryptonym = createCryptonym() hexCryptonym = friendlyToHex(cryptonym) abbrevVerkey = '~' + hexToFriendly(hexCryptonym[16:]) parameters = {'dest': cryptonym, 'verkey': abbrevVerkey, '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_bad_response(looper, [request_couple], RequestNackedException, 'Neither a full verkey nor an abbreviated one')
def test_send_different_txn_author_agreement_with_same_version_fails( looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_trustee): # Send original txn req = looper.loop.run_until_complete( prepare_txn_author_agreement(sdk_wallet_trustee[1])) req = json.loads(req) old_version = req[OPERATION][TXN_AUTHOR_AGREEMENT_VERSION] rep = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, json.dumps(req)) sdk_get_and_check_replies(looper, [rep]) # Send new txn with old version req = looper.loop.run_until_complete( prepare_txn_author_agreement(sdk_wallet_trustee[1])) req = json.loads(req) req[OPERATION][TXN_AUTHOR_AGREEMENT_VERSION] = old_version rep = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, json.dumps(req)) with pytest.raises(RequestRejectedException): sdk_get_and_check_replies(looper, [rep])
def sdk_add_attribute_and_check(looper, sdk_pool_handle, sdk_wallet_handle, attrib, dest=None): _, s_did = sdk_wallet_handle t_did = dest or s_did attrib_req = looper.loop.run_until_complete( build_attrib_request(s_did, t_did, None, attrib, None)) request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_handle, sdk_pool_handle, attrib_req) sdk_get_and_check_replies(looper, [request_couple]) return request_couple
def testStewardCannotAddNodeWithInvalidHa(looper, tdir, tconf, txnPoolNodeSet, sdk_wallet_new_steward, sdk_pool_handle): """ The case: Steward accidentally sends the NODE txn with an invalid HA. The expected result: Steward gets NAck response from the pool. """ new_node_name = "Epsilon" sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort = \ prepare_new_node_data(tconf, tdir, new_node_name) _, steward_did = sdk_wallet_new_steward node_request = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name=new_node_name, clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, bls_key=bls_key, sigseed=sigseed)) # a sequence of the test cases for each field tests = itertools.chain( itertools.product( (NODE_IP, CLIENT_IP), ('127.0.0.1 ', '256.0.0.1', '0.0.0.0') ), itertools.product( (NODE_PORT, CLIENT_PORT), ('foo', '9700', 0, 65535 + 1, 4351683546843518184) ), ) for field, value in tests: # create a transform function for each test request_json = json.loads(node_request) request_json['operation'][DATA][field] = value node_request1 = json.dumps(request_json) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_new_steward, sdk_pool_handle, node_request1) # wait NAcks with exact message. it does not works for just 'is invalid' # because the 'is invalid' will check only first few cases with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'invalid network ip address' in e._excinfo[1].args[0] or \ 'expected types' in e._excinfo[1].args[0] or \ 'network port out of the range' in e._excinfo[1].args[0]
def test_forced_upgrade_no_consensus_on_single_node( validUpgradeExpForceTrue, looper, nodeSet, sdk_pool_handle, sdk_wallet_trustee): nup = validUpgradeExpForceTrue.copy() nup.update({VERSION: bumpVersion(validUpgradeExpForceTrue[VERSION])}) for node in nodeSet: if node.name != "Alpha": node.cleanupOnStopping = False looper.removeProdable(node) node.stop() else: node.upgrader.scheduledUpgrade = None _, did = sdk_wallet_trustee req = get_req_from_update(looper, did, nup) sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, req) def testsched(): for node in nodeSet: if node.name == "Alpha": assert node.upgrader.scheduledAction assert node.upgrader.scheduledAction[0] == nup[VERSION] looper.run(eventually(testsched, retryWait=1, timeout=waits.expectedUpgradeScheduled()))
def test_taa_acceptance_writes_module_static(looper, taa_aml_request, sdk_pool_handle, sdk_wallet_trustee): taa_aml_request = json.loads(taa_aml_request) taa_aml_request['operation'][AML] = {} taa_aml_request = json.dumps(taa_aml_request) req = sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, taa_aml_request) with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [req]) assert e.match( 'TXN_AUTHOR_AGREEMENT_AML request must contain at least one acceptance mechanism' )
def test_get_txn_for_invalid_seq_no(looper, txnPoolNodeSet, sdk_wallet_steward, sdk_pool_handle): _, steward_did = sdk_wallet_steward # setting incorrect data request = sdk_build_get_txn_request(looper, steward_did, INVALID_SEQ_NO) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'cannot be smaller' in e._excinfo[1].args[0]
def test_get_txn_for_invalid_ledger_id(looper, txnPoolNodeSet, sdk_wallet_steward, sdk_pool_handle): _, steward_did = sdk_wallet_steward request = sdk_build_get_txn_request(looper, steward_did, 1) # setting incorrect Ledger_ID request_json = json.loads(request) request_json['operation']['ledgerId'] = INVALID_LEDGER_ID request = json.dumps(request_json) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) with pytest.raises(RequestNackedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'expected one of' in e._excinfo[1].args[0]
def test_get_txn_for_non_existing_seq_no(looper, txnPoolNodeSet, sdk_wallet_steward, sdk_pool_handle): _, steward_did = sdk_wallet_steward # setting incorrect data def generate_non_existing_seq_no(): return randint(500, 1000) request = sdk_build_get_txn_request(looper, steward_did, generate_non_existing_seq_no()) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) reply = sdk_get_and_check_replies(looper, [request_couple])[0][1] assert reply['result'][DATA] is None
def testOnlyAStewardCanAddAnotherSteward(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, sdk_wallet_client): sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, alias='testSteward' + randomString(3), role=STEWARD_STRING) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, steward_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, 'testSteward2', 'STEWARD')) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, nym_request) total_timeout = sdk_eval_timeout(1, len(txnPoolNodeSet)) request_couple = sdk_get_replies(looper, [request_couple], total_timeout)[0] with pytest.raises(RequestRejectedException) as e: sdk_check_reply(request_couple) assert 'Only Steward is allowed to do these transactions' in e._excinfo[1].args[0]
def get_nym(looper, sdk_pool_handle, sdk_wallet_steward, t_did): _, s_did = sdk_wallet_steward get_nym_req = looper.loop.run_until_complete(build_get_nym_request(s_did, t_did)) req = sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, get_nym_req) return sdk_get_and_check_replies(looper, [req])
def test_commit_signature_validation_integration(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, sdk_wallet_client, tconf, tdir): ''' All nodes receive PrePrepare1(txn1 for pool_ledger) Nodes 1, 2 ordered txn1 and nodes 3, 4 did not. All nodes receive PrePrepare2(txn2 for domain_ledger) Nodes 3, 4 receive commits from nodes 1, 2 Nodes 3, 4 ordered txn1 Check that all nodes ordered txn2 ''' fast_nodes = txnPoolNodeSet[:2] slow_nodes = txnPoolNodeSet[2:] sdk_send_random_and_check(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, 1) # create new steward new_steward_wallet_handle = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, alias="testClientSteward945", role=STEWARD_STRING) sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof = \ prepare_new_node_data(tconf, tdir, "new_node") # create node request to add new demote node _, steward_did = new_steward_wallet_handle node_request = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name="new_node", clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, bls_key=bls_key, sigseed=sigseed, services=[], key_proof=key_proof)) first_ordered = txnPoolNodeSet[0].master_last_ordered_3PC with ord_delay(slow_nodes): request1 = sdk_sign_and_send_prepared_request(looper, new_steward_wallet_handle, sdk_pool_handle, node_request) key1 = get_key_from_req(request1[0]) def check_nodes_receive_pp(view_no, seq_no): for node in txnPoolNodeSet: assert node.master_replica.getPrePrepare(view_no, seq_no) looper.run(eventually(check_nodes_receive_pp, first_ordered[0], first_ordered[1] + 1)) def check_fast_nodes_ordered_request(): for n in fast_nodes: assert key1 not in n.requests or n.requests[key1].executed for n in slow_nodes: assert not n.requests[key1].executed looper.run(eventually(check_fast_nodes_ordered_request)) request2 = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client) looper.run(eventually(check_nodes_receive_pp, first_ordered[0], first_ordered[1] + 2)) def check_nodes_receive_commits(view_no, seq_no): for node in txnPoolNodeSet: assert len(node.master_replica.commits[view_no, seq_no].voters) >= node.f + 1 looper.run(eventually(check_nodes_receive_commits, first_ordered[0], first_ordered[1] + 2)) sdk_get_and_check_replies(looper, [request1]) sdk_get_and_check_replies(looper, [request2])
def sdk_send_upgrade(looper, sdk_pool_handle, sdk_wallet_trustee, upgrade_data): _, did = sdk_wallet_trustee req = get_req_from_update(looper, did, upgrade_data) return sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, req)
def testLoggingTxnStateWhenCommitFails( looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, logsearch): logsPropagate, _ = logsearch(files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsOrdered, _ = logsearch(files=['replica.py'], funcs=['order_3pc_key'], msgs=['ordered batch request']) logsCommitFail, _ = logsearch(files=['node.py'], funcs=['executeBatch'], msgs=['commit failed for batch request']) seed = randomString(32) wh, _ = sdk_wallet_steward nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, "name", None)) sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, nym_request) class SomeError(Exception): pass def commitPatched(node, commitOrig, *args, **kwargs): req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = commitOrig raise SomeError(ERORR_MSG) excCounter = 0 def executeBatchPatched(node, executeBatchOrig, *args, **kwargs): nonlocal excCounter try: executeBatchOrig(*args, **kwargs) except SomeError: excCounter += 1 node.executeBatch = executeBatchOrig pass def checkSufficientExceptionsHappend(): assert excCounter == len(txnPoolNodeSet) return for node in txnPoolNodeSet: req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = functools.partial( commitPatched, node, req_handler.commit ) node.executeBatch = functools.partial( executeBatchPatched, node, node.executeBatch ) timeout = waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)) looper.run( eventually(checkSufficientExceptionsHappend, retryWait=1, timeout=timeout)) request = json.loads(nym_request) digest = get_key_from_req(request) assert any(digest in record.getMessage() for record in logsPropagate) assert any(digest in record.getMessage() for record in logsOrdered) assert any(digest in record.getMessage() for record in logsCommitFail) assert any(ERORR_MSG in record.getMessage() for record in logsCommitFail)
def test_different_ledger_request_interleave(tconf, looper, txnPoolNodeSet, sdk_one_node_added, tdir, tdirWithPoolTxns, allPluginsPath, sdk_pool_handle, sdk_wallet_client, sdk_wallet_steward): """ Send pool and domain ledger requests such that they interleave, and do view change in between and verify the pool is functional """ new_node = sdk_one_node_added sdk_send_random_and_check(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, 2) ensure_all_nodes_have_same_data(looper, txnPoolNodeSet) # Send domain ledger requests but don't wait for replies requests = sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 2) # Add another node by sending pool ledger request _, new_theta = sdk_node_theta_added(looper, txnPoolNodeSet, tdir, tconf, sdk_pool_handle, sdk_wallet_steward, allPluginsPath, name='new_theta') # Send more domain ledger requests but don't wait for replies requests.extend(sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 3)) # Do view change without waiting for replies ensure_view_change(looper, nodes=txnPoolNodeSet) checkProtocolInstanceSetup(looper, txnPoolNodeSet, retryWait=1) # Make sure all requests are completed total_timeout = sdk_eval_timeout(len(requests), len(txnPoolNodeSet)) sdk_get_and_check_replies(looper, requests, timeout=total_timeout) sdk_ensure_pool_functional(looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle) new_steward_wallet, steward_did = sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, 'another_ste', role='STEWARD') # Send another pool ledger request (NODE) but don't wait for completion of # request next_node_name = 'next_node' sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof = \ prepare_new_node_data(tconf, tdir, next_node_name) node_req = looper.loop.run_until_complete( prepare_node_request(steward_did, new_node_name=next_node_name, clientIp=clientIp, clientPort=clientPort, nodeIp=nodeIp, nodePort=nodePort, bls_key=bls_key, sigseed=sigseed, key_proof=key_proof)) sdk_wallet = (new_steward_wallet, steward_did) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet, sdk_pool_handle, node_req) # Send more domain ledger requests but don't wait for replies request_couples = [request_couple, * sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 5)] # Make sure all requests are completed total_timeout = sdk_eval_timeout(len(request_couples), len(txnPoolNodeSet)) sdk_get_and_check_replies(looper, request_couples, timeout=total_timeout) # Make sure pool is functional sdk_ensure_pool_functional(looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle)