Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 __init__.py	0 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 _helpers.py def bug(issue=None): message = "A known bug." if issue is not None: message += " See issue #{issue}.".format(issue=issue) return message	157 B	2026-01-20 12:58
📄 _suite.py """ Python representations of the JSON Schema Test Suite tests. """ from functools import partial import json import os import re import subprocess import sys import unittest from twisted.python.filepath import FilePath import attr from jsonschema.compat import PY3 from jsonschema.validators import validators import jsonschema def _find_suite(): root = os.environ.get("JSON_SCHEMA_TEST_SUITE") if root is not None: return FilePath(root) root = FilePath(jsonschema.__file__).parent().sibling("json") if not root.isdir(): # pragma: no cover raise ValueError( ( "Can't find the JSON-Schema-Test-Suite directory. " "Set the 'JSON_SCHEMA_TEST_SUITE' environment " "variable or run the tests from alongside a checkout " "of the suite." ), ) return root @attr.s(hash=True) class Suite(object): _root = attr.ib(default=attr.Factory(_find_suite)) def _remotes(self): jsonschema_suite = self._root.descendant(["bin", "jsonschema_suite"]) remotes = subprocess.check_output( [sys.executable, jsonschema_suite.path, "remotes"], ) return { "http://localhost:1234/" + name: schema for name, schema in json.loads(remotes.decode("utf-8")).items() } def benchmark(self, runner): # pragma: no cover for name in validators: self.version(name=name).benchmark(runner=runner) def version(self, name): return Version( name=name, path=self._root.descendant(["tests", name]), remotes=self._remotes(), ) @attr.s(hash=True) class Version(object): _path = attr.ib() _remotes = attr.ib() name = attr.ib() def benchmark(self, runner, kwargs): # pragma: no cover for suite in self.tests(): for test in suite: runner.bench_func( test.fully_qualified_name, partial(test.validate_ignoring_errors, kwargs), ) def tests(self): return ( test for child in self._path.globChildren(".json") for test in self._tests_in( subject=child.basename()[:-5], path=child, ) ) def format_tests(self): path = self._path.descendant(["optional", "format"]) return ( test for child in path.globChildren(".json") for test in self._tests_in( subject=child.basename()[:-5], path=child, ) ) def tests_of(self, name): return self._tests_in( subject=name, path=self._path.child(name + ".json"), ) def optional_tests_of(self, name): return self._tests_in( subject=name, path=self._path.descendant(["optional", name + ".json"]), ) def to_unittest_testcase(self, suites, kwargs): name = kwargs.pop("name", "Test" + self.name.title()) methods = { test.method_name: test.to_unittest_method(kwargs) for suite in suites for tests in suite for test in tests } cls = type(name, (unittest.TestCase,), methods) try: cls.__module__ = _someone_save_us_the_module_of_the_caller() except Exception: # pragma: no cover # We're doing crazy things, so if they go wrong, like a function # behaving differently on some other interpreter, just make them # not happen. pass return cls def _tests_in(self, subject, path): for each in json.loads(path.getContent().decode("utf-8")): yield ( _Test( version=self, subject=subject, case_description=each["description"], schema=each["schema"], remotes=self._remotes, test ) for test in each["tests"] ) @attr.s(hash=True, repr=False) class _Test(object): version = attr.ib() subject = attr.ib() case_description = attr.ib() description = attr.ib() data = attr.ib() schema = attr.ib(repr=False) valid = attr.ib() _remotes = attr.ib() def __repr__(self): # pragma: no cover return "<Test {}>".format(self.fully_qualified_name) @property def fully_qualified_name(self): # pragma: no cover return " > ".join( [ self.version.name, self.subject, self.case_description, self.description, ] ) @property def method_name(self): delimiters = r"[\W\- ]+" name = "test_%s_%s_%s" % ( re.sub(delimiters, "_", self.subject), re.sub(delimiters, "_", self.case_description), re.sub(delimiters, "_", self.description), ) if not PY3: # pragma: no cover name = name.encode("utf-8") return name def to_unittest_method(self, skip=lambda test: None, kwargs): if self.valid: def fn(this): self.validate(kwargs) else: def fn(this): with this.assertRaises(jsonschema.ValidationError): self.validate(kwargs) fn.__name__ = self.method_name reason = skip(self) return unittest.skipIf(reason is not None, reason)(fn) def validate(self, Validator, kwargs): resolver = jsonschema.RefResolver.from_schema( schema=self.schema, store=self._remotes, id_of=Validator.ID_OF, ) jsonschema.validate( instance=self.data, schema=self.schema, cls=Validator, resolver=resolver, *kwargs ) def validate_ignoring_errors(self, Validator): # pragma: no cover try: self.validate(Validator=Validator) except jsonschema.ValidationError: pass def _someone_save_us_the_module_of_the_caller(): """ The FQON of the module 2nd stack frames up from here. This is intended to allow us to dynamicallly return test case classes that are indistinguishable from being defined in the module that wants them. Otherwise, trial will mis-print the FQON, and copy pasting it won't re-run the class that really is running. Save us all, this is all so so so so so terrible. """ return sys._getframe(2).f_globals["__name__"]	6.57 KB	2026-01-20 12:58
📄 test_cli.py from unittest import TestCase import json import subprocess import sys from jsonschema import Draft4Validator, ValidationError, cli, __version__ from jsonschema.compat import NativeIO from jsonschema.exceptions import SchemaError def fake_validator(errors): errors = list(reversed(errors)) class FakeValidator(object): def __init__(self, args, **kwargs): pass def iter_errors(self, instance): if errors: return errors.pop() return [] def check_schema(self, schema): pass return FakeValidator class TestParser(TestCase): FakeValidator = fake_validator() instance_file = "foo.json" schema_file = "schema.json" def setUp(self): cli.open = self.fake_open self.addCleanup(delattr, cli, "open") def fake_open(self, path): if path == self.instance_file: contents = "" elif path == self.schema_file: contents = {} else: # pragma: no cover self.fail("What is {!r}".format(path)) return NativeIO(json.dumps(contents)) def test_find_validator_by_fully_qualified_object_name(self): arguments = cli.parse_args( [ "--validator", "jsonschema.tests.test_cli.TestParser.FakeValidator", "--instance", self.instance_file, self.schema_file, ] ) self.assertIs(arguments["validator"], self.FakeValidator) def test_find_validator_in_jsonschema(self): arguments = cli.parse_args( [ "--validator", "Draft4Validator", "--instance", self.instance_file, self.schema_file, ] ) self.assertIs(arguments["validator"], Draft4Validator) class TestCLI(TestCase): def test_draft3_schema_draft4_validator(self): stdout, stderr = NativeIO(), NativeIO() with self.assertRaises(SchemaError): cli.run( { "validator": Draft4Validator, "schema": { "anyOf": [ {"minimum": 20}, {"type": "string"}, {"required": True}, ], }, "instances": [1], "error_format": "{error.message}", }, stdout=stdout, stderr=stderr, ) def test_successful_validation(self): stdout, stderr = NativeIO(), NativeIO() exit_code = cli.run( { "validator": fake_validator(), "schema": {}, "instances": [1], "error_format": "{error.message}", }, stdout=stdout, stderr=stderr, ) self.assertFalse(stdout.getvalue()) self.assertFalse(stderr.getvalue()) self.assertEqual(exit_code, 0) def test_unsuccessful_validation(self): error = ValidationError("I am an error!", instance=1) stdout, stderr = NativeIO(), NativeIO() exit_code = cli.run( { "validator": fake_validator([error]), "schema": {}, "instances": [1], "error_format": "{error.instance} - {error.message}", }, stdout=stdout, stderr=stderr, ) self.assertFalse(stdout.getvalue()) self.assertEqual(stderr.getvalue(), "1 - I am an error!") self.assertEqual(exit_code, 1) def test_unsuccessful_validation_multiple_instances(self): first_errors = [ ValidationError("9", instance=1), ValidationError("8", instance=1), ] second_errors = [ValidationError("7", instance=2)] stdout, stderr = NativeIO(), NativeIO() exit_code = cli.run( { "validator": fake_validator(first_errors, second_errors), "schema": {}, "instances": [1, 2], "error_format": "{error.instance} - {error.message}\t", }, stdout=stdout, stderr=stderr, ) self.assertFalse(stdout.getvalue()) self.assertEqual(stderr.getvalue(), "1 - 9\t1 - 8\t2 - 7\t") self.assertEqual(exit_code, 1) def test_version(self): version = subprocess.check_output( [sys.executable, "-m", "jsonschema", "--version"], stderr=subprocess.STDOUT, ) version = version.decode("utf-8").strip() self.assertEqual(version, __version__)	4.62 KB	2026-01-20 12:58
📄 test_exceptions.py from unittest import TestCase import textwrap from jsonschema import Draft4Validator, exceptions from jsonschema.compat import PY3 class TestBestMatch(TestCase): def best_match(self, errors): errors = list(errors) best = exceptions.best_match(errors) reversed_best = exceptions.best_match(reversed(errors)) msg = "Didn't return a consistent best match!\nGot: {0}\n\nThen: {1}" self.assertEqual( best._contents(), reversed_best._contents(), msg=msg.format(best, reversed_best), ) return best def test_shallower_errors_are_better_matches(self): validator = Draft4Validator( { "properties": { "foo": { "minProperties": 2, "properties": {"bar": {"type": "object"}}, }, }, }, ) best = self.best_match(validator.iter_errors({"foo": {"bar": []}})) 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. """ validator = Draft4Validator( { "minProperties": 2, "anyOf": [{"type": "string"}, {"type": "number"}], "oneOf": [{"type": "string"}, {"type": "number"}], } ) best = self.best_match(validator.iter_errors({})) 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. """ validator = Draft4Validator( { "properties": { "foo": { "anyOf": [ {"type": "string"}, {"properties": {"bar": {"type": "array"}}}, ], }, }, }, ) best = self.best_match(validator.iter_errors({"foo": {"bar": 12}})) self.assertEqual(best.validator_value, "array") 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. """ validator = Draft4Validator( { "properties": { "foo": { "oneOf": [ {"type": "string"}, {"properties": {"bar": {"type": "array"}}}, ], }, }, }, ) best = self.best_match(validator.iter_errors({"foo": {"bar": 12}})) self.assertEqual(best.validator_value, "array") 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. """ validator = Draft4Validator( { "properties": { "foo": { "allOf": [ {"type": "string"}, {"properties": {"bar": {"type": "array"}}}, ], }, }, }, ) best = self.best_match(validator.iter_errors({"foo": {"bar": 12}})) self.assertEqual(best.validator_value, "string") def test_nested_context_for_oneOf(self): validator = Draft4Validator( { "properties": { "foo": { "oneOf": [ {"type": "string"}, { "oneOf": [ {"type": "string"}, { "properties": { "bar": {"type": "array"}, }, }, ], }, ], }, }, }, ) best = self.best_match(validator.iter_errors({"foo": {"bar": 12}})) self.assertEqual(best.validator_value, "array") def test_one_error(self): validator = Draft4Validator({"minProperties": 2}) error, = validator.iter_errors({}) self.assertEqual( exceptions.best_match(validator.iter_errors({})).validator, "minProperties", ) def test_no_errors(self): validator = Draft4Validator({}) 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_validators_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_validators_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): # FIXME: https://github.com/Julian/jsonschema/issues/442 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_validators_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 validator is dumb (like :validator:`required` in draft 3) and 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) class TestErrorInitReprStr(TestCase): def make_error(self, kwargs): defaults = dict( message=u"hello", validator=u"type", validator_value=u"string", instance=5, schema={u"type": u"string"}, ) defaults.update(kwargs) return exceptions.ValidationError(defaults) def assertShows(self, expected, kwargs): if PY3: # pragma: no cover expected = expected.replace("u'", "'") 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: %r>" % "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"}, } # Just the message should show if any of the attributes are unset 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 u'type' in schema: {u'type': u'string'} On instance: 5 """, path=[], schema_path=[], ) def test_one_item_paths(self): self.assertShows( """ Failed validating u'type' in schema: {u'type': u'string'} On instance[0]: 5 """, path=[0], schema_path=["items"], ) def test_multiple_item_paths(self): self.assertShows( """ Failed validating u'type' in schema[u'items'][0]: {u'type': u'string'} On instance[0][u'a']: 5 """, path=[0, u"a"], schema_path=[u"items", 0, 1], ) def test_uses_pprint(self): self.assertShows( """ Failed validating u'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=u"maxLength", ) def test_str_works_with_instances_having_overriden_eq_operator(self): """ Check for https://github.com/Julian/jsonschema/issues/164 which rendered exceptions unusable when a `ValidationError` involved instances with an `__eq__` method that returned truthy values. """ class DontEQMeBro(object): def __eq__(this, other): # pragma: no cover self.fail("Don't!") def __ne__(this, other): # pragma: no cover 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): set([exceptions.ValidationError("")]) set([exceptions.SchemaError("")])	14.99 KB	2026-01-20 12:58
📄 test_format.py """ Tests for the parts of jsonschema related to the :validator:`format` property. """ from unittest import TestCase from jsonschema import FormatError, ValidationError, FormatChecker from jsonschema.validators import Draft4Validator BOOM = ValueError("Boom!") BANG = ZeroDivisionError("Bang!") def boom(thing): if thing == "bang": raise BANG raise BOOM class TestFormatChecker(TestCase): def test_it_can_validate_no_formats(self): checker = FormatChecker(formats=()) self.assertFalse(checker.checkers) def test_it_raises_a_key_error_for_unknown_formats(self): with self.assertRaises(KeyError): FormatChecker(formats=["o noes"]) def test_it_can_register_cls_checkers(self): original = dict(FormatChecker.checkers) self.addCleanup(FormatChecker.checkers.pop, "boom") FormatChecker.cls_checks("boom")(boom) self.assertEqual( FormatChecker.checkers, dict(original, boom=(boom, ())), ) def test_it_can_register_checkers(self): checker = FormatChecker() checker.checks("boom")(boom) self.assertEqual( checker.checkers, dict(FormatChecker.checkers, boom=(boom, ())) ) def test_it_catches_registered_errors(self): checker = FormatChecker() checker.checks("boom", raises=type(BOOM))(boom) with self.assertRaises(FormatError) as cm: checker.check(instance=12, format="boom") self.assertIs(cm.exception.cause, BOOM) self.assertIs(cm.exception.__cause__, BOOM) # Unregistered errors should not be caught with self.assertRaises(type(BANG)): checker.check(instance="bang", format="boom") def test_format_error_causes_become_validation_error_causes(self): checker = FormatChecker() checker.checks("boom", raises=ValueError)(boom) validator = Draft4Validator({"format": "boom"}, format_checker=checker) with self.assertRaises(ValidationError) as cm: validator.validate("BOOM") self.assertIs(cm.exception.cause, BOOM) self.assertIs(cm.exception.__cause__, BOOM) def test_format_checkers_come_with_defaults(self): # This is bad :/ but relied upon. # The docs for quite awhile recommended people do things like # validate(..., format_checker=FormatChecker()) # We should change that, but we can't without deprecation... checker = FormatChecker() with self.assertRaises(FormatError): checker.check(instance="not-an-ipv4", format="ipv4") def test_repr(self): checker = FormatChecker(formats=()) checker.checks("foo")(lambda thing: True) checker.checks("bar")(lambda thing: True) checker.checks("baz")(lambda thing: True) self.assertEqual( repr(checker), "<FormatChecker checkers=['bar', 'baz', 'foo']>", )	2.91 KB	2026-01-20 12:58
📄 test_jsonschema_test_suite.py """ Test runner for the JSON Schema official test suite Tests comprehensive correctness of each draft's validator. See https://github.com/json-schema-org/JSON-Schema-Test-Suite for details. """ import sys import warnings from jsonschema import ( Draft3Validator, Draft4Validator, Draft6Validator, Draft7Validator, draft3_format_checker, draft4_format_checker, draft6_format_checker, draft7_format_checker, ) from jsonschema.tests._helpers import bug from jsonschema.tests._suite import Suite from jsonschema.validators import _DEPRECATED_DEFAULT_TYPES, create SUITE = Suite() DRAFT3 = SUITE.version(name="draft3") DRAFT4 = SUITE.version(name="draft4") DRAFT6 = SUITE.version(name="draft6") DRAFT7 = SUITE.version(name="draft7") def skip(message, kwargs): def skipper(test): if all(value == getattr(test, attr) for attr, value in kwargs.items()): return message return skipper def missing_format(checker): def missing_format(test): schema = test.schema if schema is True or schema is False or "format" not in schema: return if schema["format"] not in checker.checkers: return "Format checker {0!r} not found.".format(schema["format"]) return missing_format is_narrow_build = sys.maxunicode == 2 16 - 1 if is_narrow_build: # pragma: no cover message = "Not running surrogate Unicode case, this Python is narrow." def narrow_unicode_build(test): # pragma: no cover return skip( message=message, description="one supplementary Unicode code point is not long enough", )(test) or skip( message=message, description="two supplementary Unicode code points is long enough", )(test) else: def narrow_unicode_build(test): # pragma: no cover return TestDraft3 = DRAFT3.to_unittest_testcase( DRAFT3.tests(), DRAFT3.optional_tests_of(name="bignum"), DRAFT3.optional_tests_of(name="format"), DRAFT3.optional_tests_of(name="zeroTerminatedFloats"), Validator=Draft3Validator, format_checker=draft3_format_checker, skip=lambda test: ( narrow_unicode_build(test) or missing_format(draft3_format_checker)(test) or skip( message="Upstream bug in strict_rfc3339", subject="format", description="case-insensitive T and Z", )(test) ), ) TestDraft4 = DRAFT4.to_unittest_testcase( DRAFT4.tests(), DRAFT4.optional_tests_of(name="bignum"), DRAFT4.optional_tests_of(name="format"), DRAFT4.optional_tests_of(name="zeroTerminatedFloats"), Validator=Draft4Validator, format_checker=draft4_format_checker, skip=lambda test: ( narrow_unicode_build(test) or missing_format(draft4_format_checker)(test) or skip( message=bug(), subject="ref", case_description="Recursive references between schemas", )(test) or skip( message=bug(371), subject="ref", case_description="Location-independent identifier", )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with absolute URI" ), )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with base URI change in subschema" ), )(test) or skip( message=bug(), subject="refRemote", case_description="base URI change - change folder in subschema", )(test) or skip( message="Upstream bug in strict_rfc3339", subject="format", description="case-insensitive T and Z", )(test) ), ) TestDraft6 = DRAFT6.to_unittest_testcase( DRAFT6.tests(), DRAFT6.optional_tests_of(name="bignum"), DRAFT6.optional_tests_of(name="format"), DRAFT6.optional_tests_of(name="zeroTerminatedFloats"), Validator=Draft6Validator, format_checker=draft6_format_checker, skip=lambda test: ( narrow_unicode_build(test) or missing_format(draft6_format_checker)(test) or skip( message=bug(), subject="ref", case_description="Recursive references between schemas", )(test) or skip( message=bug(371), subject="ref", case_description="Location-independent identifier", )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with absolute URI" ), )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with base URI change in subschema" ), )(test) or skip( message=bug(), subject="refRemote", case_description="base URI change - change folder in subschema", )(test) or skip( message="Upstream bug in strict_rfc3339", subject="format", description="case-insensitive T and Z", )(test) ), ) TestDraft7 = DRAFT7.to_unittest_testcase( DRAFT7.tests(), DRAFT7.format_tests(), DRAFT7.optional_tests_of(name="bignum"), DRAFT7.optional_tests_of(name="content"), DRAFT7.optional_tests_of(name="zeroTerminatedFloats"), Validator=Draft7Validator, format_checker=draft7_format_checker, skip=lambda test: ( narrow_unicode_build(test) or missing_format(draft7_format_checker)(test) or skip( message=bug(), subject="ref", case_description="Recursive references between schemas", )(test) or skip( message=bug(371), subject="ref", case_description="Location-independent identifier", )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with absolute URI" ), )(test) or skip( message=bug(371), subject="ref", case_description=( "Location-independent identifier with base URI change in subschema" ), )(test) or skip( message=bug(), subject="refRemote", case_description="base URI change - change folder in subschema", )(test) or skip( message="Upstream bug in strict_rfc3339", subject="date-time", description="case-insensitive T and Z", )(test) or skip( message=bug(593), subject="content", case_description=( "validation of string-encoded content based on media type" ), )(test) or skip( message=bug(593), subject="content", case_description="validation of binary string-encoding", )(test) or skip( message=bug(593), subject="content", case_description=( "validation of binary-encoded media type documents" ), )(test) ), ) with warnings.catch_warnings(): warnings.simplefilter("ignore", DeprecationWarning) TestDraft3LegacyTypeCheck = DRAFT3.to_unittest_testcase( # Interestingly the any part couldn't really be done w/the old API. ( (test for test in each if test.schema != {"type": "any"}) for each in DRAFT3.tests_of(name="type") ), name="TestDraft3LegacyTypeCheck", Validator=create( meta_schema=Draft3Validator.META_SCHEMA, validators=Draft3Validator.VALIDATORS, default_types=_DEPRECATED_DEFAULT_TYPES, ), ) TestDraft4LegacyTypeCheck = DRAFT4.to_unittest_testcase( DRAFT4.tests_of(name="type"), name="TestDraft4LegacyTypeCheck", Validator=create( meta_schema=Draft4Validator.META_SCHEMA, validators=Draft4Validator.VALIDATORS, default_types=_DEPRECATED_DEFAULT_TYPES, ), )	8.27 KB	2026-01-20 12:58
📄 test_types.py """ Tests on the new type interface. The actual correctness of the type checking is handled in test_jsonschema_test_suite; these tests check that TypeChecker functions correctly and can facilitate extensions to type checking """ from collections import namedtuple from unittest import TestCase from jsonschema import ValidationError, _validators from jsonschema._types import TypeChecker from jsonschema.exceptions import UndefinedTypeCheck from jsonschema.validators import Draft4Validator, extend def equals_2(checker, instance): return instance == 2 def is_namedtuple(instance): return isinstance(instance, tuple) and getattr(instance, "_fields", None) def is_object_or_named_tuple(checker, instance): if Draft4Validator.TYPE_CHECKER.is_type(instance, "object"): return True return is_namedtuple(instance) def coerce_named_tuple(fn): def coerced(validator, value, instance, schema): if is_namedtuple(instance): instance = instance._asdict() return fn(validator, value, instance, schema) return coerced required = coerce_named_tuple(_validators.required) properties = coerce_named_tuple(_validators.properties) class TestTypeChecker(TestCase): def test_is_type(self): checker = TypeChecker({"two": equals_2}) self.assertEqual( ( checker.is_type(instance=2, type="two"), checker.is_type(instance="bar", type="two"), ), (True, False), ) def test_is_unknown_type(self): with self.assertRaises(UndefinedTypeCheck) as context: TypeChecker().is_type(4, "foobar") self.assertIn("foobar", str(context.exception)) def test_checks_can_be_added_at_init(self): checker = TypeChecker({"two": equals_2}) self.assertEqual(checker, TypeChecker().redefine("two", equals_2)) def test_redefine_existing_type(self): self.assertEqual( TypeChecker().redefine("two", object()).redefine("two", equals_2), TypeChecker().redefine("two", equals_2), ) def test_remove(self): self.assertEqual( TypeChecker({"two": equals_2}).remove("two"), TypeChecker(), ) def test_remove_unknown_type(self): with self.assertRaises(UndefinedTypeCheck) as context: TypeChecker().remove("foobar") self.assertIn("foobar", str(context.exception)) def test_redefine_many(self): self.assertEqual( TypeChecker().redefine_many({"foo": int, "bar": str}), TypeChecker().redefine("foo", int).redefine("bar", str), ) def test_remove_multiple(self): self.assertEqual( TypeChecker({"foo": int, "bar": str}).remove("foo", "bar"), TypeChecker(), ) def test_type_check_can_raise_key_error(self): """ Make sure no one writes: try: self._type_checkers[type](...) except KeyError: ignoring the fact that the function itself can raise that. """ error = KeyError("Stuff") def raises_keyerror(checker, instance): raise error with self.assertRaises(KeyError) as context: TypeChecker({"foo": raises_keyerror}).is_type(4, "foo") self.assertIs(context.exception, error) class TestCustomTypes(TestCase): def test_simple_type_can_be_extended(self): def int_or_str_int(checker, instance): if not isinstance(instance, (int, str)): return False try: int(instance) except ValueError: return False return True CustomValidator = extend( Draft4Validator, type_checker=Draft4Validator.TYPE_CHECKER.redefine( "integer", int_or_str_int, ), ) validator = CustomValidator({"type": "integer"}) validator.validate(4) validator.validate("4") with self.assertRaises(ValidationError): validator.validate(4.4) def test_object_can_be_extended(self): schema = {"type": "object"} Point = namedtuple("Point", ["x", "y"]) type_checker = Draft4Validator.TYPE_CHECKER.redefine( u"object", is_object_or_named_tuple, ) CustomValidator = extend(Draft4Validator, type_checker=type_checker) validator = CustomValidator(schema) validator.validate(Point(x=4, y=5)) def test_object_extensions_require_custom_validators(self): schema = {"type": "object", "required": ["x"]} type_checker = Draft4Validator.TYPE_CHECKER.redefine( u"object", is_object_or_named_tuple, ) CustomValidator = extend(Draft4Validator, type_checker=type_checker) validator = CustomValidator(schema) Point = namedtuple("Point", ["x", "y"]) # Cannot handle required with self.assertRaises(ValidationError): validator.validate(Point(x=4, y=5)) def test_object_extensions_can_handle_custom_validators(self): schema = { "type": "object", "required": ["x"], "properties": {"x": {"type": "integer"}}, } type_checker = Draft4Validator.TYPE_CHECKER.redefine( u"object", is_object_or_named_tuple, ) CustomValidator = extend( Draft4Validator, type_checker=type_checker, validators={"required": required, "properties": properties}, ) validator = CustomValidator(schema) Point = namedtuple("Point", ["x", "y"]) # Can now process required and properties validator.validate(Point(x=4, y=5)) with self.assertRaises(ValidationError): validator.validate(Point(x="not an integer", y=5))	5.76 KB	2026-01-20 12:58
📄 test_validators.py from collections import deque from contextlib import contextmanager from decimal import Decimal from io import BytesIO from unittest import TestCase import json import os import sys import tempfile import unittest from twisted.trial.unittest import SynchronousTestCase import attr from jsonschema import FormatChecker, TypeChecker, exceptions, validators from jsonschema.compat import PY3, pathname2url from jsonschema.tests._helpers import bug def startswith(validator, startswith, instance, schema): if not instance.startswith(startswith): yield exceptions.ValidationError(u"Whoops!") class TestCreateAndExtend(SynchronousTestCase): def setUp(self): self.addCleanup( self.assertEqual, validators.meta_schemas, dict(validators.meta_schemas), ) self.meta_schema = {u"$id": "some://meta/schema"} self.validators = {u"startswith": startswith} self.type_checker = TypeChecker() self.Validator = validators.create( meta_schema=self.meta_schema, validators=self.validators, type_checker=self.type_checker, ) def test_attrs(self): self.assertEqual( ( self.Validator.VALIDATORS, self.Validator.META_SCHEMA, self.Validator.TYPE_CHECKER, ), ( self.validators, self.meta_schema, self.type_checker, ), ) def test_init(self): schema = {u"startswith": u"foo"} self.assertEqual(self.Validator(schema).schema, schema) def test_iter_errors(self): schema = {u"startswith": u"hel"} iter_errors = self.Validator(schema).iter_errors errors = list(iter_errors(u"hello")) self.assertEqual(errors, []) expected_error = exceptions.ValidationError( u"Whoops!", instance=u"goodbye", schema=schema, validator=u"startswith", validator_value=u"hel", schema_path=deque([u"startswith"]), ) errors = list(iter_errors(u"goodbye")) self.assertEqual(len(errors), 1) self.assertEqual(errors[0]._contents(), expected_error._contents()) def test_if_a_version_is_provided_it_is_registered(self): Validator = validators.create( meta_schema={u"$id": "something"}, version="my version", ) self.addCleanup(validators.meta_schemas.pop, "something") self.assertEqual(Validator.__name__, "MyVersionValidator") def test_if_a_version_is_not_provided_it_is_not_registered(self): original = dict(validators.meta_schemas) validators.create(meta_schema={u"id": "id"}) self.assertEqual(validators.meta_schemas, original) def test_validates_registers_meta_schema_id(self): meta_schema_key = "meta schema id" my_meta_schema = {u"id": meta_schema_key} validators.create( meta_schema=my_meta_schema, version="my version", id_of=lambda s: s.get("id", ""), ) self.addCleanup(validators.meta_schemas.pop, meta_schema_key) self.assertIn(meta_schema_key, validators.meta_schemas) def test_validates_registers_meta_schema_draft6_id(self): meta_schema_key = "meta schema $id" my_meta_schema = {u"$id": meta_schema_key} validators.create( meta_schema=my_meta_schema, version="my version", ) self.addCleanup(validators.meta_schemas.pop, meta_schema_key) self.assertIn(meta_schema_key, validators.meta_schemas) def test_create_default_types(self): Validator = validators.create(meta_schema={}, validators=()) self.assertTrue( all( Validator({}).is_type(instance=instance, type=type) for type, instance in [ (u"array", []), (u"boolean", True), (u"integer", 12), (u"null", None), (u"number", 12.0), (u"object", {}), (u"string", u"foo"), ] ), ) def test_extend(self): original = dict(self.Validator.VALIDATORS) new = object() Extended = validators.extend( self.Validator, validators={u"new": new}, ) self.assertEqual( ( Extended.VALIDATORS, Extended.META_SCHEMA, Extended.TYPE_CHECKER, self.Validator.VALIDATORS, ), ( dict(original, new=new), self.Validator.META_SCHEMA, self.Validator.TYPE_CHECKER, original, ), ) def test_extend_idof(self): """ Extending a validator preserves its notion of schema IDs. """ def id_of(schema): return schema.get(u"__test__", self.Validator.ID_OF(schema)) correct_id = "the://correct/id/" meta_schema = { u"$id": "the://wrong/id/", u"__test__": correct_id, } Original = validators.create( meta_schema=meta_schema, validators=self.validators, type_checker=self.type_checker, id_of=id_of, ) self.assertEqual(Original.ID_OF(Original.META_SCHEMA), correct_id) Derived = validators.extend(Original) self.assertEqual(Derived.ID_OF(Derived.META_SCHEMA), correct_id) class TestLegacyTypeChecking(SynchronousTestCase): def test_create_default_types(self): Validator = validators.create(meta_schema={}, validators=()) self.assertEqual( set(Validator.DEFAULT_TYPES), { u"array", u"boolean", u"integer", u"null", u"number", u"object", u"string", }, ) self.flushWarnings() def test_extend(self): Validator = validators.create(meta_schema={}, validators=()) original = dict(Validator.VALIDATORS) new = object() Extended = validators.extend( Validator, validators={u"new": new}, ) self.assertEqual( ( Extended.VALIDATORS, Extended.META_SCHEMA, Extended.TYPE_CHECKER, Validator.VALIDATORS, Extended.DEFAULT_TYPES, Extended({}).DEFAULT_TYPES, self.flushWarnings()[0]["message"], ), ( dict(original, new=new), Validator.META_SCHEMA, Validator.TYPE_CHECKER, original, Validator.DEFAULT_TYPES, Validator.DEFAULT_TYPES, self.flushWarnings()[0]["message"], ), ) def test_types_redefines_the_validators_type_checker(self): schema = {"type": "string"} self.assertFalse(validators.Draft7Validator(schema).is_valid(12)) validator = validators.Draft7Validator( schema, types={"string": (str, int)}, ) self.assertTrue(validator.is_valid(12)) self.flushWarnings() def test_providing_default_types_warns(self): self.assertWarns( category=DeprecationWarning, message=( "The default_types argument is deprecated. " "Use the type_checker argument instead." ), # https://tm.tl/9363 :'( filename=sys.modules[self.assertWarns.__module__].__file__, f=validators.create, meta_schema={}, validators={}, default_types={"foo": object}, ) def test_cannot_ask_for_default_types_with_non_default_type_checker(self): """ We raise an error when you ask a validator with non-default type checker for its DEFAULT_TYPES. The type checker argument is new, so no one but this library itself should be trying to use it, and doing so while then asking for DEFAULT_TYPES makes no sense (not to mention is deprecated), since type checkers are not strictly about Python type. """ Validator = validators.create( meta_schema={}, validators={}, type_checker=TypeChecker(), ) with self.assertRaises(validators._DontDoThat) as e: Validator.DEFAULT_TYPES self.assertIn( "DEFAULT_TYPES cannot be used on Validators using TypeCheckers", str(e.exception), ) with self.assertRaises(validators._DontDoThat): Validator({}).DEFAULT_TYPES self.assertFalse(self.flushWarnings()) def test_providing_explicit_type_checker_does_not_warn(self): Validator = validators.create( meta_schema={}, validators={}, type_checker=TypeChecker(), ) self.assertFalse(self.flushWarnings()) Validator({}) self.assertFalse(self.flushWarnings()) def test_providing_neither_does_not_warn(self): Validator = validators.create(meta_schema={}, validators={}) self.assertFalse(self.flushWarnings()) Validator({}) self.assertFalse(self.flushWarnings()) def test_providing_default_types_with_type_checker_errors(self): with self.assertRaises(TypeError) as e: validators.create( meta_schema={}, validators={}, default_types={"foo": object}, type_checker=TypeChecker(), ) self.assertIn( "Do not specify default_types when providing a type checker", str(e.exception), ) self.assertFalse(self.flushWarnings()) def test_extending_a_legacy_validator_with_a_type_checker_errors(self): Validator = validators.create( meta_schema={}, validators={}, default_types={u"array": list} ) with self.assertRaises(TypeError) as e: validators.extend( Validator, validators={}, type_checker=TypeChecker(), ) self.assertIn( ( "Cannot extend a validator created with default_types " "with a type_checker. Update the validator to use a " "type_checker when created." ), str(e.exception), ) self.flushWarnings() def test_extending_a_legacy_validator_does_not_rewarn(self): Validator = validators.create(meta_schema={}, default_types={}) self.assertTrue(self.flushWarnings()) validators.extend(Validator) self.assertFalse(self.flushWarnings()) def test_accessing_default_types_warns(self): Validator = validators.create(meta_schema={}, validators={}) self.assertFalse(self.flushWarnings()) self.assertWarns( DeprecationWarning, ( "The DEFAULT_TYPES attribute is deprecated. " "See the type checker attached to this validator instead." ), # https://tm.tl/9363 :'( sys.modules[self.assertWarns.__module__].__file__, getattr, Validator, "DEFAULT_TYPES", ) def test_accessing_default_types_on_the_instance_warns(self): Validator = validators.create(meta_schema={}, validators={}) self.assertFalse(self.flushWarnings()) self.assertWarns( DeprecationWarning, ( "The DEFAULT_TYPES attribute is deprecated. " "See the type checker attached to this validator instead." ), # https://tm.tl/9363 :'( sys.modules[self.assertWarns.__module__].__file__, getattr, Validator({}), "DEFAULT_TYPES", ) def test_providing_types_to_init_warns(self): Validator = validators.create(meta_schema={}, validators={}) self.assertFalse(self.flushWarnings()) self.assertWarns( category=DeprecationWarning, message=( "The types argument is deprecated. " "Provide a type_checker to jsonschema.validators.extend " "instead." ), # https://tm.tl/9363 :'( filename=sys.modules[self.assertWarns.__module__].__file__, f=Validator, schema={}, types={"bar": object}, ) class TestIterErrors(TestCase): def setUp(self): self.validator = validators.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(TestCase): def message_for(self, instance, schema, args, kwargs): kwargs.setdefault("cls", validators.Draft3Validator) with self.assertRaises(exceptions.ValidationError) as e: validators.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 less than the minimum of 3") def test_object_with_named_type_failure(self): schema = {u"type": [{u"name": "Foo", u"minimum": 3}]} message = self.message_for(instance=1, schema=schema) self.assertEqual(message, "1 is less than the minimum of 3") 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_single_element(self): depend, on = "bar", "foo" schema = {u"dependencies": {depend: on}} message = self.message_for( instance={"bar": 2}, schema=schema, cls=validators.Draft3Validator, ) self.assertEqual(message, "%r is a dependency of %r" % (on, depend)) def test_dependencies_list_draft3(self): depend, on = "bar", "foo" schema = {u"dependencies": {depend: [on]}} message = self.message_for( instance={"bar": 2}, schema=schema, cls=validators.Draft3Validator, ) self.assertEqual(message, "%r is a dependency of %r" % (on, depend)) def test_dependencies_list_draft7(self): depend, on = "bar", "foo" schema = {u"dependencies": {depend: [on]}} message = self.message_for( instance={"bar": 2}, schema=schema, cls=validators.Draft7Validator, ) self.assertEqual(message, "%r is a dependency of %r" % (on, depend)) def test_additionalItems_single_failure(self): message = self.message_for( instance=[2], schema={u"items": [], u"additionalItems": False}, ) self.assertIn("(2 was unexpected)", message) def test_additionalItems_multiple_failures(self): message = self.message_for( instance=[1, 2, 3], schema={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(instance={additional: 2}, schema=schema) self.assertIn("(%r was unexpected)" % (additional,), message) def test_additionalProperties_multiple_failures(self): schema = {u"additionalProperties": False} message = self.message_for( instance=dict.fromkeys(["foo", "bar"]), schema=schema, ) self.assertIn(repr("foo"), message) self.assertIn(repr("bar"), message) self.assertIn("were unexpected)", message) def test_const(self): schema = {u"const": 12} message = self.message_for( instance={"foo": "bar"}, schema=schema, cls=validators.Draft6Validator, ) self.assertIn("12 was expected", message) def test_contains(self): schema = {u"contains": {u"const": 12}} message = self.message_for( instance=[2, {}, []], schema=schema, cls=validators.Draft6Validator, ) self.assertIn( "None of [2, {}, []] are valid under the given schema", message, ) def test_invalid_format_default_message(self): checker = FormatChecker(formats=()) checker.checks(u"thing")(lambda value: False) schema = {u"format": u"thing"} message = self.message_for( instance="bla", schema=schema, format_checker=checker, ) self.assertIn(repr("bla"), message) self.assertIn(repr("thing"), message) self.assertIn("is not a", message) def test_additionalProperties_false_patternProperties(self): schema = {u"type": u"object", u"additionalProperties": False, u"patternProperties": { u"^abc$": {u"type": u"string"}, u"^def$": {u"type": u"string"}, }} message = self.message_for( instance={u"zebra": 123}, schema=schema, cls=validators.Draft4Validator, ) self.assertEqual( message, "{} does not match any of the regexes: {}, {}".format( repr(u"zebra"), repr(u"^abc$"), repr(u"^def$"), ), ) message = self.message_for( instance={u"zebra": 123, u"fish": 456}, schema=schema, cls=validators.Draft4Validator, ) self.assertEqual( message, "{}, {} do not match any of the regexes: {}, {}".format( repr(u"fish"), repr(u"zebra"), repr(u"^abc$"), repr(u"^def$") ), ) def test_False_schema(self): message = self.message_for( instance="something", schema=False, cls=validators.Draft7Validator, ) self.assertIn("False schema does not allow 'something'", message) class TestValidationErrorDetails(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 = validators.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 = validators.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 = validators.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 = validators.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 = validators.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 = validators.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 = validators.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 = validators.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 = validators.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") def test_propertyNames(self): instance = {"foo": 12} schema = {"propertyNames": {"not": {"const": "foo"}}} validator = validators.Draft7Validator(schema) error, = validator.iter_errors(instance) self.assertEqual(error.validator, "not") self.assertEqual( error.message, "%r is not allowed for %r" % ({"const": "foo"}, "foo"), ) self.assertEqual(error.path, deque([])) self.assertEqual(error.schema_path, deque(["propertyNames", "not"])) def test_if_then(self): schema = { "if": {"const": 12}, "then": {"const": 13}, } validator = validators.Draft7Validator(schema) error, = validator.iter_errors(12) self.assertEqual(error.validator, "const") self.assertEqual(error.message, "13 was expected") self.assertEqual(error.path, deque([])) self.assertEqual(error.schema_path, deque(["if", "then", "const"])) def test_if_else(self): schema = { "if": {"const": 12}, "else": {"const": 13}, } validator = validators.Draft7Validator(schema) error, = validator.iter_errors(15) self.assertEqual(error.validator, "const") self.assertEqual(error.message, "13 was expected") self.assertEqual(error.path, deque([])) self.assertEqual(error.schema_path, deque(["if", "else", "const"])) def test_boolean_schema_False(self): validator = validators.Draft7Validator(False) error, = validator.iter_errors(12) self.assertEqual( ( error.message, error.validator, error.validator_value, error.instance, error.schema, error.schema_path, ), ( "False schema does not allow 12", None, None, 12, False, deque([]), ), ) def test_ref(self): ref, schema = "someRef", {"additionalProperties": {"type": "integer"}} validator = validators.Draft7Validator( {"$ref": ref}, resolver=validators.RefResolver("", {}, store={ref: schema}), ) error, = validator.iter_errors({"foo": "notAnInteger"}) self.assertEqual( ( error.message, error.validator, error.validator_value, error.instance, error.absolute_path, error.schema, error.schema_path, ), ( "'notAnInteger' is not of type 'integer'", "type", "integer", "notAnInteger", deque(["foo"]), {"type": "integer"}, deque(["additionalProperties", "type"]), ), ) class MetaSchemaTestsMixin(object): # TODO: These all belong upstream def test_invalid_properties(self): with self.assertRaises(exceptions.SchemaError): self.Validator.check_schema({"properties": {"test": object()}}) def test_minItems_invalid_string(self): with self.assertRaises(exceptions.SchemaError): # needs to be an integer self.Validator.check_schema({"minItems": "1"}) def test_enum_allows_empty_arrays(self): """ Technically, all the spec says is they SHOULD have elements, not MUST. See https://github.com/Julian/jsonschema/issues/529. """ self.Validator.check_schema({"enum": []}) def test_enum_allows_non_unique_items(self): """ Technically, all the spec says is they SHOULD be unique, not MUST. See https://github.com/Julian/jsonschema/issues/529. """ self.Validator.check_schema({"enum": [12, 12]}) class ValidatorTestMixin(MetaSchemaTestsMixin, object): def test_valid_instances_are_valid(self): schema, instance = self.valid self.assertTrue(self.Validator(schema).is_valid(instance)) def test_invalid_instances_are_not_valid(self): schema, instance = self.invalid self.assertFalse(self.Validator(schema).is_valid(instance)) def test_non_existent_properties_are_ignored(self): self.Validator({object(): object()}).validate(instance=object()) def test_it_creates_a_ref_resolver_if_not_provided(self): self.assertIsInstance( self.Validator({}).resolver, validators.RefResolver, ) def test_it_delegates_to_a_ref_resolver(self): ref, schema = "someCoolRef", {"type": "integer"} resolver = validators.RefResolver("", {}, store={ref: schema}) validator = self.Validator({"$ref": ref}, resolver=resolver) with self.assertRaises(exceptions.ValidationError): validator.validate(None) def test_it_delegates_to_a_legacy_ref_resolver(self): """ Legacy RefResolvers support only the context manager form of resolution. """ class LegacyRefResolver(object): @contextmanager def resolving(this, ref): self.assertEqual(ref, "the ref") yield {"type": "integer"} resolver = LegacyRefResolver() schema = {"$ref": "the ref"} with self.assertRaises(exceptions.ValidationError): self.Validator(schema, resolver=resolver).validate(None) 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")) @unittest.skipIf(PY3, "In Python 3 json.load always produces unicode") def test_string_a_bytestring_is_a_string(self): self.Validator({"type": "string"}).validate(b"foo") def test_patterns_can_be_native_strings(self): """ See https://github.com/Julian/jsonschema/issues/611. """ self.Validator({"pattern": "foo"}).validate("foo") def test_it_can_validate_with_decimals(self): schema = {"items": {"type": "number"}} Validator = validators.extend( self.Validator, type_checker=self.Validator.TYPE_CHECKER.redefine( "number", lambda checker, thing: isinstance( thing, (int, float, Decimal), ) and not isinstance(thing, bool), ) ) validator = Validator(schema) validator.validate([1, 1.1, Decimal(1) / Decimal(8)]) invalid = ["foo", {}, [], True, None] self.assertEqual( [error.instance for error in validator.iter_errors(invalid)], invalid, ) def test_it_returns_true_for_formats_it_does_not_know_about(self): validator = self.Validator( {"format": "carrot"}, format_checker=FormatChecker(), ) validator.validate("bugs") def test_it_does_not_validate_formats_by_default(self): validator = self.Validator({}) self.assertIsNone(validator.format_checker) def test_it_validates_formats_if_a_checker_is_provided(self): checker = FormatChecker() bad = ValueError("Bad!") @checker.checks("foo", raises=ValueError) def check(value): if value == "good": return True elif value == "bad": raise bad else: # pragma: no cover self.fail("What is {}? [Baby Don't Hurt Me]".format(value)) validator = self.Validator( {"format": "foo"}, format_checker=checker, ) validator.validate("good") with self.assertRaises(exceptions.ValidationError) as cm: validator.validate("bad") # Make sure original cause is attached self.assertIs(cm.exception.cause, bad) def test_non_string_custom_type(self): non_string_type = object() schema = {"type": [non_string_type]} Crazy = validators.extend( self.Validator, type_checker=self.Validator.TYPE_CHECKER.redefine( non_string_type, lambda checker, thing: isinstance(thing, int), ) ) Crazy(schema).validate(15) def test_it_properly_formats_tuples_in_errors(self): """ A tuple instance properly formats validation errors for uniqueItems. See https://github.com/Julian/jsonschema/pull/224 """ TupleValidator = validators.extend( self.Validator, type_checker=self.Validator.TYPE_CHECKER.redefine( "array", lambda checker, thing: isinstance(thing, tuple), ) ) with self.assertRaises(exceptions.ValidationError) as e: TupleValidator({"uniqueItems": True}).validate((1, 1)) self.assertIn("(1, 1) has non-unique elements", str(e.exception)) class AntiDraft6LeakMixin(object): """ Make sure functionality from draft 6 doesn't leak backwards in time. """ def test_True_is_not_a_schema(self): with self.assertRaises(exceptions.SchemaError) as e: self.Validator.check_schema(True) self.assertIn("True is not of type", str(e.exception)) def test_False_is_not_a_schema(self): with self.assertRaises(exceptions.SchemaError) as e: self.Validator.check_schema(False) self.assertIn("False is not of type", str(e.exception)) @unittest.skip(bug(523)) def test_True_is_not_a_schema_even_if_you_forget_to_check(self): resolver = validators.RefResolver("", {}) with self.assertRaises(Exception) as e: self.Validator(True, resolver=resolver).validate(12) self.assertNotIsInstance(e.exception, exceptions.ValidationError) @unittest.skip(bug(523)) def test_False_is_not_a_schema_even_if_you_forget_to_check(self): resolver = validators.RefResolver("", {}) with self.assertRaises(Exception) as e: self.Validator(False, resolver=resolver).validate(12) self.assertNotIsInstance(e.exception, exceptions.ValidationError) class TestDraft3Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase): Validator = validators.Draft3Validator valid = {}, {} invalid = {"type": "integer"}, "foo" def test_any_type_is_valid_for_type_any(self): validator = self.Validator({"type": "any"}) validator.validate(object()) def test_any_type_is_redefinable(self): """ Sigh, because why not. """ Crazy = validators.extend( self.Validator, type_checker=self.Validator.TYPE_CHECKER.redefine( "any", lambda checker, thing: isinstance(thing, int), ) ) validator = Crazy({"type": "any"}) validator.validate(12) with self.assertRaises(exceptions.ValidationError): validator.validate("foo") def test_is_type_is_true_for_any_type(self): self.assertTrue(self.Validator({}).is_valid(object(), {"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"})) class TestDraft4Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase): Validator = validators.Draft4Validator valid = {}, {} invalid = {"type": "integer"}, "foo" class TestDraft6Validator(ValidatorTestMixin, TestCase): Validator = validators.Draft6Validator valid = {}, {} invalid = {"type": "integer"}, "foo" class TestDraft7Validator(ValidatorTestMixin, TestCase): Validator = validators.Draft7Validator valid = {}, {} invalid = {"type": "integer"}, "foo" class TestValidatorFor(SynchronousTestCase): def test_draft_3(self): schema = {"$schema": "http://json-schema.org/draft-03/schema"} self.assertIs( validators.validator_for(schema), validators.Draft3Validator, ) schema = {"$schema": "http://json-schema.org/draft-03/schema#"} self.assertIs( validators.validator_for(schema), validators.Draft3Validator, ) def test_draft_4(self): schema = {"$schema": "http://json-schema.org/draft-04/schema"} self.assertIs( validators.validator_for(schema), validators.Draft4Validator, ) schema = {"$schema": "http://json-schema.org/draft-04/schema#"} self.assertIs( validators.validator_for(schema), validators.Draft4Validator, ) def test_draft_6(self): schema = {"$schema": "http://json-schema.org/draft-06/schema"} self.assertIs( validators.validator_for(schema), validators.Draft6Validator, ) schema = {"$schema": "http://json-schema.org/draft-06/schema#"} self.assertIs( validators.validator_for(schema), validators.Draft6Validator, ) def test_draft_7(self): schema = {"$schema": "http://json-schema.org/draft-07/schema"} self.assertIs( validators.validator_for(schema), validators.Draft7Validator, ) schema = {"$schema": "http://json-schema.org/draft-07/schema#"} self.assertIs( validators.validator_for(schema), validators.Draft7Validator, ) def test_True(self): self.assertIs( validators.validator_for(True), validators._LATEST_VERSION, ) def test_False(self): self.assertIs( validators.validator_for(False), validators._LATEST_VERSION, ) def test_custom_validator(self): Validator = validators.create( meta_schema={"id": "meta schema id"}, version="12", id_of=lambda s: s.get("id", ""), ) schema = {"$schema": "meta schema id"} self.assertIs( validators.validator_for(schema), Validator, ) def test_custom_validator_draft6(self): Validator = validators.create( meta_schema={"$id": "meta schema $id"}, version="13", ) schema = {"$schema": "meta schema $id"} self.assertIs( validators.validator_for(schema), Validator, ) def test_validator_for_jsonschema_default(self): self.assertIs(validators.validator_for({}), validators._LATEST_VERSION) def test_validator_for_custom_default(self): self.assertIs(validators.validator_for({}, default=None), None) def test_warns_if_meta_schema_specified_was_not_found(self): self.assertWarns( category=DeprecationWarning, message=( "The metaschema specified by $schema was not found. " "Using the latest draft to validate, but this will raise " "an error in the future." ), # https://tm.tl/9363 :'( filename=sys.modules[self.assertWarns.__module__].__file__, f=validators.validator_for, schema={u"$schema": "unknownSchema"}, default={}, ) def test_does_not_warn_if_meta_schema_is_unspecified(self): validators.validator_for(schema={}, default={}), self.assertFalse(self.flushWarnings()) class TestValidate(SynchronousTestCase): def assertUses(self, schema, Validator): result = [] self.patch(Validator, "check_schema", result.append) validators.validate({}, schema) self.assertEqual(result, [schema]) def test_draft3_validator_is_chosen(self): self.assertUses( schema={"$schema": "http://json-schema.org/draft-03/schema#"}, Validator=validators.Draft3Validator, ) # Make sure it works without the empty fragment self.assertUses( schema={"$schema": "http://json-schema.org/draft-03/schema"}, Validator=validators.Draft3Validator, ) def test_draft4_validator_is_chosen(self): self.assertUses( schema={"$schema": "http://json-schema.org/draft-04/schema#"}, Validator=validators.Draft4Validator, ) # Make sure it works without the empty fragment self.assertUses( schema={"$schema": "http://json-schema.org/draft-04/schema"}, Validator=validators.Draft4Validator, ) def test_draft6_validator_is_chosen(self): self.assertUses( schema={"$schema": "http://json-schema.org/draft-06/schema#"}, Validator=validators.Draft6Validator, ) # Make sure it works without the empty fragment self.assertUses( schema={"$schema": "http://json-schema.org/draft-06/schema"}, Validator=validators.Draft6Validator, ) def test_draft7_validator_is_chosen(self): self.assertUses( schema={"$schema": "http://json-schema.org/draft-07/schema#"}, Validator=validators.Draft7Validator, ) # Make sure it works without the empty fragment self.assertUses( schema={"$schema": "http://json-schema.org/draft-07/schema"}, Validator=validators.Draft7Validator, ) def test_draft7_validator_is_the_default(self): self.assertUses(schema={}, Validator=validators.Draft7Validator) def test_validation_error_message(self): with self.assertRaises(exceptions.ValidationError) as e: validators.validate(12, {"type": "string"}) self.assertRegexpMatches( str(e.exception), "(?s)Failed validating u?'.' in schema.On instance", ) def test_schema_error_message(self): with self.assertRaises(exceptions.SchemaError) as e: validators.validate(12, {"type": 12}) self.assertRegexpMatches( str(e.exception), "(?s)Failed validating u?'.' in metaschema.On schema", ) def test_it_uses_best_match(self): # This is a schema that best_match will recurse into schema = {"oneOf": [{"type": "string"}, {"type": "array"}]} with self.assertRaises(exceptions.ValidationError) as e: validators.validate(12, schema) self.assertIn("12 is not of type", str(e.exception)) class TestRefResolver(SynchronousTestCase): 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 = validators.RefResolver( self.base_uri, self.referrer, self.store, ) def test_it_does_not_retrieve_schema_urls_from_the_network(self): ref = validators.Draft3Validator.META_SCHEMA["id"] self.patch( self.resolver, "resolve_remote", lambda args, **kwargs: self.fail("Should not have been called!"), ) with self.resolver.resolving(ref) as resolved: pass self.assertEqual(resolved, validators.Draft3Validator.META_SCHEMA) 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 = validators.RefResolver.from_schema( schema, id_of=lambda schema: schema.get(u"id", u""), ) 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} if "requests" in sys.modules: self.addCleanup( sys.modules.__setitem__, "requests", sys.modules["requests"], ) sys.modules["requests"] = ReallyFakeRequests({"http://bar": schema}) with self.resolver.resolving(ref) as resolved: self.assertEqual(resolved, 12) def test_it_retrieves_unstored_refs_via_urlopen(self): ref = "http://bar#baz" schema = {"baz": 12} if "requests" in sys.modules: self.addCleanup( sys.modules.__setitem__, "requests", sys.modules["requests"], ) sys.modules["requests"] = None @contextmanager def fake_urlopen(url): self.assertEqual(url, "http://bar") yield BytesIO(json.dumps(schema).encode("utf8")) self.addCleanup(setattr, validators, "urlopen", validators.urlopen) validators.urlopen = fake_urlopen with self.resolver.resolving(ref) as resolved: pass self.assertEqual(resolved, 12) def test_it_retrieves_local_refs_via_urlopen(self): with tempfile.NamedTemporaryFile(delete=False, mode="wt") as tempf: self.addCleanup(os.remove, tempf.name) json.dump({"foo": "bar"}, tempf) ref = "file://{}#foo".format(pathname2url(tempf.name)) with self.resolver.resolving(ref) as resolved: self.assertEqual(resolved, "bar") def test_it_can_construct_a_base_uri_from_a_schema(self): schema = {"id": "foo"} resolver = validators.RefResolver.from_schema( schema, id_of=lambda schema: schema.get(u"id", u""), ) 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 = validators.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): def handler(url): self.assertEqual(url, ref) return schema schema = {"foo": "bar"} ref = "foo://bar" resolver = validators.RefResolver("", {}, handlers={"foo": handler}) with resolver.resolving(ref) as resolved: self.assertEqual(resolved, schema) def test_cache_remote_on(self): response = [object()] def handler(url): try: return response.pop() except IndexError: # pragma: no cover self.fail("Response must not have been cached!") ref = "foo://bar" resolver = validators.RefResolver( "", {}, cache_remote=True, handlers={"foo": handler}, ) with resolver.resolving(ref): pass with resolver.resolving(ref): pass def test_cache_remote_off(self): response = [object()] def handler(url): try: return response.pop() except IndexError: # pragma: no cover self.fail("Handler called twice!") ref = "foo://bar" resolver = validators.RefResolver( "", {}, cache_remote=False, handlers={"foo": handler}, ) with resolver.resolving(ref): pass def test_if_you_give_it_junk_you_get_a_resolution_error(self): error = ValueError("Oh no! What's this?") def handler(url): raise error ref = "foo://bar" resolver = validators.RefResolver("", {}, handlers={"foo": handler}) with self.assertRaises(exceptions.RefResolutionError) as err: with resolver.resolving(ref): self.fail("Shouldn't get this far!") # pragma: no cover self.assertEqual(err.exception, exceptions.RefResolutionError(error)) def test_helpful_error_message_on_failed_pop_scope(self): resolver = validators.RefResolver("", {}) resolver.pop_scope() with self.assertRaises(exceptions.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) @attr.s class ReallyFakeRequests(object): _responses = attr.ib() def get(self, url): response = self._responses.get(url) if url is None: # pragma: no cover raise ValueError("Unknown URL: " + repr(url)) return _ReallyFakeJSONResponse(json.dumps(response)) @attr.s class _ReallyFakeJSONResponse(object): _response = attr.ib() def json(self): return json.loads(self._response)	58.98 KB	2026-01-20 12:58

Terminal