def validate(schema, part, standard):
if standard in legacy:
cls = legacy[standard]
try:
jsonschema.validate(part.json, schema.json, cls=cls)
return (True, '')
except jsonschema.ValidationError as e:
return (False, str(e))
except jsonschema.SchemaError as e:
raise ValueError("Schema is invalid:\n{0}\n\n{1}".format(
str(e), schema.content))
return (is_valid, message)
else:
catalogue = create_catalog('2019-09', '2020-12')
compiled_schema = JSONSchema(schema.json, metaschema_uri=URI(standard))
if not compiled_schema.validate().valid:
raise ValueError("Schema is invalid:\n{0}\n\n{1}".format(
"INVALID SCHEMA", schema.content))
elif part.json == (1+1j):
return (False, 'INVALID JSON')
else:
jsonValue = JSON.loads(part.content)
validation_result = compiled_schema.evaluate(jsonValue)
if validation_result.valid:
return (True, '');
else:
return (False, 'VALIDATION ERROR');
def test_schema_examples(example, json1_valid, json2_valid):
schema = JSONSchema(example, metaschema_uri=metaschema_uri_2020_12)
schema.validate()
assert schema.value == example
assert schema.type == "boolean" if isinstance(example, bool) else "object"
assert schema.parent is None
assert schema.key is None
assert not schema.path
assert schema.metaschema_uri == metaschema_uri_2020_12
assert schema.evaluate(json1).valid is json1_valid
assert schema.evaluate(json2).valid is json2_valid
def test_contains(minmax, instval):
min_contains = min(minmax)
max_contains = max(minmax)
contains_count = len(
list(filter(lambda item: JSON(item).type == "boolean", instval)))
schema = JSONSchema(
{
"contains": {
"type": "boolean"
},
"minContains": min_contains,
"maxContains": max_contains,
},
metaschema_uri=metaschema_uri_2019_09)
scope = schema.evaluate(JSON(instval))
assert scope.valid == (min_contains <= contains_count <= max_contains)
def test_annotate(key, value):
result = JSONSchema({
key: value
}, metaschema_uri=metaschema_uri_2020_12).evaluate(JSON(""))
assert result.valid is True
assert result.children[key].valid is True
assert result.children[key]._assert is False
try:
assert result.children[key].annotations[key].value == value
except KeyError:
assert value is None
def test_content_schema():
example = {
"contentMediaType": "application/json",
"contentSchema": {
"required": ["foo"],
"properties": {
"foo": {
"type": "string"
}
}
},
}
result = JSONSchema(example,
metaschema_uri=metaschema_uri_2020_12).evaluate(
JSON(""))
assert result.children["contentSchema"].annotations[
"contentSchema"].value == example["contentSchema"]
del example["contentMediaType"]
result = JSONSchema(example,
metaschema_uri=metaschema_uri_2020_12).evaluate(
JSON(""))
assert "contentSchema" not in result.children
def test_uri(ptr: str, uri: str, canonical: bool):
rootschema = JSONSchema(id_example, metaschema_uri=metaschema_uri_2020_12)
schema: JSONSchema = JSONPointer.parse_uri_fragment(
ptr[1:]).evaluate(rootschema)
assert schema == Catalogue.get_schema(uri := URI(uri))
if canonical:
# 'canonical' is as per the JSON Schema spec; however, we skip testing of
# anchored URIs since we have only one way to calculate a schema's canonical URI
if (fragment := uri.fragment) and not fragment.startswith('/'):
return
if fragment:
# allow chars in the RFC3986 'sub-delims' set in the 'safe' arg,
# since these are allowed by the 'fragment' definition; in particular,
# this means we don't percent encode '$'
uri = uri.copy(
fragment=urllib.parse.quote(fragment, safe="/!$&'()*+,;="))
else:
# remove empty fragment
uri = uri.copy(fragment=False)
assert schema.canonical_uri == uri
def test_validate_schema(benchmark, value):
schema = JSONSchema(value, metaschema_uri=metaschema_uri_2020_12)
benchmark(schema.validate)
def test_evaluate_json(benchmark, request, value):
json = JSON(value)
schema = JSONSchema(example_schema, metaschema_uri=metaschema_uri_2020_12)
scope = benchmark(schema.evaluate, json)
assert scope.valid is (True if '[valid]' in request.node.name else False)
def test_invalid_schema(example):
schema = JSONSchema(example, metaschema_uri=metaschema_uri_2020_12)
with pytest.raises(JSONSchemaError):
schema.validate()
def test_recursive_schema_extension_2020_12():
tree_schema = JSONSchema(tree_2020_12)
strict_tree_schema = JSONSchema(strict_tree_2020_12)
tree_json = JSON(tree_instance_2020_12)
assert tree_schema.evaluate(tree_json).valid is True
assert strict_tree_schema.evaluate(tree_json).valid is False
def test_base_uri(ptr: str, base_uri: str):
rootschema = JSONSchema(id_example, metaschema_uri=metaschema_uri_2020_12)
schema: JSONSchema = JSONPointer.parse_uri_fragment(
ptr[1:]).evaluate(rootschema)
assert schema.base_uri == URI(base_uri)
try:
assert keyword_list.index(dependency) < keyword_list.index(
dependent)
except ValueError:
pass
@given(interdependent_keywords)
def test_keyword_dependency_resolution_2019_09(value: list):
metaschema = Catalogue.get_schema(metaschema_uri_2019_09)
kwclasses = {
key: kwclass
for key in value if (kwclass := metaschema.kwclasses.get(key))
}
keywords = [
kwclass.key for kwclass in JSONSchema._resolve_dependencies(kwclasses)
]
assert_keyword_order(keywords, [
("properties", "additionalProperties"),
("properties", "unevaluatedProperties"),
("patternProperties", "additionalProperties"),
("patternProperties", "unevaluatedProperties"),
("additionalProperties", "unevaluatedProperties"),
("items", "additionalItems"),
("items", "unevaluatedItems"),
("additionalItems", "unevaluatedItems"),
("contains", "maxContains"),
("contains", "minContains"),
("maxContains", "minContains"),
("if", "then"),
("if", "else"),
def evaluate(format_attr, instval, assert_=True):
FormatKeyword(schema := JSONSchema(True),
format_attr).evaluate(JSON(instval), scope := Scope(schema))
assert scope.annotations["format"].value == format_attr
assert scope._assert is assert_
return scope.valid
def test_validate(metaschema_uri, schema, data, valid):
json_schema = JSONSchema(schema, metaschema_uri=metaschema_uri)
json_data = JSON(data)
json_evaluator = JSONEvaluator(json_schema)
result = json_evaluator.evaluate_instance(json_data)
assert result['valid'] is valid
def get_validity(metadata: dict[str, Any], schema: JSONSchema) -> Any:
if (result := schema.evaluate(JSON(metadata))).valid:
return result.output('flag')
def example_schema_uri():
schema = JSONSchema(example_schema, metaschema_uri=metaschema_uri_2020_12)
return schema.uri
def evaluate(kwclass, kwvalue, instval):
schema = JSONSchema(True)
kwclass(schema, kwvalue).evaluate(JSON(instval), scope := Scope(schema))
return scope.valid
