Merge pull request #142 from abravalheri/display-ref-in-composite

Expand `$ref` when assigning the `definition` field to `JsonSchemaValueException`

Author: horejsek

fastjsonschema/generator.py

@@ -252,8 +252,19 @@ def exc(self, msg, *args, rule=None):
         Short-cut for creating raising exception in the code.
         """
         msg = 'raise JsonSchemaValueException("'+msg+'", value={variable}, name="{name}", definition={definition}, rule={rule})'
-        definition_rule = self.e(self._definition.get(rule) if isinstance(self._definition, dict) else None)
-        self.l(msg, *args, definition=repr(self._definition), rule=repr(rule), definition_rule=definition_rule)
+        definition = self._expand_refs(self._definition)
+        definition_rule = self.e(definition.get(rule) if isinstance(definition, dict) else None)
+        self.l(msg, *args, definition=repr(definition), rule=repr(rule), definition_rule=definition_rule)
+
+    def _expand_refs(self, definition):
+        if isinstance(definition, list):
+            return [self._expand_refs(v) for v in definition]
+        if not isinstance(definition, dict):
+            return definition
+        if "$ref" in definition and isinstance(definition["$ref"], str):
+            with self._resolver.resolving(definition["$ref"]) as schema:
+                return schema
+        return {k: self._expand_refs(v) for k, v in definition.items()}
 
     def create_variable_with_length(self):
         """

tests/conftest.py

@@ -33,7 +33,8 @@ def f(definition, value, expected, formats={}):
         if isinstance(expected, JsonSchemaValueException):
             with pytest.raises(JsonSchemaValueException) as exc:
                 validator(value)
-            assert exc.value.message == expected.message
+            if expected.message is not any:
+                assert exc.value.message == expected.message
             assert exc.value.value == (value if expected.value == '{data}' else expected.value)
             assert exc.value.name == expected.name
             assert exc.value.definition == (definition if expected.definition == '{definition}' else expected.definition)

tests/examples/conditional/address.schema.json

@@ -0,0 +1,21 @@
+{
+  "type": "object",
+  "properties": {
+    "street_address": {
+      "type": "string"
+    },
+    "country": {
+      "default": "United States of America",
+      "enum": ["United States of America", "Canada"]
+    }
+  },
+  "if": {
+    "properties": { "country": { "const": "United States of America" } }
+  },
+  "then": {
+    "properties": { "postal_code": { "pattern": "[0-9]{5}(-[0-9]{4})?" } }
+  },
+  "else": {
+    "properties": { "postal_code": { "pattern": "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" } }
+  }
+}

tests/examples/conditional/invalid.error

@@ -0,0 +1 @@
+data.postal_code must match pattern [A-Z][0-9][A-Z] [0-9][A-Z][0-9]

tests/examples/conditional/invalid.json

@@ -0,0 +1,5 @@
+{
+  "street_address": "24 Sussex Drive",
+  "country": "Canada",
+  "postal_code": "10000"
+}

tests/examples/conditional/valid.json

@@ -0,0 +1,5 @@
+{
+  "street_address": "1600 Pennsylvania Avenue NW",
+  "country": "United States of America",
+  "postal_code": "20500"
+}

tests/test_composition.py

@@ -0,0 +1,114 @@
+import pytest
+
+import fastjsonschema
+from fastjsonschema import JsonSchemaValueException
+
+
+def _composition_example(composition="oneOf"):
+    return {
+        "definitions": {
+            "multiple-of-3": {"type": "number", "multipleOf": 3},
+            "multiple-of-5": {"type": "number", "multipleOf": 5},
+        },
+        composition: [
+            {"$ref": "#/definitions/multiple-of-3"},
+            {"$ref": "#/definitions/multiple-of-5"},
+        ],
+    }
+
+
+@pytest.mark.parametrize(
+    "composition, value", [("oneOf", 10), ("allOf", 15), ("anyOf", 9)]
+)
+def test_composition(asserter, composition, value):
+    asserter(_composition_example(composition), value, value)
+
+
+@pytest.mark.parametrize(
+    "composition, value", [("oneOf", 2), ("anyOf", 2), ("allOf", 3)]
+)
+def test_ref_is_expanded_on_composition_error(composition, value):
+    with pytest.raises(JsonSchemaValueException) as exc:
+        fastjsonschema.validate(_composition_example(composition), value)
+
+    if composition in exc.value.definition:
+        assert exc.value.definition[composition] == [
+            {"type": "number", "multipleOf": 3},
+            {"type": "number", "multipleOf": 5},
+        ]
+    else:
+        # allOf will fail on the first invalid item,
+        # so the error message will not refer to the entire composition
+        assert composition == "allOf"
+        assert "$ref" not in exc.value.definition
+        assert exc.value.definition["type"] == "number"
+
+
+@pytest.mark.parametrize(
+    "composition, value", [("oneOf", 2), ("anyOf", 2), ("allOf", 3)]
+)
+def test_ref_is_expanded_with_resolver(composition, value):
+    repo = {
+        "sch://multiple-of-3": {"type": "number", "multipleOf": 3},
+        "sch://multiple-of-5": {"type": "number", "multipleOf": 5},
+    }
+    schema = {
+        composition: [
+            {"$ref": "sch://multiple-of-3"},
+            {"$ref": "sch://multiple-of-5"},
+        ]
+    }
+
+    with pytest.raises(JsonSchemaValueException) as exc:
+        fastjsonschema.validate(schema, value, handlers={"sch": repo.__getitem__})
+
+    if composition in exc.value.definition:
+        assert exc.value.definition[composition] == [
+            {"type": "number", "multipleOf": 3},
+            {"type": "number", "multipleOf": 5},
+        ]
+    else:
+        # allOf will fail on the first invalid item,
+        # so the error message will not refer to the entire composition
+        assert composition == "allOf"
+        assert "$ref" not in exc.value.definition
+        assert exc.value.definition["type"] == "number"
+
+
+def test_ref_in_conditional():
+    repo = {
+        "sch://USA": {"properties": {"country": {"const": "United States of America"}}},
+        "sch://USA-post-code": {
+            "properties": {"postal_code": {"pattern": "[0-9]{5}(-[0-9]{4})?"}}
+        },
+        "sch://general-post-code": {
+            "properties": {
+                "postal_code": {"pattern": "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]"}
+            }
+        },
+    }
+    schema = {
+        "type": "object",
+        "properties": {
+            "street_address": {"type": "string"},
+            "country": {
+                "default": "United States of America",
+                "enum": ["United States of America", "Canada"],
+            },
+        },
+        "if": {"allOf": [{"$ref": "sch://USA"}]},
+        "then": {"oneOf": [{"$ref": "sch://USA-post-code"}]},
+        "else": {"anyOf": [{"$ref": "sch://general-post-code"}]},
+    }
+    invalid = {
+        "street_address": "1600 Pennsylvania Avenue NW",
+        "country": "United States of America",
+        "postal_code": "BS12 3FG",
+    }
+
+    with pytest.raises(JsonSchemaValueException) as exc:
+        fastjsonschema.validate(schema, invalid, handlers={"sch": repo.__getitem__})
+
+    assert exc.value.definition["oneOf"] == [
+        {"properties": {"postal_code": {"pattern": "[0-9]{5}(-[0-9]{4})?"}}}
+    ]