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