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