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_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_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_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_audit_ledger_multiple_ledgers_in_one_batch(txnPoolNodeSet): # Checking first case -- first audit txn node = txnPoolNodeSet[0] audit_batch_handler = node.write_manager.audit_b_handler op = { TXN_TYPE: PlenumTransactions.NYM.value, TARGET_NYM: "000000000000000000000000Trustee4" } nym_req = sdk_gen_request(op, signatures={"sig1": "111"}) node.write_manager.apply_request(nym_req, 10000) op2 = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_AML, AML_VERSION: "version1"} pool_config_req = sdk_gen_request(op2, signatures={"sig1": "111"}) node.write_manager.apply_request(pool_config_req, 10000) domain_root_hash = Ledger.hashToStr(node.domainLedger.uncommittedRootHash) config_root_hash = Ledger.hashToStr(node.configLedger.uncommittedRootHash) domain_state_root = Ledger.hashToStr(node.states[1].headHash) config_state_root = Ledger.hashToStr(node.states[2].headHash) batch = get_3PC_batch(domain_root_hash) txn_data = audit_batch_handler._create_audit_txn_data( batch, audit_batch_handler.ledger.get_last_txn()) append_txn_to_ledger(txn_data, node.auditLedger, 1) assert txn_data[AUDIT_TXN_LEDGER_ROOT][1] == domain_root_hash assert txn_data[AUDIT_TXN_LEDGER_ROOT][2] == config_root_hash assert txn_data[AUDIT_TXN_STATE_ROOT][1] == domain_state_root assert txn_data[AUDIT_TXN_STATE_ROOT][2] == config_state_root # Checking usual case -- double update not in a first transaction op = { TXN_TYPE: PlenumTransactions.NYM.value, TARGET_NYM: "000000000000000000000000Trustee5" } nym_req = sdk_gen_request(op, signatures={"sig1": "111"}) node.write_manager.apply_request(nym_req, 10000) op2 = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_AML, AML_VERSION: "version2"} pool_config_req = sdk_gen_request(op2, signatures={"sig1": "111"}) node.write_manager.apply_request(pool_config_req, 10000) # Checking second batch created domain_root_hash_2 = Ledger.hashToStr( node.domainLedger.uncommittedRootHash) config_root_hash_2 = Ledger.hashToStr( node.configLedger.uncommittedRootHash) domain_state_root_2 = Ledger.hashToStr(node.states[1].headHash) config_state_root_2 = Ledger.hashToStr(node.states[2].headHash) batch = get_3PC_batch(domain_root_hash_2) txn_data = audit_batch_handler._create_audit_txn_data( batch, audit_batch_handler.ledger.get_last_txn()) # Checking first batch created assert txn_data[AUDIT_TXN_LEDGER_ROOT][1] == domain_root_hash_2 assert txn_data[AUDIT_TXN_LEDGER_ROOT][2] == config_root_hash_2 assert txn_data[AUDIT_TXN_STATE_ROOT][1] == domain_state_root_2 assert txn_data[AUDIT_TXN_STATE_ROOT][2] == config_state_root_2
def test_multiple_ledgers_in_second_batch_apply_first_time(txnPoolNodeSet): # First txn node = txnPoolNodeSet[0] audit_batch_handler = node.write_manager.audit_b_handler op = { TXN_TYPE: PlenumTransactions.NYM.value, TARGET_NYM: "000000000000000000000000Trustee4", ROLE: None } nym_req = sdk_gen_request(op, signatures={"sig1": "111"}) node.write_manager.apply_request(nym_req, 10000) op2 = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_AML, AML_VERSION: "version2"} pool_config_req = sdk_gen_request(op2, signatures={"sig1": "111"}) node.write_manager.apply_request(pool_config_req, 10000) domain_root_hash = Ledger.hashToStr(node.domainLedger.uncommittedRootHash) batch = get_3PC_batch(domain_root_hash) txn_data = audit_batch_handler._create_audit_txn_data( batch, audit_batch_handler.ledger.get_last_txn()) append_txn_to_ledger(txn_data, node.auditLedger, 2) # Checking rare case -- batch from two ledgers, that were never audited before op2 = { TXN_TYPE: PlenumTransactions.NODE.value, TARGET_NYM: "000000000000000000000000Trustee1", DATA: { ALIAS: "Node100" } } node_req = sdk_gen_request(op2, signatures={"sig1": "111"}) node.write_manager.apply_request(node_req, 10000) op2 = {TXN_TYPE: TXN_AUTHOR_AGREEMENT_AML, AML_VERSION: "version2"} pool_config_req = sdk_gen_request(op2, signatures={"sig1": "111"}) node.write_manager.apply_request(pool_config_req, 10000) pool_root_hash = Ledger.hashToStr(node.poolLedger.uncommittedRootHash) pool_state_root = Ledger.hashToStr(node.states[0].headHash) config_root_hash = Ledger.hashToStr(node.configLedger.uncommittedRootHash) config_state_root = Ledger.hashToStr(node.states[2].headHash) batch = get_3PC_batch(pool_root_hash, ledger_id=0) txn_data = audit_batch_handler._create_audit_txn_data( batch, audit_batch_handler.ledger.get_last_txn()) assert txn_data[AUDIT_TXN_LEDGER_ROOT][0] == pool_root_hash assert txn_data[AUDIT_TXN_STATE_ROOT][0] == pool_state_root assert txn_data[AUDIT_TXN_LEDGER_ROOT][1] == 1 assert 1 not in txn_data[AUDIT_TXN_STATE_ROOT].keys() assert txn_data[AUDIT_TXN_LEDGER_ROOT][2] == config_root_hash assert txn_data[AUDIT_TXN_STATE_ROOT][2] == config_state_root
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 get_utxo_request(address, sender_did): op = { TXN_TYPE: GET_UTXO, ADDRESS: address, } request = sdk_gen_request(op, identifier=sender_did) return request
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 write(key, val, looper, sdk_pool_handle, sdk_wallet): _, idr = sdk_wallet reqs_obj = [sdk_gen_request(op, identifier=idr) for op in [write_conf_op(key, val)]] reqs = sdk_sign_request_objects(looper, sdk_wallet, reqs_obj) sent_reqs = sdk_send_signed_requests(sdk_pool_handle, reqs) sdk_get_replies(looper, sent_reqs, timeout=10)
def _send_and_check_get_auth_rule(looper, sdk_pool_handle, sdk_wallet, key): op = {TXN_TYPE: GET_AUTH_RULE, **key} req_obj = sdk_gen_request(op, identifier=sdk_wallet[1]) return sdk_send_and_check_req_json( looper, sdk_pool_handle, sdk_wallet, json.dumps(req_obj.as_dict) )
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 write(key, val, looper, sdk_pool_handle, sdk_wallet): _, idr = sdk_wallet reqs_obj = [sdk_gen_request(op, identifier=idr) for op in [write_conf_op(key, val)]] reqs = sdk_sign_request_objects(looper, sdk_wallet, reqs_obj) sent_reqs = sdk_send_signed_requests(sdk_pool_handle, reqs) sdk_get_replies(looper, sent_reqs, timeout=10)
def two_requests(looper, sdk_wallet_steward): wh, did = sdk_wallet_steward op = {TXN_TYPE: AUCTION_START, DATA: {'id': 'xyz'}} req1 = sdk_gen_request(op, protocol_version=CURRENT_PROTOCOL_VERSION, identifier=did).as_dict field = list(PLUGIN_CLIENT_REQUEST_FIELDS.keys())[0] req1[field] = 'x' * 10 req2 = copy.deepcopy(req1) req2[field] = 'z' * 10 req1 = sdk_multisign_request_object(looper, sdk_wallet_steward, json.dumps(req1)) req_obj1 = Request(**json.loads(req1)) req2 = sdk_multisign_request_object(looper, sdk_wallet_steward, json.dumps(req2)) req_obj2 = Request(**json.loads(req2)) assert req_obj1.payload_digest == req_obj2.payload_digest assert req_obj1.digest != req_obj2.digest return req1, req2
def read(key, looper, sdk_pool_handle, sdk_wallet): _, idr = sdk_wallet reqs_obj = [sdk_gen_request(op, identifier=idr) for op in [read_conf_op(key)]] reqs = sdk_sign_request_objects(looper, sdk_wallet, reqs_obj) sent_reqs = sdk_send_signed_requests(sdk_pool_handle, reqs) (req, resp), = sdk_get_replies(looper, sent_reqs, timeout=10) return json.loads(resp['result'][DATA])[key]
def sdk_send_and_check_get_auth_rule_invalid_request(looper, sdk_pool_handle, sdk_wallet, **invalid_params): op = {TXN_TYPE: GET_AUTH_RULE} op.update(**invalid_params) req_obj = sdk_gen_request(op, identifier=sdk_wallet[1]) return sdk_send_and_check_req_json(looper, sdk_pool_handle, sdk_wallet, json.dumps(req_obj.as_dict))
def read(key, looper, sdk_pool_handle, sdk_wallet): _, idr = sdk_wallet reqs_obj = [sdk_gen_request(op, identifier=idr) for op in [read_conf_op(key)]] reqs = sdk_sign_request_objects(looper, sdk_wallet, reqs_obj) sent_reqs = sdk_send_signed_requests(sdk_pool_handle, reqs) (req, resp), = sdk_get_replies(looper, sent_reqs, timeout=10) return json.loads(resp['result'][DATA])[key]
def test_client_msg_discard_in_view_change_unit(txnPoolNodeSet): node = txnPoolNodeSet[0] node.view_changer.view_change_in_progress = True msg = sdk_gen_request("op").as_dict node.unpackClientMsg(msg, "frm") checkDiscardMsg([ node, ], msg, "view change in progress")
def test_client_msg_discard_in_view_change_with_request(test_node): test_node.send_nack_to_client = check_nack_msg msg = sdk_gen_request({TXN_TYPE: NODE}) test_node.unpackClientMsg(msg, "frm") checkDiscardMsg([ test_node, ], msg.as_dict, "view change in progress")
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 get_default_auth_rule(self): constraint = auth_map.get(self.action_id) operation = generate_auth_rule_operation(auth_action=self.action.prefix, auth_type=self.action.txn_type, field=self.action.field, old_value=self.action.old_value if self.action.prefix == EDIT_PREFIX else None, new_value=self.action.new_value, constraint=constraint.as_dict) return sdk_gen_request(operation, identifier=self.trustee_wallet[1])
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_client_msg_discard_in_view_change_with_request(txnPoolNodeSet): node = txnPoolNodeSet[0] node.view_changer.view_change_in_progress = True node.send_nack_to_client = check_nack_msg msg = sdk_gen_request("op") node.unpackClientMsg(msg, "frm") checkDiscardMsg([ node, ], msg.as_dict, "view change in progress")
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 get_changed_auth_rule(self): constraint = AuthConstraint(role=None, sig_count=1, need_to_be_owner=False) operation = generate_auth_rule_operation(auth_action=EDIT_PREFIX, auth_type=AUTH_RULE, field='*', old_value='*', new_value='*', constraint=constraint.as_dict) return sdk_gen_request(operation, identifier=self.trustee_wallet[1])
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 get_changed_auth_rule(self): self.new_default_wallet = sdk_add_new_nym(self.looper, self.sdk_pool_handle, self.trustee_wallet, role=IDENTITY_OWNER) constraint = AuthConstraint(role=IDENTITY_OWNER, sig_count=1, need_to_be_owner=False) operation = generate_auth_rule_operation(auth_action=ADD_PREFIX, auth_type=SCHEMA, field='*', new_value='*', constraint=constraint.as_dict) return sdk_gen_request(operation, identifier=self.trustee_wallet[1])
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 get_changed_auth_rule(self): constraint = AuthConstraint(role=TRUSTEE, sig_count=1, need_to_be_owner=False) operation = generate_auth_rule_operation(auth_action=EDIT_PREFIX, auth_type=NYM, field=VERKEY, old_value='*', new_value='*', constraint=constraint.as_dict) return sdk_gen_request(operation, identifier=self.creator_wallet[1])
def sign_and_validate(looper, node, action_id, signer, op, did_ledger=None): req_obj = sdk_gen_request(op, protocol_version=CURRENT_PROTOCOL_VERSION, identifier=signer.did) s_req = sdk_sign_request_objects(looper, signer.wallet_did, [req_obj])[0] request = Request(**json.loads(s_req)) if auth_check(action_id, signer, op, did_ledger): node.write_manager.dynamic_validation(request) else: with pytest.raises(UnauthorizedClientRequest): node.write_manager.dynamic_validation(request)
def get_changed_auth_rule(self): self.new_default_wallet = self.add_revoc_reg_def.new_default_wallet constraint = AuthConstraint(role=IDENTITY_OWNER, sig_count=1, need_to_be_owner=False) operation = generate_auth_rule_operation(auth_action=EDIT_PREFIX, auth_type=REVOC_REG_DEF, field='*', old_value='*', new_value='*', constraint=constraint.as_dict) return sdk_gen_request(operation, identifier=self.trustee_wallet[1])
def sdk_send_and_check_auth_rule_invalid_request(looper, sdk_pool_handle, sdk_wallet_trustee, no_wait=False, **invalid_params): op = generate_auth_rule_operation(**invalid_params) req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1]) req_json = json.dumps(req_obj.as_dict) return sdk_send_and_check_req_json(looper, sdk_pool_handle, sdk_wallet_trustee, req_json, no_wait=no_wait)
def test_client_read_request_not_discard_in_view_change_with_dict(test_node): sender = "frm" msg = sdk_gen_request({TXN_TYPE: READ_CONF}).as_dict def post_to_client_in_box(received_msg, received_frm): assert received_frm == sender assert received_msg == msg test_node.postToClientInBox = post_to_client_in_box def discard(received_msg, reason, logLevel): assert False, "Message {} was discard with '{}'".format(received_msg, reason) test_node.discard = discard test_node.unpackClientMsg(msg, sender)
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_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_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_validator_info_handler(monkeypatch, sdk_wallet_trustee, txnPoolNodeSet): op = { TXN_TYPE: VALIDATOR_INFO } req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1]) def is_ack(req_key, frm): assert (req_obj.identifier, req_obj.reqId) == req_key def is_reply_correct(resp, frm): _comparison_reply(resp, req_obj) node = txnPoolNodeSet[0] monkeypatch.setattr(node, 'transmitToClient', is_reply_correct) monkeypatch.setattr(node, 'send_ack_to_client', is_ack) node.process_action(req_obj, None)
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)
def test_client_msg_discard_in_view_change_with_request(test_node): test_node.send_nack_to_client = check_nack_msg msg = sdk_gen_request({TXN_TYPE: NODE}) test_node.unpackClientMsg(msg, "frm") checkDiscardMsg([test_node, ], msg.as_dict, "view change in progress")