Beispiel #1
0
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
Beispiel #2
0
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
Beispiel #3
0
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 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']
Beispiel #5
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['reqSignature'] == result2['data']['reqSignature']
    assert result1['txn'] == result2['data']['txn']
    assert result1['txnMetadata'] == result2['data']['txnMetadata']
    assert result1['rootHash'] == result2['data']['rootHash']
    assert result1['ver'] == result2['data']['ver']
    assert result1['auditPath'] == result2['data']['auditPath']
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 read_wrapped():
        _, steward_did = sdk_wallet_steward
        request = sdk_build_get_txn_request(looper, steward_did, 1)
        sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward,
                                           sdk_pool_handle, request)

        looper.runFor(patched_dump_info_period)
        return load_info(info_path)
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])
Beispiel #9
0
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)
Beispiel #10
0
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_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_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)
Beispiel #13
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
Beispiel #14
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_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
Beispiel #17
0
def check_get_auction_txn(expected_result,
                          looper,
                          sdk_wallet_steward,
                          sdk_pool_handle):
    seqNo = get_seq_no(expected_result)

    _, steward_did = sdk_wallet_steward
    request = sdk_build_get_txn_request(looper, steward_did, seqNo, ledger_type=str(AUCTION_LEDGER_ID))

    request_couple = \
        sdk_sign_and_send_prepared_request(looper,
                                           sdk_wallet_steward,
                                           sdk_pool_handle,
                                           request)
    result = sdk_get_and_check_replies(looper,
                                       [request_couple])[0][1]['result']

    assert expected_result['reqSignature'] == result['data']['reqSignature']
    assert expected_result['txn'] == result['data']['txn']
    assert expected_result['txnMetadata'] == result['data']['txnMetadata']
    assert expected_result['rootHash'] == result['data']['rootHash']
    assert expected_result['ver'] == result['data']['ver']
    assert expected_result['auditPath'] == result['data']['auditPath']