def test_it_resolves_local_refs_with_id(self):
schema = {"id": "foo://bar/schema#", "a": {"foo": "bar"}}
resolver = RefResolver.from_schema(schema)
with resolver.resolving("#/a") as resolved:
self.assertEqual(resolved, schema["a"])
with resolver.resolving("foo://bar/schema#/a") as resolved:
self.assertEqual(resolved, schema["a"])
def test_it_can_construct_a_base_uri_from_a_schema_without_id(self):
schema = {}
resolver = RefResolver.from_schema(schema)
self.assertEqual(resolver.base_uri, "")
with resolver.resolving("") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("#") as resolved:
self.assertEqual(resolved, schema)
def __init__(self, name, schema):
self.name = name
self.base_uri = schema.get('id', '')
# replace all relative references with absolute refs to avoid
# clashes in self.definitions
self.schema = Reference.replace_relative_references(self.base_uri, schema)
# maps full jsonschema fragment path to internal structure,
# for example a StructDef or a TypeDef.
self.definitions = {}
self.refresolver = RefResolver.from_schema(schema)
def test_it_can_construct_a_base_uri_from_a_schema(self):
schema = {"id": "foo"}
resolver = RefResolver.from_schema(schema)
self.assertEqual(resolver.base_uri, "foo")
with resolver.resolving("") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("#") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("foo") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("foo#") as resolved:
self.assertEqual(resolved, schema)
def test_it_can_construct_a_base_uri_from_a_schema(self):
schema = {"id": "foo"}
resolver = RefResolver.from_schema(schema)
self.assertEqual(resolver.base_uri, "foo")
self.assertEqual(resolver.resolution_scope, "foo")
with resolver.resolving("") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("#") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("foo") as resolved:
self.assertEqual(resolved, schema)
with resolver.resolving("foo#") as resolved:
self.assertEqual(resolved, schema)
def _iter_value_errors(self, schema, value):
resolver = RefResolver.from_schema(schema)
validator = Draft4ExtendedValidatorFactory.from_resolver(resolver)
for err in validator(schema, resolver=resolver).iter_errors(value):
yield err
def __init__(self, url: str):
self._resolver = RefResolver.from_schema(requests.get(url).json())
def validate_schema_value(schema, value, swagger_resolver=None):
# pass resolver to avoid to refetch schema files
if swagger_resolver is None:
swagger_resolver = RefResolver.from_schema(schema)
create_dereffing_validator(swagger_resolver)(
schema, resolver=swagger_resolver).validate(value)
def validate_schema_value(schema, value, swagger_resolver=None):
# pass resolver to avoid to refetch schema files
if swagger_resolver is None:
swagger_resolver = RefResolver.from_schema(schema)
create_dereffing_validator(swagger_resolver)(schema, resolver=swagger_resolver).validate(value)
"<command> <schema.json> <validated.json> [<referenced-schema-01.json> [.. <referenced-schema-n.json>]]"
)
sys.exit(1)
json_schema = sys.argv[1]
json_input = sys.argv[2]
json_referenced_schemas = sys.argv[3:]
with open(json_schema, 'r') as f:
schema_data = f.read()
schema = json.loads(schema_data)
schema_store = {schema['$id']: schema}
with open(json_input, 'r') as f:
input_data = f.read()
input_obj = json.loads(input_data)
if len(json_referenced_schemas) > 0:
for i in json_referenced_schemas:
with open(i, 'r') as f:
current_ref_schema_data = f.read()
current_ref_schema = json.loads(current_ref_schema_data)
schema_store[current_ref_schema['$id']] = current_ref_schema
resolver = RefResolver.from_schema(schema_store[list(schema_store)[0]],
store=schema_store)
validator = Draft202012Validator(schema, resolver,
jsonschema.draft202012_format_checker)
validator.validate(input_obj)
