Further improvements

Author: Stranger6667

src/hypothesis_jsonschema/_canonicalise.py

@@ -580,7 +580,7 @@ def resolve_all_refs(
         )
 
     def is_recursive(reference: str) -> bool:
-        return reference == "#" or resolver.resolution_scope == reference  # type: ignore
+        return reference == "#" or reference in resolver._scopes_stack  # type: ignore
 
     # To avoid infinite recursion, we skip all recursive definitions, and such references will be processed later
     # A definition is recursive if it contains a reference to itself or one of its ancestors.
@@ -612,7 +612,9 @@ def is_recursive(reference: str) -> bool:
             subschema = schema[key]
             assert isinstance(subschema, dict)
             schema[key] = {
-                k: resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v
+                k: resolve_all_refs(deepcopy(v), resolver=resolver)
+                if isinstance(v, dict)
+                else v
                 for k, v in subschema.items()
             }
     assert isinstance(schema, dict)

src/hypothesis_jsonschema/_from_schema.py

@@ -171,7 +171,7 @@ def __from_schema(
         def _recurse() -> st.SearchStrategy[JSONType]:
             _, resolved = resolver.resolve(ref)  # type: ignore
             return from_schema(
-                resolved, custom_formats=custom_formats, resolver=resolver
+                deepcopy(resolved), custom_formats=custom_formats, resolver=resolver
             )
 
         return st.deferred(_recurse)
@@ -462,16 +462,14 @@ def array_schema(
         if max_size is not None:
             max_size -= len(items)
 
-        items_strats = [_from_schema_(s) for s in deepcopy(items)]
+        items_strats = [_from_schema_(s) for s in items]
         additional_items_strat = _from_schema_(additional_items)
 
         # If we have a contains schema to satisfy, we try generating from it when
         # allowed to do so.  We'll skip the None (unmergable / no contains) cases
         # below, and let Hypothesis ignore the FALSEY cases for us.
         if "contains" in schema:
-            for i, mrgd in enumerate(
-                merged([schema["contains"], s]) for s in deepcopy(items)
-            ):
+            for i, mrgd in enumerate(merged([schema["contains"], s]) for s in items):
                 if mrgd is not None:
                     items_strats[i] |= _from_schema_(mrgd)
             contains_additional = merged([schema["contains"], additional_items])
@@ -508,10 +506,10 @@ def not_seen(elem: JSONType) -> bool:
                 st.lists(additional_items_strat, min_size=min_size, max_size=max_size),
             )
     else:
-        items_strat = _from_schema_(deepcopy(items))
+        items_strat = _from_schema_(items)
         if "contains" in schema:
             contains_strat = _from_schema_(schema["contains"])
-            if merged([deepcopy(items), schema["contains"]]) != schema["contains"]:
+            if merged([items, schema["contains"]]) != schema["contains"]:
                 # We only need this filter if we couldn't merge items in when
                 # canonicalising.  Note that for list-items, above, we just skip
                 # the mixed generation in this case (because they tend to be
@@ -548,7 +546,7 @@ def object_schema(
         return st.builds(dict)
     names["type"] = "string"
 
-    properties = deepcopy(schema.get("properties", {}))  # exact name: value schema
+    properties = schema.get("properties", {})  # exact name: value schema
     patterns = schema.get("patternProperties", {})  # regex for names: value schema
     # schema for other values; handled specially if nothing matches
     additional = schema.get("additionalProperties", {})
@@ -609,7 +607,7 @@ def from_object_schema(draw: Any) -> Any:
                 if re.search(rgx, string=key) is not None
             ]
             if key in properties:
-                pattern_schemas.insert(0, deepcopy(properties[key]))
+                pattern_schemas.insert(0, properties[key])
 
             if pattern_schemas:
                 out[key] = draw(
@@ -618,9 +616,7 @@ def from_object_schema(draw: Any) -> Any:
             else:
                 out[key] = draw(
                     from_schema(
-                        deepcopy(additional),
-                        custom_formats=custom_formats,
-                        resolver=resolver,
+                        additional, custom_formats=custom_formats, resolver=resolver,
                     )
                 )
 

tests/test_from_schema.py

@@ -452,9 +452,79 @@ def test_allowed_unknown_custom_format(string):
             },
             "$ref": "#/definitions/Node",
         },
+        # Simplified Open API schema
+        {
+            "type": "object",
+            "required": ["paths"],
+            "properties": {"paths": {"$ref": "#/definitions/Paths"}},
+            "additionalProperties": False,
+            "definitions": {
+                "Schema": {
+                    "type": "object",
+                    "properties": {"items": {"$ref": "#/definitions/Schema"}},
+                    "additionalProperties": False,
+                },
+                "MediaType": {
+                    "type": "object",
+                    "properties": {"schema": {"$ref": "#/definitions/Schema"}},
+                    "patternProperties": {"^x-": {}},
+                    "additionalProperties": False,
+                },
+                "Paths": {
+                    "type": "object",
+                    "patternProperties": {
+                        "^\\/": {"$ref": "#/definitions/PathItem"},
+                        "^x-": {},
+                    },
+                    "additionalProperties": False,
+                },
+                "PathItem": {
+                    "type": "object",
+                    "properties": {
+                        "parameters": {
+                            "type": "array",
+                            "items": {"$ref": "#/definitions/Parameter"},
+                            "uniqueItems": True,
+                        },
+                    },
+                    "patternProperties": {
+                        "^(get|put|post|delete|options|head|patch|trace)$": {
+                            "$ref": "#/definitions/Operation"
+                        },
+                        "^x-": {},
+                    },
+                    "additionalProperties": False,
+                },
+                "Operation": {
+                    "type": "object",
+                    "required": ["responses"],
+                    "properties": {
+                        "parameters": {
+                            "type": "array",
+                            "items": {"$ref": "#/definitions/Parameter"},
+                            "uniqueItems": True,
+                        },
+                    },
+                    "additionalProperties": False,
+                },
+                "Parameter": {
+                    "type": "object",
+                    "properties": {
+                        "schema": {"$ref": "#/definitions/Schema"},
+                        "content": {
+                            "type": "object",
+                            "minProperties": 1,
+                            "maxProperties": 1,
+                        },
+                    },
+                    "additionalProperties": False,
+                },
+            },
+        },
     ),
 )
 @given(data=st.data())
+@settings(suppress_health_check=[HealthCheck.too_slow, HealthCheck.filter_too_much])
 def test_recursive_reference(data, schema):
     value = data.draw(from_schema(schema))
     jsonschema.validate(value, schema)