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)