Merge branch 'master' of https://github.com/Julian/jsonschema into regex_value_validation

Author: manycoding

README.rst

@@ -72,6 +72,16 @@ Features
   of which properties or items failed validation.
 
 
+Installation
+------------
+
+``jsonschema`` is available on `PyPI <https://pypi.org/project/jsonschema/>`_. You can install using `pip <https://pip.pypa.io/en/stable/>`_:
+
+.. code-block:: bash
+
+    $ pip install jsonschema
+
+
 Release Notes
 -------------
 

jsonschema/_utils.py

@@ -3,7 +3,7 @@
 import pkgutil
 import re
 
-from jsonschema.compat import str_types, MutableMapping, urlsplit
+from jsonschema.compat import MutableMapping, str_types, urlsplit
 
 
 class URIDict(MutableMapping):

jsonschema/compat.py

@@ -1,3 +1,8 @@
+"""
+Python 2/3 compatibility helpers.
+
+Note: This module is *not* public API.
+"""
 import contextlib
 import operator
 import sys
@@ -17,7 +22,7 @@
     from urllib.parse import (
         unquote, urljoin, urlunsplit, SplitResult, urlsplit as _urlsplit
     )
-    from urllib.request import urlopen
+    from urllib.request import pathname2url, urlopen
     str_types = str,
     int_types = int,
     iteritems = operator.methodcaller("items")
@@ -27,7 +32,7 @@
     from urlparse import (
         urljoin, urlunsplit, SplitResult, urlsplit as _urlsplit # noqa
     )
-    from urllib import unquote  # noqa
+    from urllib import pathname2url, unquote  # noqa
     import urllib2  # noqa
     def urlopen(*args, **kwargs):
         return contextlib.closing(urllib2.urlopen(*args, **kwargs))

jsonschema/tests/test_jsonschema_test_suite.py

@@ -7,6 +7,7 @@
 """
 
 import sys
+import warnings
 
 from jsonschema import (
     Draft3Validator,
@@ -173,27 +174,29 @@ def narrow_unicode_build(test):  # pragma: no cover
 )
 
 
-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,
-    ),
-)
-
+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,
-    ),
-)
+    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,
+        ),
+    )

jsonschema/tests/test_validators.py

@@ -20,22 +20,16 @@
     _types,
     validators,
 )
-from jsonschema.compat import PY3
+from jsonschema.compat import PY3, pathname2url
 from jsonschema.tests.compat import mock
 
 
-if PY3:
-    from urllib.request import pathname2url
-else:
-    from urllib import pathname2url
-
-
 def startswith(validator, startswith, instance, schema):
     if not instance.startswith(startswith):
         yield ValidationError(u"Whoops!")
 
 
-class TestCreateAndExtend(TestCase):
+class TestCreateAndExtend(SynchronousTestCase):
     def setUp(self):
         self.addCleanup(
             self.assertEqual,
@@ -53,14 +47,23 @@ def setUp(self):
         )
 
     def test_attrs(self):
-        self.assertEqual(self.Validator.VALIDATORS, self.validators)
-        self.assertEqual(self.Validator.META_SCHEMA, self.meta_schema)
-        self.assertEqual(self.Validator.TYPE_CHECKER, self.type_checker)
+        self.assertEqual(
+            (
+                self.Validator.VALIDATORS,
+                self.Validator.META_SCHEMA,
+                self.Validator.TYPE_CHECKER,
+            ), (
+                self.validators,
+                self.meta_schema,
+                self.type_checker,
+            ),
+        )
 
         # Default types should still be set to the old default if not provided
         expected_types = {u"array", u"boolean", u"integer", u"null", u"number",
                           u"object", u"string"}
         self.assertEqual(set(self.Validator.DEFAULT_TYPES), expected_types)
+        self.assertEqual(len(self.flushWarnings()), 1)
 
     def test_init(self):
         schema = {u"startswith": u"foo"}
@@ -132,15 +135,19 @@ def test_extend(self):
             (
                 Extended.VALIDATORS,
                 Extended.META_SCHEMA,
-                Extended.DEFAULT_TYPES,
                 Extended.TYPE_CHECKER,
                 self.Validator.VALIDATORS,
+
+                Extended.DEFAULT_TYPES,
+                self.flushWarnings()[0]["message"],
             ), (
                 dict(original, new=new),
                 self.Validator.META_SCHEMA,
-                self.Validator.DEFAULT_TYPES,
                 self.Validator.TYPE_CHECKER,
                 original,
+
+                self.Validator.DEFAULT_TYPES,
+                self.flushWarnings()[0]["message"],
             ),
         )
 
@@ -922,7 +929,7 @@ def test_valid_instances_are_valid(self):
             )
 
     def test_invalid_instances_are_not_valid(self):
-        errors = iter([mock.Mock()])
+        errors = iter([ValidationError("An error!")])
 
         with mock.patch.object(
             self.validator, "iter_errors", return_value=errors,
@@ -979,17 +986,25 @@ def test_string_a_bytestring_is_a_string(self):
         self.Validator({"type": "string"}).validate(b"foo")
 
     def test_it_can_validate_with_decimals(self):
-        schema = {"type": "number"}
-        validator = self.Validator(
-            schema, types={"number": (int, float, Decimal)}
+        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),
+            )
         )
 
-        for valid in [1, 1.1, Decimal(1) / Decimal(8)]:
-            validator.validate(valid)
+        validator = Validator(schema)
+        validator.validate([1, 1.1, Decimal(1) / Decimal(8)])
 
-        for invalid in ["foo", {}, [], True, None]:
-            with self.assertRaises(ValidationError):
-                validator.validate(invalid)
+        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(
@@ -1025,6 +1040,35 @@ def check(value):
         # 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(ValidationError) as e:
+            TupleValidator({"uniqueItems": True}).validate((1, 1))
+        self.assertIn("(1, 1) has non-unique elements", str(e.exception))
+
 
 class AntiDraft6LeakMixin(object):
     """
