| from unittest import TestCase |
| import textwrap |
|
|
| from jsonschema import exceptions |
| from jsonschema.validators import _LATEST_VERSION |
|
|
|
|
| class TestBestMatch(TestCase): |
| def best_match_of(self, instance, schema): |
| errors = list(_LATEST_VERSION(schema).iter_errors(instance)) |
| msg = f"No errors found for {instance} under {schema!r}!" |
| self.assertTrue(errors, msg=msg) |
|
|
| best = exceptions.best_match(iter(errors)) |
| reversed_best = exceptions.best_match(reversed(errors)) |
|
|
| self.assertEqual( |
| best._contents(), |
| reversed_best._contents(), |
| f"No consistent best match!\nGot: {best}\n\nThen: {reversed_best}", |
| ) |
| return best |
|
|
| def test_shallower_errors_are_better_matches(self): |
| schema = { |
| "properties": { |
| "foo": { |
| "minProperties": 2, |
| "properties": {"bar": {"type": "object"}}, |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": {"bar": []}}, schema=schema) |
| self.assertEqual(best.validator, "minProperties") |
|
|
| def test_oneOf_and_anyOf_are_weak_matches(self): |
| """ |
| A property you *must* match is probably better than one you have to |
| match a part of. |
| """ |
|
|
| schema = { |
| "minProperties": 2, |
| "anyOf": [{"type": "string"}, {"type": "number"}], |
| "oneOf": [{"type": "string"}, {"type": "number"}], |
| } |
| best = self.best_match_of(instance={}, schema=schema) |
| self.assertEqual(best.validator, "minProperties") |
|
|
| def test_if_the_most_relevant_error_is_anyOf_it_is_traversed(self): |
| """ |
| If the most relevant error is an anyOf, then we traverse its context |
| and select the otherwise *least* relevant error, since in this case |
| that means the most specific, deep, error inside the instance. |
| |
| I.e. since only one of the schemas must match, we look for the most |
| relevant one. |
| """ |
|
|
| schema = { |
| "properties": { |
| "foo": { |
| "anyOf": [ |
| {"type": "string"}, |
| {"properties": {"bar": {"type": "array"}}}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) |
| self.assertEqual(best.validator_value, "array") |
|
|
| def test_no_anyOf_traversal_for_equally_relevant_errors(self): |
| """ |
| We don't traverse into an anyOf (as above) if all of its context errors |
| seem to be equally "wrong" against the instance. |
| """ |
|
|
| schema = { |
| "anyOf": [ |
| {"type": "string"}, |
| {"type": "integer"}, |
| {"type": "object"}, |
| ], |
| } |
| best = self.best_match_of(instance=[], schema=schema) |
| self.assertEqual(best.validator, "anyOf") |
|
|
| def test_anyOf_traversal_for_single_equally_relevant_error(self): |
| """ |
| We *do* traverse anyOf with a single nested error, even though it is |
| vacuously equally relevant to itself. |
| """ |
|
|
| schema = { |
| "anyOf": [ |
| {"type": "string"}, |
| ], |
| } |
| best = self.best_match_of(instance=[], schema=schema) |
| self.assertEqual(best.validator, "type") |
|
|
| def test_anyOf_traversal_for_single_sibling_errors(self): |
| """ |
| We *do* traverse anyOf with a single subschema that fails multiple |
| times (e.g. on multiple items). |
| """ |
|
|
| schema = { |
| "anyOf": [ |
| {"items": {"const": 37}}, |
| ], |
| } |
| best = self.best_match_of(instance=[12, 12], schema=schema) |
| self.assertEqual(best.validator, "const") |
|
|
| def test_anyOf_traversal_for_non_type_matching_sibling_errors(self): |
| """ |
| We *do* traverse anyOf with multiple subschemas when one does not type |
| match. |
| """ |
|
|
| schema = { |
| "anyOf": [ |
| {"type": "object"}, |
| {"items": {"const": 37}}, |
| ], |
| } |
| best = self.best_match_of(instance=[12, 12], schema=schema) |
| self.assertEqual(best.validator, "const") |
|
|
| def test_if_the_most_relevant_error_is_oneOf_it_is_traversed(self): |
| """ |
| If the most relevant error is an oneOf, then we traverse its context |
| and select the otherwise *least* relevant error, since in this case |
| that means the most specific, deep, error inside the instance. |
| |
| I.e. since only one of the schemas must match, we look for the most |
| relevant one. |
| """ |
|
|
| schema = { |
| "properties": { |
| "foo": { |
| "oneOf": [ |
| {"type": "string"}, |
| {"properties": {"bar": {"type": "array"}}}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) |
| self.assertEqual(best.validator_value, "array") |
|
|
| def test_no_oneOf_traversal_for_equally_relevant_errors(self): |
| """ |
| We don't traverse into an oneOf (as above) if all of its context errors |
| seem to be equally "wrong" against the instance. |
| """ |
|
|
| schema = { |
| "oneOf": [ |
| {"type": "string"}, |
| {"type": "integer"}, |
| {"type": "object"}, |
| ], |
| } |
| best = self.best_match_of(instance=[], schema=schema) |
| self.assertEqual(best.validator, "oneOf") |
|
|
| def test_oneOf_traversal_for_single_equally_relevant_error(self): |
| """ |
| We *do* traverse oneOf with a single nested error, even though it is |
| vacuously equally relevant to itself. |
| """ |
|
|
| schema = { |
| "oneOf": [ |
| {"type": "string"}, |
| ], |
| } |
| best = self.best_match_of(instance=[], schema=schema) |
| self.assertEqual(best.validator, "type") |
|
|
| def test_oneOf_traversal_for_single_sibling_errors(self): |
| """ |
| We *do* traverse oneOf with a single subschema that fails multiple |
| times (e.g. on multiple items). |
| """ |
|
|
| schema = { |
| "oneOf": [ |
| {"items": {"const": 37}}, |
| ], |
| } |
| best = self.best_match_of(instance=[12, 12], schema=schema) |
| self.assertEqual(best.validator, "const") |
|
|
| def test_oneOf_traversal_for_non_type_matching_sibling_errors(self): |
| """ |
| We *do* traverse oneOf with multiple subschemas when one does not type |
| match. |
| """ |
|
|
| schema = { |
| "oneOf": [ |
| {"type": "object"}, |
| {"items": {"const": 37}}, |
| ], |
| } |
| best = self.best_match_of(instance=[12, 12], schema=schema) |
| self.assertEqual(best.validator, "const") |
|
|
| def test_if_the_most_relevant_error_is_allOf_it_is_traversed(self): |
| """ |
| Now, if the error is allOf, we traverse but select the *most* relevant |
| error from the context, because all schemas here must match anyways. |
| """ |
|
|
| schema = { |
| "properties": { |
| "foo": { |
| "allOf": [ |
| {"type": "string"}, |
| {"properties": {"bar": {"type": "array"}}}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) |
| self.assertEqual(best.validator_value, "string") |
|
|
| def test_nested_context_for_oneOf(self): |
| """ |
| We traverse into nested contexts (a oneOf containing an error in a |
| nested oneOf here). |
| """ |
|
|
| schema = { |
| "properties": { |
| "foo": { |
| "oneOf": [ |
| {"type": "string"}, |
| { |
| "oneOf": [ |
| {"type": "string"}, |
| { |
| "properties": { |
| "bar": {"type": "array"}, |
| }, |
| }, |
| ], |
| }, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": {"bar": 12}}, schema=schema) |
| self.assertEqual(best.validator_value, "array") |
|
|
| def test_it_prioritizes_matching_types(self): |
| schema = { |
| "properties": { |
| "foo": { |
| "anyOf": [ |
| {"type": "array", "minItems": 2}, |
| {"type": "string", "minLength": 10}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": "bar"}, schema=schema) |
| self.assertEqual(best.validator, "minLength") |
|
|
| reordered = { |
| "properties": { |
| "foo": { |
| "anyOf": [ |
| {"type": "string", "minLength": 10}, |
| {"type": "array", "minItems": 2}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": "bar"}, schema=reordered) |
| self.assertEqual(best.validator, "minLength") |
|
|
| def test_it_prioritizes_matching_union_types(self): |
| schema = { |
| "properties": { |
| "foo": { |
| "anyOf": [ |
| {"type": ["array", "object"], "minItems": 2}, |
| {"type": ["integer", "string"], "minLength": 10}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": "bar"}, schema=schema) |
| self.assertEqual(best.validator, "minLength") |
|
|
| reordered = { |
| "properties": { |
| "foo": { |
| "anyOf": [ |
| {"type": "string", "minLength": 10}, |
| {"type": "array", "minItems": 2}, |
| ], |
| }, |
| }, |
| } |
| best = self.best_match_of(instance={"foo": "bar"}, schema=reordered) |
| self.assertEqual(best.validator, "minLength") |
|
|
| def test_boolean_schemas(self): |
| schema = {"properties": {"foo": False}} |
| best = self.best_match_of(instance={"foo": "bar"}, schema=schema) |
| self.assertIsNone(best.validator) |
|
|
| def test_one_error(self): |
| validator = _LATEST_VERSION({"minProperties": 2}) |
| error, = validator.iter_errors({}) |
| self.assertEqual( |
| exceptions.best_match(validator.iter_errors({})).validator, |
| "minProperties", |
| ) |
|
|
| def test_no_errors(self): |
| validator = _LATEST_VERSION({}) |
| self.assertIsNone(exceptions.best_match(validator.iter_errors({}))) |
|
|
|
|
| class TestByRelevance(TestCase): |
| def test_short_paths_are_better_matches(self): |
| shallow = exceptions.ValidationError("Oh no!", path=["baz"]) |
| deep = exceptions.ValidationError("Oh yes!", path=["foo", "bar"]) |
| match = max([shallow, deep], key=exceptions.relevance) |
| self.assertIs(match, shallow) |
|
|
| match = max([deep, shallow], key=exceptions.relevance) |
| self.assertIs(match, shallow) |
|
|
| def test_global_errors_are_even_better_matches(self): |
| shallow = exceptions.ValidationError("Oh no!", path=[]) |
| deep = exceptions.ValidationError("Oh yes!", path=["foo"]) |
|
|
| errors = sorted([shallow, deep], key=exceptions.relevance) |
| self.assertEqual( |
| [list(error.path) for error in errors], |
| [["foo"], []], |
| ) |
|
|
| errors = sorted([deep, shallow], key=exceptions.relevance) |
| self.assertEqual( |
| [list(error.path) for error in errors], |
| [["foo"], []], |
| ) |
|
|
| def test_weak_keywords_are_lower_priority(self): |
| weak = exceptions.ValidationError("Oh no!", path=[], validator="a") |
| normal = exceptions.ValidationError("Oh yes!", path=[], validator="b") |
|
|
| best_match = exceptions.by_relevance(weak="a") |
|
|
| match = max([weak, normal], key=best_match) |
| self.assertIs(match, normal) |
|
|
| match = max([normal, weak], key=best_match) |
| self.assertIs(match, normal) |
|
|
| def test_strong_keywords_are_higher_priority(self): |
| weak = exceptions.ValidationError("Oh no!", path=[], validator="a") |
| normal = exceptions.ValidationError("Oh yes!", path=[], validator="b") |
| strong = exceptions.ValidationError("Oh fine!", path=[], validator="c") |
|
|
| best_match = exceptions.by_relevance(weak="a", strong="c") |
|
|
| match = max([weak, normal, strong], key=best_match) |
| self.assertIs(match, strong) |
|
|
| match = max([strong, normal, weak], key=best_match) |
| self.assertIs(match, strong) |
|
|
|
|
| class TestErrorTree(TestCase): |
| def test_it_knows_how_many_total_errors_it_contains(self): |
| |
| errors = [ |
| exceptions.ValidationError("Something", validator=i) |
| for i in range(8) |
| ] |
| tree = exceptions.ErrorTree(errors) |
| self.assertEqual(tree.total_errors, 8) |
|
|
| def test_it_contains_an_item_if_the_item_had_an_error(self): |
| errors = [exceptions.ValidationError("a message", path=["bar"])] |
| tree = exceptions.ErrorTree(errors) |
| self.assertIn("bar", tree) |
|
|
| def test_it_does_not_contain_an_item_if_the_item_had_no_error(self): |
| errors = [exceptions.ValidationError("a message", path=["bar"])] |
| tree = exceptions.ErrorTree(errors) |
| self.assertNotIn("foo", tree) |
|
|
| def test_keywords_that_failed_appear_in_errors_dict(self): |
| error = exceptions.ValidationError("a message", validator="foo") |
| tree = exceptions.ErrorTree([error]) |
| self.assertEqual(tree.errors, {"foo": error}) |
|
|
| def test_it_creates_a_child_tree_for_each_nested_path(self): |
| errors = [ |
| exceptions.ValidationError("a bar message", path=["bar"]), |
| exceptions.ValidationError("a bar -> 0 message", path=["bar", 0]), |
| ] |
| tree = exceptions.ErrorTree(errors) |
| self.assertIn(0, tree["bar"]) |
| self.assertNotIn(1, tree["bar"]) |
|
|
| def test_children_have_their_errors_dicts_built(self): |
| e1, e2 = ( |
| exceptions.ValidationError("1", validator="foo", path=["bar", 0]), |
| exceptions.ValidationError("2", validator="quux", path=["bar", 0]), |
| ) |
| tree = exceptions.ErrorTree([e1, e2]) |
| self.assertEqual(tree["bar"][0].errors, {"foo": e1, "quux": e2}) |
|
|
| def test_multiple_errors_with_instance(self): |
| e1, e2 = ( |
| exceptions.ValidationError( |
| "1", |
| validator="foo", |
| path=["bar", "bar2"], |
| instance="i1"), |
| exceptions.ValidationError( |
| "2", |
| validator="quux", |
| path=["foobar", 2], |
| instance="i2"), |
| ) |
| exceptions.ErrorTree([e1, e2]) |
|
|
| def test_it_does_not_contain_subtrees_that_are_not_in_the_instance(self): |
| error = exceptions.ValidationError("123", validator="foo", instance=[]) |
| tree = exceptions.ErrorTree([error]) |
|
|
| with self.assertRaises(IndexError): |
| tree[0] |
|
|
| def test_if_its_in_the_tree_anyhow_it_does_not_raise_an_error(self): |
| """ |
| If a keyword refers to a path that isn't in the instance, the |
| tree still properly returns a subtree for that path. |
| """ |
|
|
| error = exceptions.ValidationError( |
| "a message", validator="foo", instance={}, path=["foo"], |
| ) |
| tree = exceptions.ErrorTree([error]) |
| self.assertIsInstance(tree["foo"], exceptions.ErrorTree) |
|
|
| def test_iter(self): |
| e1, e2 = ( |
| exceptions.ValidationError( |
| "1", |
| validator="foo", |
| path=["bar", "bar2"], |
| instance="i1"), |
| exceptions.ValidationError( |
| "2", |
| validator="quux", |
| path=["foobar", 2], |
| instance="i2"), |
| ) |
| tree = exceptions.ErrorTree([e1, e2]) |
| self.assertEqual(set(tree), {"bar", "foobar"}) |
|
|
| def test_repr_single(self): |
| error = exceptions.ValidationError( |
| "1", |
| validator="foo", |
| path=["bar", "bar2"], |
| instance="i1", |
| ) |
| tree = exceptions.ErrorTree([error]) |
| self.assertEqual(repr(tree), "<ErrorTree (1 total error)>") |
|
|
| def test_repr_multiple(self): |
| e1, e2 = ( |
| exceptions.ValidationError( |
| "1", |
| validator="foo", |
| path=["bar", "bar2"], |
| instance="i1"), |
| exceptions.ValidationError( |
| "2", |
| validator="quux", |
| path=["foobar", 2], |
| instance="i2"), |
| ) |
| tree = exceptions.ErrorTree([e1, e2]) |
| self.assertEqual(repr(tree), "<ErrorTree (2 total errors)>") |
|
|
| def test_repr_empty(self): |
| tree = exceptions.ErrorTree([]) |
| self.assertEqual(repr(tree), "<ErrorTree (0 total errors)>") |
|
|
|
|
| class TestErrorInitReprStr(TestCase): |
| def make_error(self, **kwargs): |
| defaults = dict( |
| message="hello", |
| validator="type", |
| validator_value="string", |
| instance=5, |
| schema={"type": "string"}, |
| ) |
| defaults.update(kwargs) |
| return exceptions.ValidationError(**defaults) |
|
|
| def assertShows(self, expected, **kwargs): |
| expected = textwrap.dedent(expected).rstrip("\n") |
|
|
| error = self.make_error(**kwargs) |
| message_line, _, rest = str(error).partition("\n") |
| self.assertEqual(message_line, error.message) |
| self.assertEqual(rest, expected) |
|
|
| def test_it_calls_super_and_sets_args(self): |
| error = self.make_error() |
| self.assertGreater(len(error.args), 1) |
|
|
| def test_repr(self): |
| self.assertEqual( |
| repr(exceptions.ValidationError(message="Hello!")), |
| "<ValidationError: 'Hello!'>", |
| ) |
|
|
| def test_unset_error(self): |
| error = exceptions.ValidationError("message") |
| self.assertEqual(str(error), "message") |
|
|
| kwargs = { |
| "validator": "type", |
| "validator_value": "string", |
| "instance": 5, |
| "schema": {"type": "string"}, |
| } |
| |
| for attr in kwargs: |
| k = dict(kwargs) |
| del k[attr] |
| error = exceptions.ValidationError("message", **k) |
| self.assertEqual(str(error), "message") |
|
|
| def test_empty_paths(self): |
| self.assertShows( |
| """ |
| Failed validating 'type' in schema: |
| {'type': 'string'} |
| |
| On instance: |
| 5 |
| """, |
| path=[], |
| schema_path=[], |
| ) |
|
|
| def test_one_item_paths(self): |
| self.assertShows( |
| """ |
| Failed validating 'type' in schema: |
| {'type': 'string'} |
| |
| On instance[0]: |
| 5 |
| """, |
| path=[0], |
| schema_path=["items"], |
| ) |
|
|
| def test_multiple_item_paths(self): |
| self.assertShows( |
| """ |
| Failed validating 'type' in schema['items'][0]: |
| {'type': 'string'} |
| |
| On instance[0]['a']: |
| 5 |
| """, |
| path=[0, "a"], |
| schema_path=["items", 0, 1], |
| ) |
|
|
| def test_uses_pprint(self): |
| self.assertShows( |
| """ |
| Failed validating 'maxLength' in schema: |
| {0: 0, |
| 1: 1, |
| 2: 2, |
| 3: 3, |
| 4: 4, |
| 5: 5, |
| 6: 6, |
| 7: 7, |
| 8: 8, |
| 9: 9, |
| 10: 10, |
| 11: 11, |
| 12: 12, |
| 13: 13, |
| 14: 14, |
| 15: 15, |
| 16: 16, |
| 17: 17, |
| 18: 18, |
| 19: 19} |
| |
| On instance: |
| [0, |
| 1, |
| 2, |
| 3, |
| 4, |
| 5, |
| 6, |
| 7, |
| 8, |
| 9, |
| 10, |
| 11, |
| 12, |
| 13, |
| 14, |
| 15, |
| 16, |
| 17, |
| 18, |
| 19, |
| 20, |
| 21, |
| 22, |
| 23, |
| 24] |
| """, |
| instance=list(range(25)), |
| schema=dict(zip(range(20), range(20))), |
| validator="maxLength", |
| ) |
|
|
| def test_does_not_reorder_dicts(self): |
| self.assertShows( |
| """ |
| Failed validating 'type' in schema: |
| {'do': 3, 'not': 7, 'sort': 37, 'me': 73} |
| |
| On instance: |
| {'here': 73, 'too': 37, 'no': 7, 'sorting': 3} |
| """, |
| schema={ |
| "do": 3, |
| "not": 7, |
| "sort": 37, |
| "me": 73, |
| }, |
| instance={ |
| "here": 73, |
| "too": 37, |
| "no": 7, |
| "sorting": 3, |
| }, |
| ) |
|
|
| def test_str_works_with_instances_having_overriden_eq_operator(self): |
| """ |
| Check for #164 which rendered exceptions unusable when a |
| `ValidationError` involved instances with an `__eq__` method |
| that returned truthy values. |
| """ |
|
|
| class DontEQMeBro: |
| def __eq__(this, other): |
| self.fail("Don't!") |
|
|
| def __ne__(this, other): |
| self.fail("Don't!") |
|
|
| instance = DontEQMeBro() |
| error = exceptions.ValidationError( |
| "a message", |
| validator="foo", |
| instance=instance, |
| validator_value="some", |
| schema="schema", |
| ) |
| self.assertIn(repr(instance), str(error)) |
|
|
|
|
| class TestHashable(TestCase): |
| def test_hashable(self): |
| {exceptions.ValidationError("")} |
| {exceptions.SchemaError("")} |
|
|
