Renamed and expanded the use of user-defined exceptions for corner cases

Author: andrewhabib

jsonsubschema/_canonicalization.py

@@ -301,8 +301,7 @@ def rewrite_enum(d):
 
     # Unsupported cases of rewriting enums
     elif t == 'array' or t == 'object':
-        raise UnexpectedCanonicalization(
-            msg='Rewriting the following enum is not supported.', tau=t, schema=d)
+        raise UnsupportedEnumCanonicalization(tau=t, schema=d)
 
 
 def simplify_schema_and_embed_checkers(s):

jsonsubschema/_checkers.py

@@ -1450,7 +1450,12 @@ def neg(s):
         #     if s.__getattr__(k) != default:
         #         break
         # else:
-        return None
+        if s.keys() & definitions.JtypesToKeywords['object']:
+            raise UnsupportedNegatedObject(schema=s)
+        else: 
+             return boolToConstructor.get("anyOf")(
+            {"anyOf": get_default_types_except("object")})
+
 
 
 def JSONanyOfFactory(s):

jsonsubschema/exceptions.py

@@ -4,11 +4,19 @@
 '''
 
 
-class _Error(Exception):
+class _UnsupportedCase(Exception):
     pass
 
 
-class UnsupportedRecursiveRef(_Error):
+class _CanonicalizationError(_UnsupportedCase):
+    pass
+
+
+class _SubtypeCheckError(_UnsupportedCase):
+    pass
+
+
+class UnsupportedRecursiveRef(_CanonicalizationError):
     def __init__(self, schema, which_side):
         self.schema = schema
         self.which_side = which_side
@@ -17,16 +25,32 @@ def __str__(self):
         return f'Recursive schemas are not supported. {self.which_side} is recursive.'
 
 
-class UnexpectedCanonicalization(_Error):
+class UnsupportedEnumCanonicalization(_CanonicalizationError):
 
-    def __init__(self, msg, tau, schema):
-        self.msg = msg
+    def __init__(self, tau, schema):
         self.tau = tau
         self.schema = schema
 
     def __str__(self):
-        return '{}\n"type": {} \n"schema": {}'.format(self.msg, self.tau, self.schema)
+        return f'Canonicalizing an enum schema of type {self.tau} is not supported.'
+
 
+class UnsupportedNegatedObject(_SubtypeCheckError):
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def __str__(self):
+        return f'Object negation at {self.schema} is not supported.'
+
+
+class UnsupportedNegatedArray(_SubtypeCheckError):
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def __str__(self):
+        return f'Array negation at {self.schema} is not supported.'
 
 # class UnsupportedSchemaType(_Error):
 #     '''

test/test_enum.py

@@ -6,7 +6,7 @@
 import unittest
 
 from jsonsubschema import isSubschema
-from jsonsubschema.exceptions import UnexpectedCanonicalization
+from jsonsubschema.exceptions import UnsupportedEnumCanonicalization
 
 
 class TestEnum(unittest.TestCase):
@@ -91,10 +91,11 @@ def test_array(self):
         s2 = {'type': 'array'}
 
         with self.subTest():
-            self.assertRaises(UnexpectedCanonicalization, isSubschema, s1, s2)
+            self.assertRaises(UnsupportedEnumCanonicalization,
+                              isSubschema, s1, s2)
 
-        with self.subTest(): # To test prining the exception msg
-            with self.assertRaises(UnexpectedCanonicalization) as ctxt:
+        with self.subTest():  # To test prining the exception msg
+            with self.assertRaises(UnsupportedEnumCanonicalization) as ctxt:
                 isSubschema(s2, s1)
             print(ctxt.exception)
 
@@ -103,9 +104,10 @@ def test_object(self):
         s2 = {'type': 'object'}
 
         with self.subTest():
-            self.assertRaises(UnexpectedCanonicalization, isSubschema, s1, s2)
+            self.assertRaises(UnsupportedEnumCanonicalization,
+                              isSubschema, s1, s2)
 
-        with self.subTest(): # To test prining the exception msg
-            with self.assertRaises(UnexpectedCanonicalization) as ctxt:
+        with self.subTest():  # To test prining the exception msg
+            with self.assertRaises(UnsupportedEnumCanonicalization) as ctxt:
                 isSubschema(s2, s1)
-            print(ctxt.exception)
+            print(ctxt.exception)

test/test_refs.py

@@ -6,6 +6,7 @@
 import unittest
 
 from jsonsubschema import isSubschema
+from jsonsubschema.exceptions import UnsupportedRecursiveRef
 
 
 class TestSimpleRefs(unittest.TestCase):
@@ -89,7 +90,7 @@ def test_1(self):
         with self.subTest():
             self.assertFalse(isSubschema(s2, s4))
 
-    @unittest.skip("Unsupported recursive/circular $ref")
+    @unittest.skip("Recursive schema; fails due to jsonschema failure case, not us")
     def test_2(self):
         s1 = {"definitions": {"S": {"anyOf": [{"enum": [None]},
                                               {"allOf": [{"items": [{"$ref": "#/definitions/S"},
@@ -110,4 +111,34 @@ def test_2(self):
         s2 = {"enum": [None]}
 
         with self.subTest():
-            self.assertTrue(isSubschema(s2, s1))
+            with self.assertRaises(UnsupportedRecursiveRef) as ctxt:
+                isSubschema(s2, s1)
+            print(ctxt.exception)
+
+    def test_3(self):
+        s1 = {
+            "definitions": {
+                "person": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "children": {
+                            "type": "array",
+                            "items": {"$ref": "#/definitions/person"},
+                            "default": []
+                        }
+                    }
+                }
+            },
+            "type": "object",
+            "properties": {
+                "person": {"$ref": "#/definitions/person"}
+            }
+        }
+
+        s2 = {"enum": [None]}
+
+        with self.subTest():
+            with self.assertRaises(UnsupportedRecursiveRef) as ctxt:
+                isSubschema(s2, s1)
+            print(ctxt.exception)