def test_transform_txn_for_catchup_rep(alh, db_manager, initial_domain_size, initial_pool_size, initial_config_size): do_apply_audit_txn(alh, txns_count=10, ledger_id=DOMAIN_LEDGER_ID, view_no=0, pp_sq_no=1, txn_time=10000, has_audit_txn=True) audit_txn_after_serialization = \ JsonSerializer.loads( JsonSerializer.dumps( alh.ledger.get_last_txn() ) ) transformed_audit_txn = alh.transform_txn_for_ledger(audit_txn_after_serialization) check_audit_txn(txn=transformed_audit_txn, view_no=0, pp_seq_no=1, seq_no=1, txn_time=10000, ledger_id=DOMAIN_LEDGER_ID, txn_root=db_manager.get_ledger(DOMAIN_LEDGER_ID).uncommitted_root_hash, state_root=db_manager.get_state(DOMAIN_LEDGER_ID).headHash, pool_size=initial_pool_size, domain_size=initial_domain_size + 10, config_size=initial_config_size, last_pool_seqno=None, last_domain_seqno=None, last_config_seqno=None)
def static_validation(self, request: Request): self._validate_request_type(request) try: content_as_dict = JsonSerializer.loads( request.operation[RS_CONTENT]) except ValueError: raise InvalidClientRequest( request.identifier, request.reqId, "'{}' must be a JSON serialized string".format(RS_CONTENT)) if self.is_json_ld_content(): self.do_static_validation_json_ld(content_as_dict, request) self.do_static_validation_content(content_as_dict, request)
def do_dynamic_validation_content(self, request): # it has been checked on static validation step that the content is a valid JSON. # and it has schema and mapping fields content_as_dict = JsonSerializer.loads(request.operation[RS_CONTENT]) schema_id = content_as_dict[RS_CRED_DEF_SCHEMA] mapping_id = content_as_dict[RS_CRED_DEF_MAPPING] # 1. check that the schema field points to an existing object on the ledger schema, _, _ = self.get_from_state(schema_id) if not schema: raise InvalidClientRequest( request.identifier, request.reqId, "Can not find a referenced '{}' with id={}; please make sure that it has been added to the ledger" .format(RS_CRED_DEF_SCHEMA, schema_id)) # 2. check that the mapping field points to an existing object on the ledger mapping, _, _ = self.get_from_state(mapping_id) if not mapping: raise InvalidClientRequest( request.identifier, request.reqId, "Can not find a referenced '{}' with id={}; please make sure that it has been added to the ledger" .format(RS_CRED_DEF_MAPPING, mapping_id)) # 3. check that the schema field points to an object of the Schema type if schema.get(RS_TYPE) != RS_SCHEMA_TYPE_VALUE: raise InvalidClientRequest( request.identifier, request.reqId, "'{}' field must reference a schema with {}={}".format( RS_CRED_DEF_SCHEMA, RS_TYPE, RS_SCHEMA_TYPE_VALUE)) # 4. check that the mapping fields points to an object of the Mapping type if mapping.get(RS_TYPE) != RS_MAPPING_TYPE_VALUE: raise InvalidClientRequest( request.identifier, request.reqId, "'{}' field must reference a mapping with {}={}".format( RS_CRED_DEF_MAPPING, RS_TYPE, RS_MAPPING_TYPE_VALUE))
def do_dynamic_validation_content(self, request): # it has been checked on static validation step that the content is a valid JSON. # and it has schema and attributes fields content_as_dict = JsonSerializer.loads(request.operation[RS_CONTENT]) # 1. check that the schema field points to an existing object on the ledger schema_id = content_as_dict[RS_MAPPING_SCHEMA] schema, _, _ = self.get_from_state(schema_id) if not schema: raise InvalidClientRequest(request.identifier, request.reqId, 'Can not find a schema with id={}; please make sure that it has been added to the ledger'.format( schema_id)) # 2. check that the schema field points to an object of the Schema type if schema.get(RS_TYPE) != RS_SCHEMA_TYPE_VALUE: raise InvalidClientRequest(request.identifier, request.reqId, "'{}' field must reference a schema with {}={}".format( RS_MAPPING_SCHEMA, RS_TYPE, RS_SCHEMA_TYPE_VALUE)) # 3. find all attribute leaf dicts with encoding-rank pairs enc_desc_dicts = list(find_encoding_desc_dicts(content_as_dict[RS_MAPPING_ATTRIBUTES])) # 4. check that every dict has encoding and rank fields # Note: this check can be done in static validation, but then we will have to traverse the leaf dicts twice for desc_dict, attr in enc_desc_dicts: if not isinstance(desc_dict, dict): raise InvalidClientRequest(request.identifier, request.reqId, "{} and {} must be set for the attribute '{}'".format(RS_MAPPING_ENC, RS_MAPPING_RANK, attr)) missing_fields = [] for field in [RS_MAPPING_ENC, RS_MAPPING_RANK]: v = desc_dict.get(field) if not v and v != 0: missing_fields.append(field) if missing_fields: missing_fields_str = " and ".join(missing_fields) raise InvalidClientRequest(request.identifier, request.reqId, "{} must be set for the attribute '{}'".format(missing_fields_str, attr)) # 5. check that all ranks are unique and form a sequence without gaps # Note: this check can be done in static validation, but then we will have to traverse the leaf dicts twice expected_ranks = list(range(1, len(enc_desc_dicts) + 1)) ranks = sorted([desc_dict[RS_MAPPING_RANK] for desc_dict, attr in enc_desc_dicts]) if ranks != expected_ranks: raise InvalidClientRequest(request.identifier, request.reqId, "the attribute's ranks are not sequential: expected ranks are all values from 1 to {}".format( len(enc_desc_dicts))) # 6. check that all the enc fields point to an existing object on the ledger of the type Encoding for desc_dict, attr in enc_desc_dicts: encoding_id = desc_dict[RS_MAPPING_ENC] encoding, _, _ = self.get_from_state(encoding_id) if not encoding: raise InvalidClientRequest(request.identifier, request.reqId, "Can not find a referenced '{}' with id={} in the '{}' attribute; please make sure that it has been added to the ledger".format( RS_MAPPING_ENC, encoding_id, attr)) if encoding.get(RS_TYPE) != RS_ENCODING_TYPE_VALUE: raise InvalidClientRequest(request.identifier, request.reqId, "'{}' field in the '{}' attribute must reference an encoding with {}={}".format( RS_MAPPING_ENC, attr, RS_TYPE, RS_ENCODING_TYPE_VALUE))