@@ -1083,11 +1127,6 @@ def test_is_type_does_not_evade_bool_if_it_is_being_tested(self):
         self.assertTrue(self.validator.is_type(True, "boolean"))
         self.assertTrue(self.validator.is_valid(True, {"type": "any"}))
 
-    def test_non_string_custom_types(self):
-        schema = {'type': [None]}
-        cls = self.Validator(schema, types={None: type(None)})
-        cls.validate(None, schema)
-
 
 class TestDraft4Validator(AntiDraft6LeakMixin, ValidatorTestMixin, TestCase):
     Validator = validators.Draft4Validator
@@ -1097,6 +1136,10 @@ class TestDraft6Validator(ValidatorTestMixin, TestCase):
     Validator = validators.Draft6Validator
 
 
+class TestDraft7Validator(ValidatorTestMixin, TestCase):
+    Validator = validators.Draft7Validator
+
+
 class TestBuiltinFormats(TestCase):
     """
     The built-in (specification-defined) formats do not raise type errors.
@@ -1490,35 +1533,6 @@ def test_helpful_error_message_on_failed_pop_scope(self):
         self.assertIn("Failed to pop the scope", str(exc.exception))
 
 
-class UniqueTupleItemsMixin(object):
-    """
-    A tuple instance properly formats validation errors for uniqueItems.
-
-    See https://github.com/Julian/jsonschema/pull/224
-    """
-
-    def test_it_properly_formats_an_error_message(self):
-        validator = self.Validator(
-            schema={"uniqueItems": True},
-            types={"array": (tuple,)},
-        )
-        with self.assertRaises(ValidationError) as e:
-            validator.validate((1, 1))
-        self.assertIn("(1, 1) has non-unique elements", str(e.exception))
-
-
-class TestDraft6UniqueTupleItems(UniqueTupleItemsMixin, TestCase):
-    Validator = validators.Draft6Validator
-
-
-class TestDraft4UniqueTupleItems(UniqueTupleItemsMixin, TestCase):
-    Validator = validators.Draft4Validator
-
-
-class TestDraft3UniqueTupleItems(UniqueTupleItemsMixin, TestCase):
-    Validator = validators.Draft3Validator
-
-
 def sorted_errors(errors):
     def key(error):
         return (

jsonschema/validators.py

@@ -9,8 +9,16 @@
 
 from jsonschema import _utils, _validators, _types
 from jsonschema.compat import (
-    Sequence, urljoin, urlsplit, urldefrag, unquote, urlopen,
-    str_types, int_types, iteritems, lru_cache,
+    Sequence,
+    int_types,
+    iteritems,
+    lru_cache,
+    str_types,
+    unquote,
+    urldefrag,
+    urljoin,
+    urlopen,
+    urlsplit,
 )
 from jsonschema.exceptions import (
     RefResolutionError,