def create_validator(schema):
"""Creates a validator for the given schema id.
"""
schema_store = compile_schema_store()
resolver = jsonschema.RefResolver.from_schema(schema_store[schema], store=schema_store)
# TODO: Remove this after the jsonschema>=4 requirement had time to reach users
try:
return jsonschema.Draft202012Validator(schema_store[schema], resolver=resolver).validate
except AttributeError:
return jsonschema.Draft7Validator(schema_store[schema], resolver=resolver).validate
def operation(self,
methods,
path,
public=False,
access_policy=None,
request_schema=None):
if public == True and access_policy is not None:
raise ValueError(
"Operation might be public or have access policy, not both")
request_validator = None
if request_schema:
request_validator = jsonschema.Draft202012Validator(
schema=request_schema)
def wrap(func):
if not isinstance(path, list):
raise ValueError("`path` must be a list")
if not isinstance(methods, list):
raise ValueError("`methods` must be a list")
_str_path = []
for p in path:
if isinstance(p, str):
_str_path.append(p)
elif isinstance(p, dict):
_str_path.append("__{}__".format(p["name"]))
def wrapped_func(operation, request):
if request_validator:
validate_request(request_validator, request)
return func(operation, request)
for method in methods:
operation_id = "{}.{}.{}.{}".format(
method, func.__module__, func.__name__,
"_".join(_str_path)).replace("$", "d")
self._operations[operation_id] = {
"method": method,
"path": path,
}
self._operation_handlers[operation_id] = wrapped_func
if public is True:
self._set_access_policy_for_public_op(operation_id)
elif access_policy is not None:
self._set_operation_access_policy(operation_id,
access_policy)
return func
return wrap
def _validate_output_json(self, output_json: str):
"""
Validate output JSON data with provided .scheme file
This function will raise error if JSON does not match schema.
"""
try:
with open(self._args.schema) as schema_file:
log.info("Validating Json with schema...")
schema = json.loads(schema_file.read())
validator = jsonschema.Draft202012Validator(schema=schema)
validator.validate(instance=json.loads(output_json))
except IOError as e:
log.error("provided Json schema file is wrong: {}".format(self._args.schema))
return False
else:
log.info("Validate OK")
return True