def test_pool_restarts_one_by_one_with_restart_now(sdk_pool_handle,
sdk_wallet_trustee, looper,
tconf, txnPoolNodeSet):
server, indicator = looper.loop.run_until_complete(
_createServer(host=tconf.controlServiceHost,
port=tconf.controlServicePort))
unow = datetime.utcnow().replace(tzinfo=dateutil.tz.tzutc())
first_start = str(datetime.isoformat(unow + timedelta(seconds=1000)))
op = {TXN_TYPE: POOL_RESTART, ACTION: START, DATETIME: first_start}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
sdk_get_reply(looper, req, 100)
op[DATETIME] = "0"
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
sdk_get_reply(looper, req, 100)
restart_log = []
for a in txnPoolNodeSet[0].restarter._actionLog:
restart_log.append(a)
restart_log.reverse()
_check_restart_log(restart_log[1], RestartLog.SCHEDULED, first_start)
_check_restart_log(restart_log[0], RestartLog.CANCELLED)
_stopServer(server)
def test_revert_works_for_fees_before_catch_up_on_all_nodes(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
sdk_wallet_trustee, fees_set, address_main, mint_tokens):
node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin]
with delay_rules(node_set, cDelay()):
request = helpers.request.nym()
request = add_fees_request_with_address(helpers, fees_set, request,
address_main)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, True, retryWait=0.2, timeout=15))
sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet, request)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, False, retryWait=0.2, timeout=15))
for n in nodeSetWithIntegratedTokenPlugin:
n.start_catchup()
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(lambda: assertExp(n.mode == Mode.participating)))
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_state, n, True, retryWait=0.2, timeout=15))
ensure_all_nodes_have_same_data(looper, nodeSetWithIntegratedTokenPlugin)
def test_pool_restart_cancel(sdk_pool_handle, sdk_wallet_trustee, looper,
tconf, txnPoolNodeSet):
loop = asyncio.get_event_loop()
server, indicator = loop.run_until_complete(
_createServer(host=tconf.controlServiceHost,
port=tconf.controlServicePort))
unow = datetime.utcnow().replace(tzinfo=dateutil.tz.tzutc())
start_at = unow + timedelta(seconds=100)
op = {TXN_TYPE: POOL_RESTART, ACTION: START, DATETIME: str(start_at)}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
for node in txnPoolNodeSet:
assert node.restarter.lastActionEventInfo[0] == RestartLog.SCHEDULED
op = {
TXN_TYPE: POOL_RESTART,
ACTION: CANCEL,
DATETIME: str(datetime.isoformat(start_at))
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
req_json, resp = sdk_get_reply(looper, req, 100)
for node in txnPoolNodeSet:
assert node.restarter.lastActionEventInfo[0] == RestartLog.CANCELLED
_stopServer(server)
_comparison_reply(resp, req_obj)
assert resp[f.RESULT.nm][DATETIME] == str(datetime.isoformat(start_at))
def test_revert_works_for_fees_before_catch_up_on_one_node(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle,
fees_set, address_main, mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
reverted_node = node_set[-1]
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request_1, request_2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
c_ledger_root_before = get_committed_txn_root_for_pool([reverted_node], TOKEN_LEDGER_ID)
with delay_rules(reverted_node.nodeIbStasher, cDelay()):
"""
Send NYM with FEES and wait for reply. All of nodes, except reverted_node will order them
"""
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, helpers.request._steward_wallet, request_1)
sdk_get_and_check_replies(looper, [r])
check_state(reverted_node, is_equal=False)
c_ledger_root_for_other = get_committed_txn_root_for_pool(node_set[:-1], TOKEN_LEDGER_ID)
"""
Start catchup. Uncommitted batch for reverted_node should be rejected and it will get
NYM with FEES during catchup procedure.
"""
reverted_node.start_catchup()
looper.run(eventually(lambda: assertExp(reverted_node.mode == Mode.participating)))
check_state(reverted_node, is_equal=True)
"""
Check, that committed txn root was changed and it's the same as for others
"""
c_ledger_root_after = get_committed_txn_root_for_pool([reverted_node], TOKEN_LEDGER_ID)
assert c_ledger_root_after != c_ledger_root_before
assert c_ledger_root_after == c_ledger_root_for_other
ensure_all_nodes_have_same_data(looper, node_set)
c_ledger_root_before = get_committed_txn_root_for_pool(node_set, TOKEN_LEDGER_ID)
"""
Send another NYM with FEES and check, that committed ledger's root was changed
"""
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, helpers.request._steward_wallet, request_2)
sdk_get_and_check_replies(looper, [r])
c_ledger_root_after = get_committed_txn_root_for_pool(node_set, TOKEN_LEDGER_ID)
assert c_ledger_root_after != c_ledger_root_before
ensure_all_nodes_have_same_data(looper, node_set)
for n in node_set:
check_state(n, is_equal=True)
def test_catchup_several_batches(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
current_amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
node_set = nodeSetWithIntegratedTokenPlugin
"""
Prepare NUM_BATCHES * TXN_IN_BATCH requests and 1 for checking pool functional
"""
all_reqs = nyms_with_fees(NUM_BATCHES * TXN_IN_BATCH + 1,
helpers,
fees_set,
address_main,
current_amount,
init_seq_no=init_seq_no)
reqs_to_catchup = all_reqs[:-1]
req_for_check = all_reqs[-1]
reverted_node = node_set[-1]
with delay_rules(reverted_node.nodeIbStasher, cDelay()):
len_batches_before = len(
reverted_node.master_replica._ordering_service.batches)
sdk_requests = []
for req in reqs_to_catchup:
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
req)
sdk_requests.append(r)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
len_batches_after = len(
reverted_node.master_replica._ordering_service.batches)
"""
Checks, that we have a 2 new batches
"""
assert len_batches_after - len_batches_before == NUM_BATCHES
sdk_get_and_check_replies(looper, sdk_requests)
reverted_node.start_catchup()
looper.run(
eventually(
lambda: assertExp(reverted_node.mode == Mode.participating)))
ensure_all_nodes_have_same_data(looper, node_set)
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
req_for_check)
sdk_get_and_check_replies(looper, [r])
ensure_all_nodes_have_same_data(looper, node_set)
def sdk_ensure_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee, pool_config_data):
_, did = sdk_wallet_trustee
pool_cfg = WPoolConfig(trustee=did, **pool_config_data)
req = pool_cfg.ledgerRequest()
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, sdk_wallet_trustee, req)
sdk_get_and_check_replies(looper, [req])
return pool_cfg
def test_apply_several_batches_with_several_txns(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
fees_set, address_main, mint_tokens):
current_amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
node_set = nodeSetWithIntegratedTokenPlugin
all_reqs = nyms_with_fees(NUM_BATCHES * TXN_IN_BATCH,
helpers,
fees_set,
address_main,
current_amount,
init_seq_no=init_seq_no)
domain_txns_before = get_committed_txns_count_for_pool(
node_set, DOMAIN_LEDGER_ID)
token_txns_before = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
sdk_requests = []
for req in all_reqs:
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet, req)
sdk_requests.append(r)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
sdk_get_and_check_replies(looper, sdk_requests)
domain_txns_after = get_committed_txns_count_for_pool(
node_set, DOMAIN_LEDGER_ID)
token_txns_after = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
assert domain_txns_after - domain_txns_before == NUM_BATCHES * TXN_IN_BATCH
assert token_txns_after - token_txns_before == NUM_BATCHES * TXN_IN_BATCH
def test_auth_rule_after_get_auth_rule_as_is(
looper, sdk_pool_handle, sdk_wallet_trustee
):
# get all auth rules
auth_rules_resp = sdk_send_and_check_get_auth_rule_request(
looper, sdk_pool_handle, sdk_wallet_trustee
)
auth_rules = auth_rules_resp[0][1][RESULT][DATA]
for rule in auth_rules:
# prepare action key
dict_key = dict(rule)
dict_key.pop(CONSTRAINT)
# prepare "operation" to send AUTH_RULE txn
op = dict(rule)
op[TXN_TYPE] = AUTH_RULE
# send AUTH_RULE txn
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
sdk_get_and_check_replies(looper, [req])
# send GET_AUTH_RULE
get_response = sdk_send_and_check_get_auth_rule_request(
looper, sdk_pool_handle, sdk_wallet_trustee, **dict_key)
# check response
result = get_response[0][1]["result"][DATA]
assert len(result) == 1
_check_key(dict_key, result[0])
assert rule[CONSTRAINT] == result[0][CONSTRAINT]
assert get_response[0][1]["result"][STATE_PROOF]
def test_malicious_primary_sent_pp(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
def raise_invalid_ex():
raise InvalidClientMessageException(1, 2, 3)
nodes = nodeSetWithIntegratedTokenPlugin
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request1, request2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
malicious_primary = getPrimaryReplica(nodes).node
not_malicious_nodes = set(nodes) - {malicious_primary}
for n in not_malicious_nodes:
n.doDynamicValidation = lambda *args, **kwargs: raise_invalid_ex()
r1 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet, request1)
with pytest.raises(RequestRejectedException,
match="client request invalid"):
sdk_get_and_check_replies(looper, [r1])
def sdk_send_alternating_ledgers_requests(looper, pool_h, sdk_wallet_trustee,
sdk_wallet_new_steward, count: int):
node_alias = random_string(7)
node_did = SimpleSigner(seed=random_string(32).encode()).identifier
ReqFactory = namedtuple('ReqFactory', 'wallet create')
req_factories = [
ReqFactory(wallet=sdk_wallet_new_steward,
create=lambda: sdk_gen_pool_request(
looper, sdk_wallet_new_steward, node_alias, node_did)),
ReqFactory(
wallet=sdk_wallet_trustee,
create=lambda: sdk_gen_domain_request(looper, sdk_wallet_trustee)),
ReqFactory(
wallet=sdk_wallet_trustee,
create=lambda: sdk_gen_config_request(looper, sdk_wallet_trustee))
]
res = []
for i in range(count):
factory = req_factories[i % len(req_factories)]
req = factory.create()
res.append(
sdk_sign_and_submit_req_obj(looper, pool_h, factory.wallet, req))
looper.runFor(
0.1
) # Give nodes some time to start ordering, so that requests are really alternating
return res
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
sdk_wallet_steward, sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {TXN_TYPE: GET_BAL, DATA: {'id': '123'}}
# Valid field value results in successful processing
req_obj = sdk_gen_request(
op,
identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
_, did = sdk_wallet_steward
req = sdk_gen_request(op,
identifier=did,
fix_length_dummy=randomString(dummy_field_length +
1))
reqs = sdk_sign_request_objects(looper, sdk_wallet_steward, [req])
reqs = sdk_send_signed_requests(sdk_pool_handle, reqs)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, reqs)
assert 'should have length' in e._excinfo[1].args[0]
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
stewardWallet, steward1, sdk_wallet_steward,
sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {TXN_TYPE: GET_BAL, DATA: {'id': '123'}}
# Valid field value results in successful processing
req_obj = sdk_gen_request(
op,
identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
req = Request(operation=op,
reqId=Request.gen_req_id(),
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=stewardWallet.defaultId,
fix_length_dummy=randomString(dummy_field_length + 1))
steward1.submitReqs(req)
for node in txn_pool_node_set_post_creation:
looper.run(
eventually(checkReqNackWithReason,
steward1,
'should have length',
node.clientstack.name,
retryWait=1))
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
sdk_wallet_steward, sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {
TXN_TYPE: GET_BAL,
DATA: {'id': '123'}
}
# Valid field value results in successful processing
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, sdk_wallet_steward,
req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
_, did = sdk_wallet_steward
req = sdk_gen_request(op, identifier=did, fix_length_dummy=randomString(dummy_field_length + 1))
reqs = sdk_sign_request_objects(looper, sdk_wallet_steward, [req])
reqs = sdk_send_signed_requests(sdk_pool_handle, reqs)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, reqs)
assert 'should have length' in e._excinfo[1].args[0]
def sdk_get_frozen_ledgers(looper, sdk_pool_handle, sdk_wallet):
req = looper.loop.run_until_complete(
build_get_frozen_ledgers_request(sdk_wallet[1]))
rep = sdk_sign_and_submit_req_obj(
looper, sdk_pool_handle, sdk_wallet,
sdk_json_to_request_object(json.loads(req)))
return sdk_get_and_check_replies(looper, [rep])[0]
def test_pool_restart_now(
sdk_pool_handle, sdk_wallet_trustee, looper, tdir, tconf):
server, indicator = looper.loop.run_until_complete(
_createServer(
host=tconf.controlServiceHost,
port=tconf.controlServicePort
)
)
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
is_reply_received = False
try:
req_json, resp = sdk_get_reply(looper, req, 100)
except Exception as ex:
assert "Timeout" in ex.args
_stopServer(server)
if is_reply_received:
_comparison_reply(resp, req_obj)
def test_last_committed_after_catchup(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle,
fees_set, address_main, mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
reverted_node = node_set[-1]
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request_1, request_2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
reverted_last_committed = get_last_committed_from_tracker(reverted_node)
not_reverted_last_committed = get_last_committed_from_tracker(node_set[-1])
assert reverted_last_committed == not_reverted_last_committed
with delay_rules(reverted_node.nodeIbStasher, cDelay()):
"""
Send NYM with FEES and wait for reply.
"""
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, helpers.request._steward_wallet, request_1)
sdk_get_and_check_replies(looper, [r])
"""
Start catchup. Uncommitted batch for reverted_node should be rejected and it will get
NYM with FEES during catchup procedure.
"""
reverted_node.start_catchup()
looper.run(eventually(lambda: assertExp(reverted_node.mode == Mode.participating)))
assert get_last_committed_from_tracker(reverted_node) ==\
get_last_committed_from_tracker(node_set[0])
def sdk_pool_config_sent(looper, sdk_pool_handle, sdk_wallet_trustee,
pool_config_data):
_, did = sdk_wallet_trustee
pool_cfg = WPoolConfig(trustee=did, **pool_config_data)
req = pool_cfg.ledgerRequest()
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req)
return pool_cfg, req
def sdk_send_update_node(looper, sdk_pool, sdk_wallet_steward, node, node_data):
node_dest = hexToFriendly(node.nodestack.verhex)
op = {
TXN_TYPE: NODE,
TARGET_NYM: node_dest,
DATA: node_data,
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1])
return sdk_sign_and_submit_req_obj(looper, sdk_pool, sdk_wallet_steward, req_obj)
def send_get_utxo(looper, address, sdk_wallet_client, sdk_pool_handle):
_, sender_did = sdk_wallet_client
request = get_utxo_request(address, sender_did)
req_resp_json = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_client, request)
_, reply = sdk_get_and_check_replies(looper, [
req_resp_json,
])[0]
return reply['result']
def test_validator_info_command(
sdk_pool_handle, sdk_wallet_trustee, looper):
op = {
TXN_TYPE: VALIDATOR_INFO
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
def test_fail_pool_restart_with_invalid_datetime(sdk_pool_handle,
sdk_wallet_steward, looper):
invalid_datetime = "12.05.2018 4/40"
op = {TXN_TYPE: POOL_RESTART, ACTION: START, DATETIME: invalid_datetime}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
with pytest.raises(RequestNackedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("datetime " + invalid_datetime + " is not valid")
def test_fail_validator_info_command(sdk_pool_handle, sdk_wallet_client,
looper):
op = {TXN_TYPE: VALIDATOR_INFO}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_client[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_client, req_obj)
with pytest.raises(RequestRejectedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("None role cannot do action with type = " +
VALIDATOR_INFO)
def test_validator_info_command(
sdk_pool_handle, sdk_wallet_trustee, looper):
op = {
TXN_TYPE: VALIDATOR_INFO
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
def test_multiple_batches_for_pool(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
node_stashers = [n.nodeIbStasher for n in node_set]
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request1, request2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
txns_count_before = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
with delay_rules(node_stashers, cDelay()):
r1 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request1)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
r2 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request2)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
for n in node_set:
n.start_catchup()
# clear all request queues to not re-send the same reqs after catch-up
for n in node_set:
n.requests.clear()
for r in n.replicas.values():
for ledger_id, queue in r._ordering_service.requestQueues.items(
):
queue.clear()
for n in node_set:
looper.run(
eventually(lambda: assertExp(n.mode == Mode.participating)))
txns_count_after = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
assert txns_count_after == txns_count_before
ensure_all_nodes_have_same_data(looper, node_set)
def sdk_get_auth_rule_request(looper, sdk_wallet_trustee, sdk_pool_handle, key=None):
op = {TXN_TYPE: GET_AUTH_RULE}
if key:
op.update(key)
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
resp = sdk_get_and_check_replies(looper, [req])
return resp
def test_fail_pool_restart(sdk_pool_handle, sdk_wallet_steward, looper):
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
with pytest.raises(RequestRejectedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("STEWARD cannot do restart")
def test_multiple_batches_for_one_node(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
affected_node = node_set[-1]
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request1, request2, request3 = nyms_with_fees(3,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
expected_txns_length = 2
txns_count_before = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
with delay_rules(affected_node.nodeIbStasher, cDelay()):
r1 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request1)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
r2 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request2)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
affected_node.start_catchup()
looper.run(
eventually(
lambda: assertExp(affected_node.mode == Mode.participating)))
txns_count_after = get_committed_txns_count_for_pool(
node_set, TOKEN_LEDGER_ID)
assert txns_count_after - txns_count_before == expected_txns_length
ensure_all_nodes_have_same_data(looper, node_set)
r3 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet, request3)
sdk_get_and_check_replies(looper, [r3])
ensure_all_nodes_have_same_data(looper, node_set)
def read_wrapped(txn_type):
op = {TXN_TYPE: txn_type, f.LEDGER_ID.nm: DOMAIN_LEDGER_ID, DATA: 1}
req = Request(identifier=did,
operation=op,
reqId=getTimeBasedId(),
protocolVersion=CURRENT_PROTOCOL_VERSION)
sdk_get_and_check_replies(looper, [
sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_client, req)
])
return node._info_tool.info
def read_wrapped(txn_type):
op = {
TXN_TYPE: txn_type,
f.LEDGER_ID.nm: DOMAIN_LEDGER_ID,
DATA: 1
}
req = Request(identifier=did,
operation=op, reqId=getTimeBasedId(),
protocolVersion=CURRENT_PROTOCOL_VERSION)
sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req_obj(
looper, sdk_pool_handle, sdk_wallet_client, req)])
return node._info_tool.info
def test_fail_validator_info_command(
sdk_pool_handle, sdk_wallet_client, looper):
op = {
TXN_TYPE: VALIDATOR_INFO
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_client[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_client,
req_obj)
with pytest.raises(RequestRejectedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("None role cannot do action with type = " +
VALIDATOR_INFO)
def test_apply_several_batches(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle, fees_set, address_main,
mint_tokens):
node_set = [n.nodeIbStasher for n in nodeSetWithIntegratedTokenPlugin]
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
request1, request2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
expected_txns_length = 2
txns_count_before = get_committed_txns_count_for_pool(
nodeSetWithIntegratedTokenPlugin, TOKEN_LEDGER_ID)
with delay_rules(node_set, cDelay()):
r1 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request1)
r2 = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request2)
for n in nodeSetWithIntegratedTokenPlugin:
looper.run(
eventually(check_uncommitted_txn,
n,
expected_txns_length,
TOKEN_LEDGER_ID,
retryWait=0.2,
timeout=15))
sdk_get_and_check_replies(looper, [r1])
sdk_get_and_check_replies(looper, [r2])
txns_count_after = get_committed_txns_count_for_pool(
nodeSetWithIntegratedTokenPlugin, TOKEN_LEDGER_ID)
assert txns_count_after - txns_count_before == expected_txns_length
def test_revert_batches_with_fees_unset_fees_without_fee(
looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle,
sdk_wallet_trustee, sdk_wallet_steward, fees_set, address_main,
mint_tokens):
node_set = nodeSetWithIntegratedTokenPlugin
reverted_node = node_set[-1]
head_hash_before = get_head_hash_for_pool([reverted_node], TOKEN_LEDGER_ID)
uncommitted_size_before = get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID)
with delay_rules(reverted_node.nodeIbStasher, cDelay()):
request_check_health = helpers.request.nym()
request_check_health = add_fees_request_with_address(
helpers, fees_set, request_check_health, address_main)
r = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
helpers.request._steward_wallet,
request_check_health)
looper.runFor(waits.expectedPrePrepareTime(len(node_set)))
"""
We send only 1 txn with fees, and expects,
that we have only 1 uncommitted txn for token_ledger
"""
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
sdk_get_and_check_replies(looper, [r])
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
"""
Unset fees, for sending txn without fees
"""
helpers.node.reset_fees()
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward)
"""
We sent a NYM txn without fees and expects,
that count of uncommitted txns wasn`t changed
"""
assert get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID) - uncommitted_size_before == 1
"""
Initiate reverting procedure by calling start_catchup
"""
reverted_node.master_replica.revert_unordered_batches()
head_hash_after = get_head_hash_for_pool([reverted_node],
TOKEN_LEDGER_ID)
uncommitted_size_after = get_uncommitted_txns_count_for_pool(
[reverted_node], TOKEN_LEDGER_ID)
assert head_hash_before == head_hash_after
assert uncommitted_size_before == uncommitted_size_after
def test_fail_pool_restart_with_steward_role(
sdk_pool_handle, sdk_wallet_steward, looper):
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_steward,
req_obj)
with pytest.raises(RequestRejectedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("STEWARD cannot do action with type = " +
POOL_RESTART)
def test_reqnack_auth_rule_edit_transaction_with_wrong_format(
looper, sdk_wallet_trustee, sdk_pool_handle):
op = generate_auth_rule_operation(auth_action=EDIT_PREFIX)
op.pop(OLD_VALUE)
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, [req])
e.match("InvalidClientRequest")
e.match("Transaction for change authentication "
"rule for {}={} must contain field {}".format(
AUTH_ACTION, EDIT_PREFIX, OLD_VALUE))
def test_fail_pool_restart_with_invalid_datetime(
sdk_pool_handle, sdk_wallet_steward, looper):
invalid_datetime = "12.05.2018 4/40"
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
DATETIME: invalid_datetime
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_steward,
req_obj)
with pytest.raises(RequestNackedException) as excinfo:
sdk_get_and_check_replies(looper, [req], 100)
assert excinfo.match("datetime " + invalid_datetime + " is not valid")
def sdk_send_and_check_auth_rules_request(looper,
sdk_wallet_trustee,
sdk_pool_handle,
rules=None,
no_wait=False):
if rules is None:
rules = [
generate_auth_rule(ADD_PREFIX, NYM, ROLE, TRUST_ANCHOR),
generate_auth_rule(EDIT_PREFIX, NYM, ROLE, TRUST_ANCHOR, TRUSTEE)
]
op = {RULES: rules, TXN_TYPE: AUTH_RULES}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
if no_wait:
return req
resp = sdk_get_and_check_replies(looper, [req])
return resp
def sdk_send_and_check_auth_rule_request(looper,
sdk_wallet_trustee,
sdk_pool_handle,
auth_action=ADD_PREFIX,
auth_type=NYM,
field=ROLE,
new_value=TRUST_ANCHOR,
old_value=None,
constraint=None,
no_wait=False):
op = generate_auth_rule_operation(auth_action, auth_type, field, new_value,
old_value, constraint)
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
if no_wait:
return req
resp = sdk_get_and_check_replies(looper, [req])
return resp
def successful_op(looper, op, sdk_wallet, sdk_pool_handle):
req_obj = sdk_gen_request(op, identifier=sdk_wallet[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet, req_obj)
sdk_get_reply(looper, req)
