Extend sequance and mapping check

nezhar · nezhar · commit 27661b2f9460 · 2021-07-02T13:41:18.000+02:00
diff --git a/jsonschema/_utils.py b/jsonschema/_utils.py
@@ -1,5 +1,6 @@
 from collections.abc import MutableMapping
 from urllib.parse import urlsplit
+import collections
 import itertools
 import json
 import pkgutil
@@ -188,14 +189,32 @@ def list_equal(one, two):
     return True
 
 
+def is_sequence(instance):
+    """
+    Checks if an instance is a sequence but not a string
+    """
+    return isinstance(
+        instance, collections.Sequence
+    ) and not isinstance(
+        instance, str
+    )
+
+
+def is_mapping(instance):
+    """
+    Checks if an instance is a mapping
+    """
+    return isinstance(instance, collections.Mapping)
+
+
 def equal(one, two):
     """
     Check if two things are equal, but evade booleans and ints being equal.
     """
-    if isinstance(one, list) and isinstance(two, list):
+    if is_sequence(one) and is_sequence(two):
         return list_equal(one, two)
 
-    if isinstance(one, dict) and isinstance(two, dict):
+    if is_mapping(one) and is_mapping(two):
         return dict_equal(one, two)
 
     return unbool(one) == unbool(two)
@@ -225,18 +244,15 @@ def uniq(container):
         sliced = itertools.islice(sort, 1, None)
 
         for i, j in zip(sort, sliced):
-            return not list_equal(list(i), list(j))
+            return not list_equal(i, j)
 
     except (NotImplementedError, TypeError):
         seen = []
         for e in container:
             e = unbool(e)
 
             for i in seen:
-                if isinstance(i, dict) and isinstance(e, dict):
-                    if dict_equal(i, e):
-                        return False
-                elif i == e:
+                if equal(i, e):
                     return False
 
             seen.append(e)
diff --git a/jsonschema/tests/test_validators.py b/jsonschema/tests/test_validators.py
@@ -1096,33 +1096,72 @@ def test_check_redefined_sequence(self):
             "type": "array",
             "uniqueItems": True
         }
-
         MyMapping = namedtuple('MyMapping', 'a, b')
-
         Validator = validators.extend(
             self.Validator,
-            type_checker=self.Validator.TYPE_CHECKER.redefine(
-                "array",
-                lambda checker, thing: isinstance(thing, (list, deque)),
-            )
+            type_checker=self.Validator.TYPE_CHECKER.redefine_many({
+                "array": lambda checker, thing: isinstance(
+                    thing, (list, deque)
+                ),
+                "object": lambda checker, thing: isinstance(
+                    thing, (dict, MyMapping)
+                ),
+            })
         )
-
         validator = Validator(schema)
-        validator.validate(deque(['a', None, '1', '', True]))
-        with self.assertRaises(exceptions.ValidationError):
-            validator.validate(deque(['a', 'b', 'a']))
 
-        validator.validate(deque([[False], [0]]))
-        with self.assertRaises(exceptions.ValidationError):
-            validator.validate(deque([[False], [False]]))
+        valid_instances = [
+            deque(['a', None, '1', '', True]),
+            deque([[False], [0]]),
+            [deque([False]), deque([0])],
+            [[deque([False])], [deque([0])]],
+            [[[[[deque([False])]]]], [[[[deque([0])]]]]],
+            [deque([deque([False])]), deque([deque([0])])],
+            [MyMapping('a', 0), MyMapping('a', False)],
+            [
+                MyMapping('a', [deque([0])]),
+                MyMapping('a', [deque([False])])
+            ],
+            [
+                MyMapping('a', [
+                    MyMapping('a', deque([0]))
+                ]),
+                MyMapping('a', [
+                    MyMapping('a', deque([False]))
+                ])
+            ],
+            [deque(deque(deque([False]))), deque(deque(deque([0])))],
+        ]
 
-        validator.validate([deque([False]), deque([0])])
-        with self.assertRaises(exceptions.ValidationError):
-            validator.validate([deque([False]), deque([False])])
+        for instance in valid_instances:
+            validator.validate(instance)
+
+        invalid_instances = [
+            deque(['a', 'b', 'a']),
+            deque([[False], [False]]),
+            [deque([False]), deque([False])],
+            [[deque([False])], [deque([False])]],
+            [[[[[deque([False])]]]], [[[[deque([False])]]]]],
+            [deque([deque([False])]), deque([deque([False])])],
+            [MyMapping('a', False), MyMapping('a', False)],
+            [
+                MyMapping('a', [deque([False])]),
+                MyMapping('a', [deque([False])])
+            ],
+            [
+                MyMapping('a', [
+                    MyMapping('a', deque([False]))
+                ]),
+                MyMapping('a', [
+                    MyMapping('a', deque([False]))
+                ])
+            ],
+            [deque(deque(deque([False]))), deque(deque(deque([False])))],
+        ]
 
-        validator.validate([MyMapping('a', 0), MyMapping('a', False)])
-        with self.assertRaises(exceptions.ValidationError):
-            validator.validate([MyMapping('a', False), MyMapping('a', False)])
+        for instance in invalid_instances:
+            with self.assertRaises(exceptions.ValidationError):
+                validator.validate(instance)
 
 
 class AntiDraft6LeakMixin(object):
