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 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 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)
