def test_send_get_rich_schema_obj_by_invalid_metadata( looper, sdk_pool_handle, sdk_wallet_endorser, txn_type, rs_type, content, invalid_meta_name, invalid_meta_value): rs_id = randomString() rs_name = randomString() rs_version = '1.0' sdk_write_rich_schema_object_and_check(looper, sdk_wallet_endorser, sdk_pool_handle, txn_type=txn_type, rs_id=rs_id, rs_name=rs_name, rs_version=rs_version, rs_type=rs_type, rs_content=content) get_rich_schema_by_metadata_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_METADATA, RS_NAME: rs_name, RS_VERSION: rs_version, RS_TYPE: rs_type } get_rich_schema_by_metadata_operation[ invalid_meta_name] = invalid_meta_value result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_endorser, get_rich_schema_by_metadata_operation) assert result['data'] is None assert result['seqNo'] is None assert result['txnTime'] is None assert result['state_proof'] check_valid_proof(result)
def test_state_proof_returned_for_get_rich_schema_obj_by_metadata( looper, nodeSetWithOneNodeResponding, sdk_wallet_endorser, sdk_pool_handle, sdk_wallet_client, write_rich_schema, txn_type, rs_type, content, rs_id, rs_name, rs_version): """ Tests that state proof is returned in the reply for GET_RICH_SCHEMA_OBJECT_BY_METADATA. Use different submitter and reader! """ get_rich_schema_by_metadata_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_METADATA, RS_NAME: rs_name, RS_VERSION: rs_version, RS_TYPE: rs_type } result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_client, get_rich_schema_by_metadata_operation) expected_data = SortedDict({ 'id': rs_id, 'rsType': rs_type, 'rsName': rs_name, 'rsVersion': rs_version, 'content': content, 'from': sdk_wallet_endorser[1] }) assert SortedDict(result['data']) == expected_data assert result['seqNo'] assert result['txnTime'] assert result['state_proof'] check_valid_proof(result)
def test_send_get_rich_schema_obj_by_metadata(looper, sdk_pool_handle, sdk_wallet_endorser, sdk_wallet_client, write_rich_schema, txn_type, rs_type, content, rs_id, rs_name, rs_version): get_rich_schema_by_metadata_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_METADATA, RS_NAME: rs_name, RS_VERSION: rs_version, RS_TYPE: rs_type } result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_client, get_rich_schema_by_metadata_operation) expected_data = SortedDict({ 'id': rs_id, 'rsType': rs_type, 'rsName': rs_name, 'rsVersion': rs_version, 'content': json.dumps(content), 'from': sdk_wallet_endorser[1], 'endorser': None, 'ver': None }) assert SortedDict(result['data']) == expected_data assert result['seqNo'] assert result['txnTime'] assert result['state_proof'] check_valid_proof(result)
def test_state_proof_returned_for_get_revoc_reg_entry(looper, nodeSetWithOneNodeResponding, sdk_wallet_steward, sdk_pool_handle, sdk_wallet_client, send_revoc_reg_entry): revoc_reg_def = send_revoc_reg_entry[0] revoc_reg_entry_data = send_revoc_reg_entry[1][0]['operation'] timestamp = int(time.time()) req = looper.loop.run_until_complete(build_get_revoc_reg_request( sdk_wallet_client[1], get_revoc_reg_def_id(sdk_wallet_steward[1], revoc_reg_def[0]), timestamp)) rep = sdk_get_and_check_replies(looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, req)]) result = rep[0][1]['result'] expected_data = revoc_reg_entry_data data = result.get(DATA) del expected_data['type'] del data['seqNo'] del data['txnTime'] assert DATA in result assert data assert data == expected_data assert result[TXN_TIME] check_valid_proof(result)
def test_state_proof_returned_for_get_attr(looper, nodeSetWithOneNodeResponding, sdk_added_raw_attribute, attributeName, attributeData, sdk_pool_handle, sdk_wallet_client): """ Tests that state proof is returned in the reply for GET_ATTR transactions. Use different submitter and reader! """ get_attr_operation = { TARGET_NYM: sdk_added_raw_attribute['result']['txn']['data']['dest'], TXN_TYPE: GET_ATTR, RAW: attributeName } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_attr_operation) expected_data = attrib_raw_data_serializer.deserialize(attributeData) assert DATA in result data = attrib_raw_data_serializer.deserialize(result[DATA]) assert data == expected_data assert result[TXN_TIME] check_valid_proof(result)
def test_state_proof_returned_for_get_nym(looper, nodeSetWithOneNodeResponding, sdk_user_wallet_a, sdk_pool_handle, sdk_wallet_client, sdk_wallet_endorser): """ Tests that state proof is returned in the reply for GET_NYM transactions. Use different submitter and reader! """ _, dest = sdk_user_wallet_a nym_operation = {TARGET_NYM: dest, TXN_TYPE: NYM} sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_endorser, nym_operation) get_nym_operation = {TARGET_NYM: dest, TXN_TYPE: GET_NYM} result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_nym_operation) assert DATA in result assert result[DATA] data = domain_state_serializer.deserialize(result[DATA]) assert ROLE in data assert VERKEY in data assert f.IDENTIFIER.nm in data assert result[TXN_TIME] check_valid_proof(result)
def test_send_get_rich_schema_obj_by_invalid_id(looper, sdk_pool_handle, sdk_wallet_endorser, txn_type, rs_type, content): rs_id = randomString() rs_name = randomString() rs_version = '1.0' sdk_write_rich_schema_object_and_check(looper, sdk_wallet_endorser, sdk_pool_handle, txn_type=txn_type, rs_id=rs_id, rs_name=rs_name, rs_version=rs_version, rs_type=rs_type, rs_content=content) get_rich_schema_by_id_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_ID, RS_ID: randomString(), } result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_endorser, get_rich_schema_by_id_operation) assert result['data'] is None assert result['seqNo'] is None assert result['txnTime'] is None assert result['state_proof'] check_valid_proof(result)
def check_get_delta(looper, sdk_wallet_client, sdk_wallet_steward, revoc_reg_def, timestamp_fr, timestamp_to, sdk_pool_handle, revoc_reg_entry_data, check_data=True): req = looper.loop.run_until_complete( build_get_revoc_reg_delta_request( sdk_wallet_client[1], get_revoc_reg_def_id(sdk_wallet_steward[1], revoc_reg_def[0]), timestamp_fr, timestamp_to)) rep = sdk_get_and_check_replies( looper, [sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, req)]) if check_data: result = rep[0][1]['result'] expected_data = revoc_reg_entry_data data = result.get(DATA)['value']['accum_to'] del data['seqNo'] del data['txnTime'] if 'type' in expected_data: del expected_data['type'] assert DATA in result assert data assert data == expected_data assert result[TXN_TIME] check_valid_proof(result)
def test_get_rich_schema_obj_not_existent(db_manager, handler_and_request, metadata, get_rich_schema_by_meta_handler, get_rich_schema_req): save_multi_sig(db_manager) # execute: get object result = get_rich_schema_by_meta_handler.get_result(get_rich_schema_req) # check assert result assert result['data'] is None assert result['seqNo'] is None assert result['txnTime'] is None assert result['state_proof'] check_valid_proof(result)
def test_state_proof_returned_for_get_context(looper, nodeSetWithOneNodeResponding, sdk_wallet_endorser, sdk_pool_handle, sdk_wallet_client): """ Tests that state proof is returned in the reply for GET_CONTEXT transactions. Use different submitter and reader! """ _, dest = sdk_wallet_endorser context_name = "test_context" context_version = "1.0" meta = { CONTEXT_NAME: context_name, CONTEXT_VERSION: context_version, RS_TYPE: CONTEXT_TYPE, } data = SIMPLE_CONTEXT context_operation = {TXN_TYPE: SET_CONTEXT, DATA: data, META: meta} sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_endorser, context_operation) get_context_operation = { TARGET_NYM: dest, TXN_TYPE: GET_CONTEXT, META: { CONTEXT_NAME: context_name, CONTEXT_VERSION: context_version, RS_TYPE: CONTEXT_TYPE } } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_context_operation) assert DATA in result rdata = result.get(DATA) assert rdata assert DATA in rdata data = rdata[DATA] assert CONTEXT_CONTEXT in data assert data == SIMPLE_CONTEXT assert META in rdata meta = rdata[META] assert NAME in meta assert VERSION in meta assert result[TXN_TIME] check_valid_proof(result)
def test_state_proof_returned_for_get_schema(looper, nodeSetWithOneNodeResponding, sdk_wallet_endorser, sdk_pool_handle, sdk_wallet_client): """ Tests that state proof is returned in the reply for GET_SCHEMA transactions. Use different submitter and reader! """ _, dest = sdk_wallet_endorser schema_name = "test_schema" schema_version = "1.0" schema_attr_names = ["width", "height"] data = { SCHEMA_NAME: schema_name, SCHEMA_VERSION: schema_version, SCHEMA_ATTR_NAMES: schema_attr_names } schema_operation = { TXN_TYPE: SCHEMA, DATA: data } sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_endorser, schema_operation) get_schema_operation = { TARGET_NYM: dest, TXN_TYPE: GET_SCHEMA, DATA: { NAME: schema_name, VERSION: schema_version, } } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_schema_operation) assert DATA in result data = result.get(DATA) assert data assert SCHEMA_ATTR_NAMES in data assert data[SCHEMA_ATTR_NAMES] == schema_attr_names assert NAME in data assert VERSION in data assert result[TXN_TIME] check_valid_proof(result)
def test_get_rich_schema_obj_committed_only(db_manager, handler_and_request, metadata, get_rich_schema_by_meta_handler, get_rich_schema_req): # prepare: store object in state with bls multi-sig, and then update the object (uncommitted) handler, request = handler_and_request rs_name, rs_version, rs_type = metadata op = request.operation op[RS_NAME] = rs_name op[RS_VERSION] = rs_version op[RS_TYPE] = rs_type seq_no = 1 txn_time = 1560241033 txn = reqToTxn(request) append_txn_metadata(txn, seq_no, txn_time) handler.update_state(txn, None, request) handler.state.commit() get_payload_data(txn)[RS_CONTENT] = "new uncommitted content" handler.update_state(txn, None, request) save_multi_sig(db_manager) # execute: get object result = get_rich_schema_by_meta_handler.get_result(get_rich_schema_req) # check assert result expected_data = SortedDict({ 'ver': op[OP_VER], 'id': op[RS_ID], 'rsType': op[RS_TYPE], 'rsName': op[RS_NAME], 'rsVersion': op[RS_VERSION], 'content': op[RS_CONTENT], 'from': request.identifier, 'endorser': request.endorser, }) assert SortedDict(result['data']) == expected_data assert result['seqNo'] == seq_no assert result['txnTime'] == txn_time assert result['state_proof'] check_valid_proof(result) path = op[RS_ID].encode() assert is_proof_verified(db_manager, result['state_proof'], path, result[DATA], seq_no, txn_time)
def test_state_proof_returned_for_get_claim_def(looper, nodeSetWithOneNodeResponding, sdk_wallet_endorser, sdk_pool_handle, sdk_wallet_client, send_schema_seq_no): """ Tests that state proof is returned in the reply for GET_CLAIM_DEF transactions. Use different submitter and reader! """ _, dest = sdk_wallet_endorser data = {"primary": {'N': '123'}, REVOCATION: {'h0': '456'}} claim_def_operation = { TXN_TYPE: CLAIM_DEF, CLAIM_DEF_SCHEMA_REF: send_schema_seq_no, DATA: data, CLAIM_DEF_SIGNATURE_TYPE: 'CL', CLAIM_DEF_TAG: "tag1" } sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_endorser, claim_def_operation) get_claim_def_operation = { CLAIM_DEF_FROM: dest, TXN_TYPE: GET_CLAIM_DEF, CLAIM_DEF_SCHEMA_REF: send_schema_seq_no, CLAIM_DEF_SIGNATURE_TYPE: 'CL', CLAIM_DEF_TAG: "tag1" } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_client, get_claim_def_operation) expected_data = data assert DATA in result data = result.get(DATA) assert data assert data == expected_data assert result[TXN_TIME] check_valid_proof(result)
def test_state_proof_returned_for_get_auth_rule(looper, nodeSetWithOneNodeResponding, sdk_wallet_steward, sdk_pool_handle, sdk_wallet_client, send_auth_rule): req = send_auth_rule key = generate_key(auth_action=ADD_PREFIX, auth_type=NYM, field=ROLE, new_value=ENDORSER) rep = sdk_send_and_check_get_auth_rule_request(looper, sdk_pool_handle, sdk_wallet_client, **key) result = rep[0][1]['result'] expected_data = req[0][0]['operation'] del expected_data['type'] assert DATA in result data = result.get(DATA) assert data assert data[0] == expected_data check_valid_proof(result)
def test_state_proof_returned_for_get_rich_schema_obj_by_id( looper, nodeSetWithOneNodeResponding, sdk_wallet_endorser, sdk_pool_handle, sdk_wallet_client, txn_type, rs_type, content): """ Tests that state proof is returned in the reply for GET_RICH_SCHEMA_OBJECT_BY_ID. Use different submitter and reader! """ rs_id = randomString() rs_name = randomString() rs_version = '1.0' sdk_write_rich_schema_object_and_check(looper, sdk_wallet_endorser, sdk_pool_handle, txn_type=txn_type, rs_id=rs_id, rs_name=rs_name, rs_version=rs_version, rs_type=rs_type, rs_content=content) get_rich_schema_by_id_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_ID, RS_ID: rs_id, } result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_client, get_rich_schema_by_id_operation) expected_data = SortedDict({ 'id': rs_id, 'rsType': rs_type, 'rsName': rs_name, 'rsVersion': rs_version, 'content': content, 'from': sdk_wallet_endorser[1] }) assert SortedDict(result['data']) == expected_data assert result['seqNo'] assert result['txnTime'] assert result['state_proof'] check_valid_proof(result)
def test_send_get_rich_schema_obj_by_id(looper, sdk_pool_handle, sdk_wallet_endorser, txn_type, rs_type, content): rs_id = randomString() rs_name = randomString() rs_version = '1.0' sdk_write_rich_schema_object_and_check(looper, sdk_wallet_endorser, sdk_pool_handle, txn_type=txn_type, rs_id=rs_id, rs_name=rs_name, rs_version=rs_version, rs_type=rs_type, rs_content=content) get_rich_schema_by_id_operation = { TXN_TYPE: GET_RICH_SCHEMA_OBJECT_BY_ID, RS_ID: rs_id, } result = sdk_submit_operation_and_get_result( looper, sdk_pool_handle, sdk_wallet_endorser, get_rich_schema_by_id_operation) expected_data = SortedDict({ 'id': rs_id, 'rsType': rs_type, 'rsName': rs_name, 'rsVersion': rs_version, 'content': json.dumps(content), 'from': sdk_wallet_endorser[1], 'endorser': None, 'ver': None }) assert SortedDict(result['data']) == expected_data assert result['seqNo'] assert result['txnTime'] assert result['state_proof'] check_valid_proof(result)
def test_state_proof_returned_for_missing_schema(looper, nodeSetWithOneNodeResponding, sdk_pool_handle, sdk_wallet_trust_anchor): """ Tests that state proof is returned in the reply for GET_SCHEMA transactions """ _, dest = sdk_wallet_trust_anchor schema_name = "test_schema" schema_version = "1.0" get_schema_operation = { TARGET_NYM: dest, TXN_TYPE: GET_SCHEMA, DATA: { SCHEMA_NAME: schema_name, SCHEMA_VERSION: schema_version, } } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_trust_anchor, get_schema_operation) assert SCHEMA_ATTR_NAMES not in result[DATA] check_valid_proof(result)
def test_state_proof_returned_for_missing_context(looper, nodeSet, sdk_pool_handle, sdk_wallet_endorser): """ Tests that state proof is returned in the reply for GET_CONTEXT transactions """ _, dest = sdk_wallet_endorser context_name = "test_context" context_version = "1.0" get_context_operation = { TARGET_NYM: dest, TXN_TYPE: GET_CONTEXT, META: { CONTEXT_NAME: context_name, CONTEXT_VERSION: context_version, RS_TYPE: CONTEXT_TYPE } } result = sdk_submit_operation_and_get_result(looper, sdk_pool_handle, sdk_wallet_endorser, get_context_operation) assert not result[DATA] check_valid_proof(result)
def check_no_data_and_valid_proof(result): assert result.get(DATA) is None check_valid_proof(result)