def _check_state(version):
expected_data = taa_aml_expected_data[version]
_data = state.get(
WriteRequestManager._state_path_taa_aml_version(version),
isCommitted=False)
if version in written:
assert (config_state_serializer.deserialize(_data)[VALUE] ==
config_state_serializer.deserialize(expected_data))
else:
assert _data is None
def get_taa_aml_data(self, version: Optional[str] = None, isCommitted: bool = True):
path = self._state_path_taa_aml_latest() if version is None \
else self._state_path_taa_aml_version(version)
payload = self.config_state.get(path, isCommitted=isCommitted)
if payload is None:
return None
return config_state_serializer.deserialize(payload)
def _check_state(version):
digest = taa_expected_digests[version]
_digest = state.get(
WriteRequestManager._state_path_taa_version(version),
isCommitted=False)
_data = state.get(WriteRequestManager._state_path_taa_digest(digest),
isCommitted=False)
if version in written:
assert _digest == digest.encode()
assert (config_state_serializer.deserialize(_data) ==
taa_expected_state_data[version])
else:
assert _digest is None
assert _data is None
def test_auth_rule_state_format(looper, sdk_pool_handle, sdk_wallet_trustee,
txnPoolNodeSet, off_ledger_signature):
auth_action = ADD_PREFIX
auth_type = NYM
field = ROLE
new_value = ENDORSER
constraint = {
CONSTRAINT_ID: ConstraintsEnum.ROLE_CONSTRAINT_ID,
ROLE: "*",
SIG_COUNT: 1,
NEED_TO_BE_OWNER: False,
METADATA: {}
}
if off_ledger_signature:
constraint[OFF_LEDGER_SIGNATURE] = off_ledger_signature
sdk_send_and_check_auth_rule_request(looper,
sdk_pool_handle,
sdk_wallet_trustee,
auth_action=auth_action,
auth_type=auth_type,
field=field,
new_value=new_value,
constraint=constraint)
state = txnPoolNodeSet[0].db_manager.get_database(CONFIG_LEDGER_ID).state
key = generate_key(auth_action, auth_type, field, new_value)
path = config.make_state_path_for_auth_rule(
StaticAuthRuleHelper.get_auth_key(key))
state_constraint = config_state_serializer.deserialize(state.get(path))
assert state_constraint == constraint
_, before_resp = sdk_send_and_check_get_auth_rule_request(
looper,
sdk_pool_handle,
sdk_wallet_trustee,
auth_type=auth_type,
auth_action=auth_action,
field=field,
new_value=new_value)[0]
for rule in before_resp["result"][DATA]:
if rule[CONSTRAINT][CONSTRAINT_ID] == 'ROLE' and off_ledger_signature:
assert OFF_LEDGER_SIGNATURE in rule[CONSTRAINT]
def test_fill_ts_store_for_config_after_catchup(txnPoolNodeSet, looper,
sdk_pool_handle,
sdk_wallet_trustee, tconf,
tdir, allPluginsPath,
set_txn_author_agreement_aml):
sdk_send_txn_author_agreement(looper,
sdk_pool_handle,
sdk_wallet_trustee,
*create_random_taa(),
ratified=get_utc_epoch() - 600)
node_to_disconnect = txnPoolNodeSet[-1]
disconnect_node_and_ensure_disconnected(looper, txnPoolNodeSet,
node_to_disconnect)
looper.removeProdable(name=node_to_disconnect.name)
sdk_reply = sdk_send_txn_author_agreement(looper,
sdk_pool_handle,
sdk_wallet_trustee,
*create_random_taa(),
ratified=get_utc_epoch() - 600)
node_to_disconnect = start_stopped_node(node_to_disconnect, looper, tconf,
tdir, allPluginsPath)
txnPoolNodeSet[-1] = node_to_disconnect
looper.run(checkNodesConnected(txnPoolNodeSet))
waitNodeDataEquality(looper,
node_to_disconnect,
*txnPoolNodeSet,
exclude_from_check=['check_last_ordered_3pc_backup'])
req_handler = node_to_disconnect.read_manager.request_handlers[
GET_TXN_AUTHOR_AGREEMENT]
last_digest = StaticTAAHelper.get_taa_digest(req_handler.state)
key = StaticTAAHelper.state_path_taa_digest(last_digest)
root_hash = req_handler.database_manager.ts_store.get_equal_or_prev(
get_txn_time(sdk_reply[1]['result']))
assert root_hash
from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
key=key)
assert config_state_serializer.deserialize(from_state)['val']['text'] == \
get_payload_data(sdk_reply[1]['result'])['text']
def _decode_state_value(self, encoded):
if encoded:
return config_state_serializer.deserialize(encoded)
return None
