Do not inline recursive references at all

Author: Stranger6667

src/hypothesis_jsonschema/_canonicalise.py

@@ -577,10 +577,13 @@ def is_recursive_reference(reference: str, resolver: LocalResolver) -> bool:
 
 def resolve_all_refs(
     schema: Union[bool, Schema], *, resolver: LocalResolver = None
-) -> Schema:
-    """Resolve all non-recursive references in the given schema."""
+) -> Tuple[Schema, bool]:
+    """Resolve all non-recursive references in the given schema.
+
+    When a recursive reference is detected, it stops traversing the currently resolving branch and leaves it as is.
+    """
     if isinstance(schema, bool):
-        return canonicalish(schema)
+        return canonicalish(schema), False
     assert isinstance(schema, dict), schema
     if resolver is None:
         resolver = LocalResolver.from_schema(deepcopy(schema))
@@ -603,32 +606,52 @@ def resolve_all_refs(
                     raise HypothesisRefResolutionError(msg)
                 # `deepcopy` is not needed, because, the schemas are copied inside the `merged` call above
                 return resolve_all_refs(m, resolver=resolver)
+        else:
+            return schema, True
 
     for key in SCHEMA_KEYS:
         val = schema.get(key, False)
         if isinstance(val, list):
-            schema[key] = [
-                resolve_all_refs(deepcopy(v), resolver=resolver)
-                if isinstance(v, dict)
-                else v
-                for v in val
-            ]
+            value = []
+            for v in val:
+                if isinstance(v, dict):
+                    resolved, is_recursive = resolve_all_refs(
+                        deepcopy(v), resolver=resolver
+                    )
+                    if is_recursive:
+                        return schema, True
+                    else:
+                        value.append(resolved)
+                else:
+                    value.append(v)
+            schema[key] = value
         elif isinstance(val, dict):
-            schema[key] = resolve_all_refs(deepcopy(val), resolver=resolver)
+            resolved, is_recursive = resolve_all_refs(deepcopy(val), resolver=resolver)
+            if is_recursive:
+                return schema, True
+            else:
+                schema[key] = resolved
         else:
             assert isinstance(val, bool)
     for key in SCHEMA_OBJECT_KEYS:  # values are keys-to-schema-dicts, not schemas
         if key in schema:
             subschema = schema[key]
             assert isinstance(subschema, dict)
-            schema[key] = {
-                k: resolve_all_refs(deepcopy(v), resolver=resolver)
-                if isinstance(v, dict)
-                else v
-                for k, v in subschema.items()
-            }
+            value = {}
+            for k, v in subschema.items():
+                if isinstance(v, dict):
+                    resolved, is_recursive = resolve_all_refs(
+                        deepcopy(v), resolver=resolver
+                    )
+                    if is_recursive:
+                        return schema, True
+                    else:
+                        value[k] = resolved
+                else:
+                    value[k] = v
+            schema[key] = value
     assert isinstance(schema, dict)
-    return schema
+    return schema, False
 
 
 def merged(schemas: List[Any]) -> Optional[Schema]:

src/hypothesis_jsonschema/_from_schema.py

@@ -114,7 +114,7 @@ def __from_schema(
     custom_formats: Dict[str, st.SearchStrategy[str]] = None,
 ) -> st.SearchStrategy[JSONType]:
     try:
-        schema = resolve_all_refs(schema)
+        schema, _ = resolve_all_refs(schema)
     except RecursionError:
         raise HypothesisRefResolutionError(
             f"Could not resolve recursive references in schema={schema!r}"

tests/test_canonicalise.py

@@ -542,12 +542,12 @@ def test_validators_use_proper_draft():
         (ROOT_REFERENCE, ROOT_REFERENCE),
         (NESTED, NESTED),
         (NESTED_WITH_ID, NESTED_WITH_ID),
-        # "foo" content should be inlined as is, because "#" is recursive (special case)
+        # "foo" content should not be inlined, because "#" is recursive (special case)
         (
             {"foo": {"$ref": "#"}, "not": {"$ref": "#foo"}},
-            {"foo": {"$ref": "#"}, "not": {"$ref": "#"}},
+            {"foo": {"$ref": "#"}, "not": {"$ref": "#foo"}},
         ),
-        # "foo" content should be inlined as is, because it points to itself
+        # "foo" content should not be inlined, because it points to itself
         (
             SELF_REFERENTIAL,
             SELF_REFERENTIAL,
@@ -558,22 +558,21 @@ def test_validators_use_proper_draft():
             # 1. We start from resolving "$ref" in "not"
             # 2. at this point we don't know this path is recursive, so we follow to "foo"
             # 3. inside "foo" we found a reference to "foo", which means it is recursive
-            {"foo": {"not": {"$ref": "#foo"}}, "not": {"not": {"$ref": "#foo"}}},
+            {"foo": {"not": {"$ref": "#foo"}}, "not": {"$ref": "#foo"}},
         ),
         # Circular reference between two schemas
         (
             {"foo": {"$ref": "#bar"}, "bar": {"$ref": "#foo"}, "not": {"$ref": "#foo"}},
             # 1. We start in "not" and follow to "foo"
             # 2. In "foo" we follow to "bar"
             # 3. Here we see a reference to previously seen scope, which means it is a recursive path
-            # We take the schema where we stop and inline it to the starting point (therefore it is `{"$ref": "#foo"}`)
             {"foo": {"$ref": "#bar"}, "bar": {"$ref": "#foo"}, "not": {"$ref": "#foo"}},
         ),
     ),
 )
 def test_skip_recursive_references_simple_schemas(schema, expected):
     # When there is a recursive reference, it should not be resolved
-    assert resolve_all_refs(schema) == expected
+    assert resolve_all_refs(schema)[0] == expected
 
 
 @pytest.mark.parametrize(
@@ -637,18 +636,11 @@ def test_skip_recursive_references_simple_schemas(schema, expected):
                 "properties": {"foo": {"$ref": "#/definitions/foo"}},
             },
             {
-                "properties": {
-                    "foo": {
-                        "properties": {
-                            "bar": {"$ref": "#/definitions/foo"},
-                            "baz": {"$ref": "#/definitions/foo"},
-                        }
-                    }
-                },
+                "properties": {"foo": {"$ref": "#/definitions/foo"}},
             },
         ),
     ),
 )
 def test_skip_recursive_references_complex_schemas(schema, resolved):
     resolved["definitions"] = schema["definitions"]
-    assert resolve_all_refs(schema) == resolved
+    assert resolve_all_refs(schema)[0] == resolved