889 lines
32 KiB
Python
889 lines
32 KiB
Python
from collections import deque
|
|
import json
|
|
|
|
from jsonschema import FormatChecker, ValidationError
|
|
from jsonschema.tests.compat import mock, unittest
|
|
from jsonschema.validators import (
|
|
RefResolutionError, UnknownType, Draft3Validator,
|
|
Draft4Validator, RefResolver, create, extend, validator_for, validate,
|
|
)
|
|
|
|
|
|
class TestCreateAndExtend(unittest.TestCase):
|
|
def setUp(self):
|
|
self.meta_schema = {u"properties" : {u"smelly" : {}}}
|
|
self.smelly = mock.MagicMock()
|
|
self.validators = {u"smelly" : self.smelly}
|
|
self.types = {u"dict" : dict}
|
|
self.Validator = create(
|
|
meta_schema=self.meta_schema,
|
|
validators=self.validators,
|
|
default_types=self.types,
|
|
)
|
|
|
|
self.validator_value = 12
|
|
self.schema = {u"smelly" : self.validator_value}
|
|
self.validator = self.Validator(self.schema)
|
|
|
|
def test_attrs(self):
|
|
self.assertEqual(self.Validator.VALIDATORS, self.validators)
|
|
self.assertEqual(self.Validator.META_SCHEMA, self.meta_schema)
|
|
self.assertEqual(self.Validator.DEFAULT_TYPES, self.types)
|
|
|
|
def test_init(self):
|
|
self.assertEqual(self.validator.schema, self.schema)
|
|
|
|
def test_iter_errors(self):
|
|
instance = "hello"
|
|
|
|
self.smelly.return_value = []
|
|
self.assertEqual(list(self.validator.iter_errors(instance)), [])
|
|
|
|
error = mock.Mock()
|
|
self.smelly.return_value = [error]
|
|
self.assertEqual(list(self.validator.iter_errors(instance)), [error])
|
|
|
|
self.smelly.assert_called_with(
|
|
self.validator, self.validator_value, instance, self.schema,
|
|
)
|
|
|
|
def test_if_a_version_is_provided_it_is_registered(self):
|
|
with mock.patch("jsonschema.validators.validates") as validates:
|
|
validates.side_effect = lambda version : lambda cls : cls
|
|
Validator = create(meta_schema={u"id" : ""}, version="my version")
|
|
validates.assert_called_once_with("my version")
|
|
self.assertEqual(Validator.__name__, "MyVersionValidator")
|
|
|
|
def test_if_a_version_is_not_provided_it_is_not_registered(self):
|
|
with mock.patch("jsonschema.validators.validates") as validates:
|
|
create(meta_schema={u"id" : "id"})
|
|
self.assertFalse(validates.called)
|
|
|
|
def test_extend(self):
|
|
validators = dict(self.Validator.VALIDATORS)
|
|
new = mock.Mock()
|
|
|
|
Extended = extend(self.Validator, validators={u"a new one" : new})
|
|
|
|
validators.update([(u"a new one", new)])
|
|
self.assertEqual(Extended.VALIDATORS, validators)
|
|
self.assertNotIn(u"a new one", self.Validator.VALIDATORS)
|
|
|
|
self.assertEqual(Extended.META_SCHEMA, self.Validator.META_SCHEMA)
|
|
self.assertEqual(Extended.DEFAULT_TYPES, self.Validator.DEFAULT_TYPES)
|
|
|
|
|
|
class TestIterErrors(unittest.TestCase):
|
|
def setUp(self):
|
|
self.validator = Draft3Validator({})
|
|
|
|
def test_iter_errors(self):
|
|
instance = [1, 2]
|
|
schema = {
|
|
u"disallow" : u"array",
|
|
u"enum" : [["a", "b", "c"], ["d", "e", "f"]],
|
|
u"minItems" : 3
|
|
}
|
|
|
|
got = (e.message for e in self.validator.iter_errors(instance, schema))
|
|
expected = [
|
|
"%r is disallowed for [1, 2]" % (schema["disallow"],),
|
|
"[1, 2] is too short",
|
|
"[1, 2] is not one of %r" % (schema["enum"],),
|
|
]
|
|
self.assertEqual(sorted(got), sorted(expected))
|
|
|
|
def test_iter_errors_multiple_failures_one_validator(self):
|
|
instance = {"foo" : 2, "bar" : [1], "baz" : 15, "quux" : "spam"}
|
|
schema = {
|
|
u"properties" : {
|
|
"foo" : {u"type" : "string"},
|
|
"bar" : {u"minItems" : 2},
|
|
"baz" : {u"maximum" : 10, u"enum" : [2, 4, 6, 8]},
|
|
}
|
|
}
|
|
|
|
errors = list(self.validator.iter_errors(instance, schema))
|
|
self.assertEqual(len(errors), 4)
|
|
|
|
|
|
class TestValidationErrorMessages(unittest.TestCase):
|
|
def message_for(self, instance, schema, *args, **kwargs):
|
|
kwargs.setdefault("cls", Draft3Validator)
|
|
with self.assertRaises(ValidationError) as e:
|
|
validate(instance, schema, *args, **kwargs)
|
|
return e.exception.message
|
|
|
|
def test_single_type_failure(self):
|
|
message = self.message_for(instance=1, schema={u"type" : u"string"})
|
|
self.assertEqual(message, "1 is not of type %r" % u"string")
|
|
|
|
def test_single_type_list_failure(self):
|
|
message = self.message_for(instance=1, schema={u"type" : [u"string"]})
|
|
self.assertEqual(message, "1 is not of type %r" % u"string")
|
|
|
|
def test_multiple_type_failure(self):
|
|
types = u"string", u"object"
|
|
message = self.message_for(instance=1, schema={u"type" : list(types)})
|
|
self.assertEqual(message, "1 is not of type %r, %r" % types)
|
|
|
|
def test_object_without_title_type_failure(self):
|
|
type = {u"type" : [{u"minimum" : 3}]}
|
|
message = self.message_for(instance=1, schema={u"type" : [type]})
|
|
self.assertEqual(message, "1 is not of type %r" % (type,))
|
|
|
|
def test_object_with_name_type_failure(self):
|
|
name = "Foo"
|
|
schema = {u"type" : [{u"name" : name, u"minimum" : 3}]}
|
|
message = self.message_for(instance=1, schema=schema)
|
|
self.assertEqual(message, "1 is not of type %r" % (name,))
|
|
|
|
def test_minimum(self):
|
|
message = self.message_for(instance=1, schema={"minimum" : 2})
|
|
self.assertEqual(message, "1 is less than the minimum of 2")
|
|
|
|
def test_maximum(self):
|
|
message = self.message_for(instance=1, schema={"maximum" : 0})
|
|
self.assertEqual(message, "1 is greater than the maximum of 0")
|
|
|
|
def test_dependencies_failure_has_single_element_not_list(self):
|
|
depend, on = "bar", "foo"
|
|
schema = {u"dependencies" : {depend : on}}
|
|
message = self.message_for({"bar" : 2}, schema)
|
|
self.assertEqual(message, "%r is a dependency of %r" % (on, depend))
|
|
|
|
def test_additionalItems_single_failure(self):
|
|
message = self.message_for(
|
|
[2], {u"items" : [], u"additionalItems" : False},
|
|
)
|
|
self.assertIn("(2 was unexpected)", message)
|
|
|
|
def test_additionalItems_multiple_failures(self):
|
|
message = self.message_for(
|
|
[1, 2, 3], {u"items" : [], u"additionalItems" : False}
|
|
)
|
|
self.assertIn("(1, 2, 3 were unexpected)", message)
|
|
|
|
def test_additionalProperties_single_failure(self):
|
|
additional = "foo"
|
|
schema = {u"additionalProperties" : False}
|
|
message = self.message_for({additional : 2}, schema)
|
|
self.assertIn("(%r was unexpected)" % (additional,), message)
|
|
|
|
def test_additionalProperties_multiple_failures(self):
|
|
schema = {u"additionalProperties" : False}
|
|
message = self.message_for(dict.fromkeys(["foo", "bar"]), schema)
|
|
|
|
self.assertIn(repr("foo"), message)
|
|
self.assertIn(repr("bar"), message)
|
|
self.assertIn("were unexpected)", message)
|
|
|
|
def test_invalid_format_default_message(self):
|
|
checker = FormatChecker(formats=())
|
|
check_fn = mock.Mock(return_value=False)
|
|
checker.checks(u"thing")(check_fn)
|
|
|
|
schema = {u"format" : u"thing"}
|
|
message = self.message_for("bla", schema, format_checker=checker)
|
|
|
|
self.assertIn(repr("bla"), message)
|
|
self.assertIn(repr("thing"), message)
|
|
self.assertIn("is not a", message)
|
|
|
|
|
|
class TestValidationErrorDetails(unittest.TestCase):
|
|
# TODO: These really need unit tests for each individual validator, rather
|
|
# than just these higher level tests.
|
|
def test_anyOf(self):
|
|
instance = 5
|
|
schema = {
|
|
"anyOf": [
|
|
{"minimum": 20},
|
|
{"type": "string"}
|
|
]
|
|
}
|
|
|
|
validator = Draft4Validator(schema)
|
|
errors = list(validator.iter_errors(instance))
|
|
self.assertEqual(len(errors), 1)
|
|
e = errors[0]
|
|
|
|
self.assertEqual(e.validator, "anyOf")
|
|
self.assertEqual(e.validator_value, schema["anyOf"])
|
|
self.assertEqual(e.instance, instance)
|
|
self.assertEqual(e.schema, schema)
|
|
self.assertIsNone(e.parent)
|
|
|
|
self.assertEqual(e.path, deque([]))
|
|
self.assertEqual(e.relative_path, deque([]))
|
|
self.assertEqual(e.absolute_path, deque([]))
|
|
|
|
self.assertEqual(e.schema_path, deque(["anyOf"]))
|
|
self.assertEqual(e.relative_schema_path, deque(["anyOf"]))
|
|
self.assertEqual(e.absolute_schema_path, deque(["anyOf"]))
|
|
|
|
self.assertEqual(len(e.context), 2)
|
|
|
|
e1, e2 = sorted_errors(e.context)
|
|
|
|
self.assertEqual(e1.validator, "minimum")
|
|
self.assertEqual(e1.validator_value, schema["anyOf"][0]["minimum"])
|
|
self.assertEqual(e1.instance, instance)
|
|
self.assertEqual(e1.schema, schema["anyOf"][0])
|
|
self.assertIs(e1.parent, e)
|
|
|
|
self.assertEqual(e1.path, deque([]))
|
|
self.assertEqual(e1.absolute_path, deque([]))
|
|
self.assertEqual(e1.relative_path, deque([]))
|
|
|
|
self.assertEqual(e1.schema_path, deque([0, "minimum"]))
|
|
self.assertEqual(e1.relative_schema_path, deque([0, "minimum"]))
|
|
self.assertEqual(
|
|
e1.absolute_schema_path, deque(["anyOf", 0, "minimum"]),
|
|
)
|
|
|
|
self.assertFalse(e1.context)
|
|
|
|
self.assertEqual(e2.validator, "type")
|
|
self.assertEqual(e2.validator_value, schema["anyOf"][1]["type"])
|
|
self.assertEqual(e2.instance, instance)
|
|
self.assertEqual(e2.schema, schema["anyOf"][1])
|
|
self.assertIs(e2.parent, e)
|
|
|
|
self.assertEqual(e2.path, deque([]))
|
|
self.assertEqual(e2.relative_path, deque([]))
|
|
self.assertEqual(e2.absolute_path, deque([]))
|
|
|
|
self.assertEqual(e2.schema_path, deque([1, "type"]))
|
|
self.assertEqual(e2.relative_schema_path, deque([1, "type"]))
|
|
self.assertEqual(e2.absolute_schema_path, deque(["anyOf", 1, "type"]))
|
|
|
|
self.assertEqual(len(e2.context), 0)
|
|
|
|
def test_type(self):
|
|
instance = {"foo": 1}
|
|
schema = {
|
|
"type": [
|
|
{"type": "integer"},
|
|
{
|
|
"type": "object",
|
|
"properties": {
|
|
"foo": {"enum": [2]}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = list(validator.iter_errors(instance))
|
|
self.assertEqual(len(errors), 1)
|
|
e = errors[0]
|
|
|
|
self.assertEqual(e.validator, "type")
|
|
self.assertEqual(e.validator_value, schema["type"])
|
|
self.assertEqual(e.instance, instance)
|
|
self.assertEqual(e.schema, schema)
|
|
self.assertIsNone(e.parent)
|
|
|
|
self.assertEqual(e.path, deque([]))
|
|
self.assertEqual(e.relative_path, deque([]))
|
|
self.assertEqual(e.absolute_path, deque([]))
|
|
|
|
self.assertEqual(e.schema_path, deque(["type"]))
|
|
self.assertEqual(e.relative_schema_path, deque(["type"]))
|
|
self.assertEqual(e.absolute_schema_path, deque(["type"]))
|
|
|
|
self.assertEqual(len(e.context), 2)
|
|
|
|
e1, e2 = sorted_errors(e.context)
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e1.validator_value, schema["type"][0]["type"])
|
|
self.assertEqual(e1.instance, instance)
|
|
self.assertEqual(e1.schema, schema["type"][0])
|
|
self.assertIs(e1.parent, e)
|
|
|
|
self.assertEqual(e1.path, deque([]))
|
|
self.assertEqual(e1.relative_path, deque([]))
|
|
self.assertEqual(e1.absolute_path, deque([]))
|
|
|
|
self.assertEqual(e1.schema_path, deque([0, "type"]))
|
|
self.assertEqual(e1.relative_schema_path, deque([0, "type"]))
|
|
self.assertEqual(e1.absolute_schema_path, deque(["type", 0, "type"]))
|
|
|
|
self.assertFalse(e1.context)
|
|
|
|
self.assertEqual(e2.validator, "enum")
|
|
self.assertEqual(e2.validator_value, [2])
|
|
self.assertEqual(e2.instance, 1)
|
|
self.assertEqual(e2.schema, {u"enum" : [2]})
|
|
self.assertIs(e2.parent, e)
|
|
|
|
self.assertEqual(e2.path, deque(["foo"]))
|
|
self.assertEqual(e2.relative_path, deque(["foo"]))
|
|
self.assertEqual(e2.absolute_path, deque(["foo"]))
|
|
|
|
self.assertEqual(
|
|
e2.schema_path, deque([1, "properties", "foo", "enum"]),
|
|
)
|
|
self.assertEqual(
|
|
e2.relative_schema_path, deque([1, "properties", "foo", "enum"]),
|
|
)
|
|
self.assertEqual(
|
|
e2.absolute_schema_path,
|
|
deque(["type", 1, "properties", "foo", "enum"]),
|
|
)
|
|
|
|
self.assertFalse(e2.context)
|
|
|
|
def test_single_nesting(self):
|
|
instance = {"foo" : 2, "bar" : [1], "baz" : 15, "quux" : "spam"}
|
|
schema = {
|
|
"properties" : {
|
|
"foo" : {"type" : "string"},
|
|
"bar" : {"minItems" : 2},
|
|
"baz" : {"maximum" : 10, "enum" : [2, 4, 6, 8]},
|
|
}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2, e3, e4 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque(["bar"]))
|
|
self.assertEqual(e2.path, deque(["baz"]))
|
|
self.assertEqual(e3.path, deque(["baz"]))
|
|
self.assertEqual(e4.path, deque(["foo"]))
|
|
|
|
self.assertEqual(e1.relative_path, deque(["bar"]))
|
|
self.assertEqual(e2.relative_path, deque(["baz"]))
|
|
self.assertEqual(e3.relative_path, deque(["baz"]))
|
|
self.assertEqual(e4.relative_path, deque(["foo"]))
|
|
|
|
self.assertEqual(e1.absolute_path, deque(["bar"]))
|
|
self.assertEqual(e2.absolute_path, deque(["baz"]))
|
|
self.assertEqual(e3.absolute_path, deque(["baz"]))
|
|
self.assertEqual(e4.absolute_path, deque(["foo"]))
|
|
|
|
self.assertEqual(e1.validator, "minItems")
|
|
self.assertEqual(e2.validator, "enum")
|
|
self.assertEqual(e3.validator, "maximum")
|
|
self.assertEqual(e4.validator, "type")
|
|
|
|
def test_multiple_nesting(self):
|
|
instance = [1, {"foo" : 2, "bar" : {"baz" : [1]}}, "quux"]
|
|
schema = {
|
|
"type" : "string",
|
|
"items" : {
|
|
"type" : ["string", "object"],
|
|
"properties" : {
|
|
"foo" : {"enum" : [1, 3]},
|
|
"bar" : {
|
|
"type" : "array",
|
|
"properties" : {
|
|
"bar" : {"required" : True},
|
|
"baz" : {"minItems" : 2},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2, e3, e4, e5, e6 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque([]))
|
|
self.assertEqual(e2.path, deque([0]))
|
|
self.assertEqual(e3.path, deque([1, "bar"]))
|
|
self.assertEqual(e4.path, deque([1, "bar", "bar"]))
|
|
self.assertEqual(e5.path, deque([1, "bar", "baz"]))
|
|
self.assertEqual(e6.path, deque([1, "foo"]))
|
|
|
|
self.assertEqual(e1.schema_path, deque(["type"]))
|
|
self.assertEqual(e2.schema_path, deque(["items", "type"]))
|
|
self.assertEqual(
|
|
list(e3.schema_path), ["items", "properties", "bar", "type"],
|
|
)
|
|
self.assertEqual(
|
|
list(e4.schema_path),
|
|
["items", "properties", "bar", "properties", "bar", "required"],
|
|
)
|
|
self.assertEqual(
|
|
list(e5.schema_path),
|
|
["items", "properties", "bar", "properties", "baz", "minItems"]
|
|
)
|
|
self.assertEqual(
|
|
list(e6.schema_path), ["items", "properties", "foo", "enum"],
|
|
)
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e2.validator, "type")
|
|
self.assertEqual(e3.validator, "type")
|
|
self.assertEqual(e4.validator, "required")
|
|
self.assertEqual(e5.validator, "minItems")
|
|
self.assertEqual(e6.validator, "enum")
|
|
|
|
def test_recursive(self):
|
|
schema = {
|
|
"definitions": {
|
|
"node": {
|
|
"anyOf": [{
|
|
"type": "object",
|
|
"required": ["name", "children"],
|
|
"properties": {
|
|
"name": {
|
|
"type": "string",
|
|
},
|
|
"children": {
|
|
"type": "object",
|
|
"patternProperties": {
|
|
"^.*$": {
|
|
"$ref": "#/definitions/node",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}],
|
|
},
|
|
},
|
|
"type": "object",
|
|
"required": ["root"],
|
|
"properties": {
|
|
"root": {"$ref": "#/definitions/node"},
|
|
}
|
|
}
|
|
|
|
instance = {
|
|
"root": {
|
|
"name": "root",
|
|
"children": {
|
|
"a": {
|
|
"name": "a",
|
|
"children": {
|
|
"ab": {
|
|
"name": "ab",
|
|
# missing "children"
|
|
}
|
|
}
|
|
},
|
|
},
|
|
},
|
|
}
|
|
validator = Draft4Validator(schema)
|
|
|
|
e, = validator.iter_errors(instance)
|
|
self.assertEqual(e.absolute_path, deque(["root"]))
|
|
self.assertEqual(
|
|
e.absolute_schema_path, deque(["properties", "root", "anyOf"]),
|
|
)
|
|
|
|
e1, = e.context
|
|
self.assertEqual(e1.absolute_path, deque(["root", "children", "a"]))
|
|
self.assertEqual(
|
|
e1.absolute_schema_path, deque(
|
|
[
|
|
"properties",
|
|
"root",
|
|
"anyOf",
|
|
0,
|
|
"properties",
|
|
"children",
|
|
"patternProperties",
|
|
"^.*$",
|
|
"anyOf",
|
|
],
|
|
),
|
|
)
|
|
|
|
e2, = e1.context
|
|
self.assertEqual(
|
|
e2.absolute_path, deque(
|
|
["root", "children", "a", "children", "ab"],
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
e2.absolute_schema_path, deque(
|
|
[
|
|
"properties",
|
|
"root",
|
|
"anyOf",
|
|
0,
|
|
"properties",
|
|
"children",
|
|
"patternProperties",
|
|
"^.*$",
|
|
"anyOf",
|
|
0,
|
|
"properties",
|
|
"children",
|
|
"patternProperties",
|
|
"^.*$",
|
|
"anyOf"
|
|
],
|
|
),
|
|
)
|
|
|
|
def test_additionalProperties(self):
|
|
instance = {"bar": "bar", "foo": 2}
|
|
schema = {
|
|
"additionalProperties" : {"type": "integer", "minimum": 5}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque(["bar"]))
|
|
self.assertEqual(e2.path, deque(["foo"]))
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e2.validator, "minimum")
|
|
|
|
def test_patternProperties(self):
|
|
instance = {"bar": 1, "foo": 2}
|
|
schema = {
|
|
"patternProperties" : {
|
|
"bar": {"type": "string"},
|
|
"foo": {"minimum": 5}
|
|
}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque(["bar"]))
|
|
self.assertEqual(e2.path, deque(["foo"]))
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e2.validator, "minimum")
|
|
|
|
def test_additionalItems(self):
|
|
instance = ["foo", 1]
|
|
schema = {
|
|
"items": [],
|
|
"additionalItems" : {"type": "integer", "minimum": 5}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque([0]))
|
|
self.assertEqual(e2.path, deque([1]))
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e2.validator, "minimum")
|
|
|
|
def test_additionalItems_with_items(self):
|
|
instance = ["foo", "bar", 1]
|
|
schema = {
|
|
"items": [{}],
|
|
"additionalItems" : {"type": "integer", "minimum": 5}
|
|
}
|
|
|
|
validator = Draft3Validator(schema)
|
|
errors = validator.iter_errors(instance)
|
|
e1, e2 = sorted_errors(errors)
|
|
|
|
self.assertEqual(e1.path, deque([1]))
|
|
self.assertEqual(e2.path, deque([2]))
|
|
|
|
self.assertEqual(e1.validator, "type")
|
|
self.assertEqual(e2.validator, "minimum")
|
|
|
|
|
|
class ValidatorTestMixin(object):
|
|
def setUp(self):
|
|
self.instance = mock.Mock()
|
|
self.schema = {}
|
|
self.resolver = mock.Mock()
|
|
self.validator = self.validator_class(self.schema)
|
|
|
|
def test_valid_instances_are_valid(self):
|
|
errors = iter([])
|
|
|
|
with mock.patch.object(
|
|
self.validator, "iter_errors", return_value=errors,
|
|
):
|
|
self.assertTrue(
|
|
self.validator.is_valid(self.instance, self.schema)
|
|
)
|
|
|
|
def test_invalid_instances_are_not_valid(self):
|
|
errors = iter([mock.Mock()])
|
|
|
|
with mock.patch.object(
|
|
self.validator, "iter_errors", return_value=errors,
|
|
):
|
|
self.assertFalse(
|
|
self.validator.is_valid(self.instance, self.schema)
|
|
)
|
|
|
|
def test_non_existent_properties_are_ignored(self):
|
|
instance, my_property, my_value = mock.Mock(), mock.Mock(), mock.Mock()
|
|
validate(instance=instance, schema={my_property : my_value})
|
|
|
|
def test_it_creates_a_ref_resolver_if_not_provided(self):
|
|
self.assertIsInstance(self.validator.resolver, RefResolver)
|
|
|
|
def test_it_delegates_to_a_ref_resolver(self):
|
|
resolver = RefResolver("", {})
|
|
schema = {"$ref" : mock.Mock()}
|
|
|
|
with mock.patch.object(resolver, "resolve") as resolve:
|
|
resolve.return_value = "url", {"type": "integer"}
|
|
with self.assertRaises(ValidationError):
|
|
self.validator_class(schema, resolver=resolver).validate(None)
|
|
|
|
resolve.assert_called_once_with(schema["$ref"])
|
|
|
|
def test_is_type_is_true_for_valid_type(self):
|
|
self.assertTrue(self.validator.is_type("foo", "string"))
|
|
|
|
def test_is_type_is_false_for_invalid_type(self):
|
|
self.assertFalse(self.validator.is_type("foo", "array"))
|
|
|
|
def test_is_type_evades_bool_inheriting_from_int(self):
|
|
self.assertFalse(self.validator.is_type(True, "integer"))
|
|
self.assertFalse(self.validator.is_type(True, "number"))
|
|
|
|
def test_is_type_raises_exception_for_unknown_type(self):
|
|
with self.assertRaises(UnknownType):
|
|
self.validator.is_type("foo", object())
|
|
|
|
|
|
class TestDraft3Validator(ValidatorTestMixin, unittest.TestCase):
|
|
validator_class = Draft3Validator
|
|
|
|
def test_is_type_is_true_for_any_type(self):
|
|
self.assertTrue(self.validator.is_valid(mock.Mock(), {"type": "any"}))
|
|
|
|
def test_is_type_does_not_evade_bool_if_it_is_being_tested(self):
|
|
self.assertTrue(self.validator.is_type(True, "boolean"))
|
|
self.assertTrue(self.validator.is_valid(True, {"type": "any"}))
|
|
|
|
def test_non_string_custom_types(self):
|
|
schema = {'type': [None]}
|
|
cls = self.validator_class(schema, types={None: type(None)})
|
|
cls.validate(None, schema)
|
|
|
|
|
|
class TestDraft4Validator(ValidatorTestMixin, unittest.TestCase):
|
|
validator_class = Draft4Validator
|
|
|
|
|
|
class TestBuiltinFormats(unittest.TestCase):
|
|
"""
|
|
The built-in (specification-defined) formats do not raise type errors.
|
|
|
|
If an instance or value is not a string, it should be ignored.
|
|
|
|
"""
|
|
|
|
|
|
for format in FormatChecker.checkers:
|
|
def test(self, format=format):
|
|
v = Draft4Validator({"format": format}, format_checker=FormatChecker())
|
|
v.validate(123)
|
|
|
|
name = "test_{0}_ignores_non_strings".format(format)
|
|
test.__name__ = name
|
|
setattr(TestBuiltinFormats, name, test)
|
|
del test # Ugh py.test. Stop discovering top level tests.
|
|
|
|
|
|
class TestValidatorFor(unittest.TestCase):
|
|
def test_draft_3(self):
|
|
schema = {"$schema" : "http://json-schema.org/draft-03/schema"}
|
|
self.assertIs(validator_for(schema), Draft3Validator)
|
|
|
|
schema = {"$schema" : "http://json-schema.org/draft-03/schema#"}
|
|
self.assertIs(validator_for(schema), Draft3Validator)
|
|
|
|
def test_draft_4(self):
|
|
schema = {"$schema" : "http://json-schema.org/draft-04/schema"}
|
|
self.assertIs(validator_for(schema), Draft4Validator)
|
|
|
|
schema = {"$schema" : "http://json-schema.org/draft-04/schema#"}
|
|
self.assertIs(validator_for(schema), Draft4Validator)
|
|
|
|
def test_custom_validator(self):
|
|
Validator = create(meta_schema={"id" : "meta schema id"}, version="12")
|
|
schema = {"$schema" : "meta schema id"}
|
|
self.assertIs(validator_for(schema), Validator)
|
|
|
|
def test_validator_for_jsonschema_default(self):
|
|
self.assertIs(validator_for({}), Draft4Validator)
|
|
|
|
def test_validator_for_custom_default(self):
|
|
self.assertIs(validator_for({}, default=None), None)
|
|
|
|
|
|
class TestValidate(unittest.TestCase):
|
|
def test_draft3_validator_is_chosen(self):
|
|
schema = {"$schema" : "http://json-schema.org/draft-03/schema#"}
|
|
with mock.patch.object(Draft3Validator, "check_schema") as chk_schema:
|
|
validate({}, schema)
|
|
chk_schema.assert_called_once_with(schema)
|
|
# Make sure it works without the empty fragment
|
|
schema = {"$schema" : "http://json-schema.org/draft-03/schema"}
|
|
with mock.patch.object(Draft3Validator, "check_schema") as chk_schema:
|
|
validate({}, schema)
|
|
chk_schema.assert_called_once_with(schema)
|
|
|
|
def test_draft4_validator_is_chosen(self):
|
|
schema = {"$schema" : "http://json-schema.org/draft-04/schema#"}
|
|
with mock.patch.object(Draft4Validator, "check_schema") as chk_schema:
|
|
validate({}, schema)
|
|
chk_schema.assert_called_once_with(schema)
|
|
|
|
def test_draft4_validator_is_the_default(self):
|
|
with mock.patch.object(Draft4Validator, "check_schema") as chk_schema:
|
|
validate({}, {})
|
|
chk_schema.assert_called_once_with({})
|
|
|
|
|
|
class TestRefResolver(unittest.TestCase):
|
|
|
|
base_uri = ""
|
|
stored_uri = "foo://stored"
|
|
stored_schema = {"stored" : "schema"}
|
|
|
|
def setUp(self):
|
|
self.referrer = {}
|
|
self.store = {self.stored_uri : self.stored_schema}
|
|
self.resolver = RefResolver(self.base_uri, self.referrer, self.store)
|
|
|
|
def test_it_does_not_retrieve_schema_urls_from_the_network(self):
|
|
ref = Draft3Validator.META_SCHEMA["id"]
|
|
with mock.patch.object(self.resolver, "resolve_remote") as remote:
|
|
with self.resolver.resolving(ref) as resolved:
|
|
self.assertEqual(resolved, Draft3Validator.META_SCHEMA)
|
|
self.assertFalse(remote.called)
|
|
|
|
def test_it_resolves_local_refs(self):
|
|
ref = "#/properties/foo"
|
|
self.referrer["properties"] = {"foo" : object()}
|
|
with self.resolver.resolving(ref) as resolved:
|
|
self.assertEqual(resolved, self.referrer["properties"]["foo"])
|
|
|
|
def test_it_resolves_local_refs_with_id(self):
|
|
schema = {"id": "http://bar/schema#", "a": {"foo": "bar"}}
|
|
resolver = RefResolver.from_schema(schema)
|
|
with resolver.resolving("#/a") as resolved:
|
|
self.assertEqual(resolved, schema["a"])
|
|
with resolver.resolving("http://bar/schema#/a") as resolved:
|
|
self.assertEqual(resolved, schema["a"])
|
|
|
|
def test_it_retrieves_stored_refs(self):
|
|
with self.resolver.resolving(self.stored_uri) as resolved:
|
|
self.assertIs(resolved, self.stored_schema)
|
|
|
|
self.resolver.store["cached_ref"] = {"foo" : 12}
|
|
with self.resolver.resolving("cached_ref#/foo") as resolved:
|
|
self.assertEqual(resolved, 12)
|
|
|
|
def test_it_retrieves_unstored_refs_via_requests(self):
|
|
ref = "http://bar#baz"
|
|
schema = {"baz" : 12}
|
|
|
|
with mock.patch("jsonschema.validators.requests") as requests:
|
|
requests.get.return_value.json.return_value = schema
|
|
with self.resolver.resolving(ref) as resolved:
|
|
self.assertEqual(resolved, 12)
|
|
requests.get.assert_called_once_with("http://bar")
|
|
|
|
def test_it_retrieves_unstored_refs_via_urlopen(self):
|
|
ref = "http://bar#baz"
|
|
schema = {"baz" : 12}
|
|
|
|
with mock.patch("jsonschema.validators.requests", None):
|
|
with mock.patch("jsonschema.validators.urlopen") as urlopen:
|
|
urlopen.return_value.read.return_value = (
|
|
json.dumps(schema).encode("utf8"))
|
|
with self.resolver.resolving(ref) as resolved:
|
|
self.assertEqual(resolved, 12)
|
|
urlopen.assert_called_once_with("http://bar")
|
|
|
|
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 test_it_can_construct_a_base_uri_from_a_schema_without_id(self):
|
|
schema = {}
|
|
resolver = RefResolver.from_schema(schema)
|
|
self.assertEqual(resolver.base_uri, "")
|
|
self.assertEqual(resolver.resolution_scope, "")
|
|
with resolver.resolving("") as resolved:
|
|
self.assertEqual(resolved, schema)
|
|
with resolver.resolving("#") as resolved:
|
|
self.assertEqual(resolved, schema)
|
|
|
|
def test_custom_uri_scheme_handlers(self):
|
|
schema = {"foo": "bar"}
|
|
ref = "foo://bar"
|
|
foo_handler = mock.Mock(return_value=schema)
|
|
resolver = RefResolver("", {}, handlers={"foo": foo_handler})
|
|
with resolver.resolving(ref) as resolved:
|
|
self.assertEqual(resolved, schema)
|
|
foo_handler.assert_called_once_with(ref)
|
|
|
|
def test_cache_remote_on(self):
|
|
ref = "foo://bar"
|
|
foo_handler = mock.Mock()
|
|
resolver = RefResolver(
|
|
"", {}, cache_remote=True, handlers={"foo" : foo_handler},
|
|
)
|
|
with resolver.resolving(ref):
|
|
pass
|
|
with resolver.resolving(ref):
|
|
pass
|
|
foo_handler.assert_called_once_with(ref)
|
|
|
|
def test_cache_remote_off(self):
|
|
ref = "foo://bar"
|
|
foo_handler = mock.Mock()
|
|
resolver = RefResolver(
|
|
"", {}, cache_remote=False, handlers={"foo" : foo_handler},
|
|
)
|
|
with resolver.resolving(ref):
|
|
pass
|
|
self.assertEqual(foo_handler.call_count, 1)
|
|
|
|
def test_if_you_give_it_junk_you_get_a_resolution_error(self):
|
|
ref = "foo://bar"
|
|
foo_handler = mock.Mock(side_effect=ValueError("Oh no! What's this?"))
|
|
resolver = RefResolver("", {}, handlers={"foo" : foo_handler})
|
|
with self.assertRaises(RefResolutionError) as err:
|
|
with resolver.resolving(ref):
|
|
pass
|
|
self.assertEqual(str(err.exception), "Oh no! What's this?")
|
|
|
|
def test_helpful_error_message_on_failed_pop_scope(self):
|
|
resolver = RefResolver("", {})
|
|
resolver.pop_scope()
|
|
with self.assertRaises(RefResolutionError) as exc:
|
|
resolver.pop_scope()
|
|
self.assertIn("Failed to pop the scope", str(exc.exception))
|
|
|
|
|
|
def sorted_errors(errors):
|
|
def key(error):
|
|
return (
|
|
[str(e) for e in error.path],
|
|
[str(e) for e in error.schema_path]
|
|
)
|
|
return sorted(errors, key=key)
|