schemathesis 4.2.1__tar.gz → 4.2.2__tar.gz

{schemathesis-4.2.1 → schemathesis-4.2.2}/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.2.1...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.2.2...HEAD) - TBD
+
+## [4.2.2](https://github.com/schemathesis/schemathesis/compare/v4.2.1...v4.2.2) - 2025-10-11
+
+### :bug: Fixed
+
+- False positive error about recursive references when there are non-recursive and non-removable ones are present in the same schema.
+- False positive error about recursive references in the examples phase.
+
+### :wrench: Changed
+
+- Improve recursive reference sanitization.
 
 ## [4.2.1](https://github.com/schemathesis/schemathesis/compare/v4.2.0...v4.2.1) - 2025-10-09
 

{schemathesis-4.2.1 → schemathesis-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.2.1
+Version: 4.2.2
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.2.1 → schemathesis-4.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.2.1"
+version = "4.2.2"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-4.2.1 → schemathesis-4.2.2}/src/schemathesis/core/jsonschema/bundler.py

@@ -90,7 +90,7 @@ class Bundler:
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
                         cloned = deepclone(resolved_schema)
                         remaining_references = sanitize(cloned)
-                        if remaining_references:
+                        if reference in remaining_references:
                             # This schema is either infinitely recursive or the sanitization logic misses it, in any
                             # event, we git up here
                             raise InfiniteRecursiveReference(reference)

schemathesis-4.2.2/src/schemathesis/core/jsonschema/references.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Any
+
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
+
+
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove $ref from optional locations."""
+    if isinstance(schema, bool):
+        return set()
+
+    stack: list[JsonSchema] = [schema]
+
+    while stack:
+        current = stack.pop()
+        if not isinstance(current, dict):
+            continue
+
+        _sanitize_combinators(current)
+
+        _sanitize_properties(current)
+
+        if "items" in current:
+            _sanitize_items(current)
+
+        if "prefixItems" in current:
+            _sanitize_prefix_items(current)
+
+        if "additionalProperties" in current:
+            _sanitize_additional_properties(current)
+
+        if "additionalItems" in current:
+            _sanitize_additional_items(current)
+
+        for value in current.values():
+            if isinstance(value, dict):
+                stack.append(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        stack.append(item)
+
+    remaining: set[str] = set()
+    _collect_all_references(schema, remaining)
+    return remaining
+
+
+def _sanitize_combinators(schema: JsonSchemaObject) -> None:
+    """Sanitize anyOf/oneOf/allOf."""
+    for combinator_key in ("anyOf", "oneOf"):
+        variants = schema.get(combinator_key)
+        if not isinstance(variants, list):
+            continue
+
+        flattened = _flatten_combinator(variants, combinator_key)
+
+        cleaned = [variant for variant in flattened if not _has_ref(variant)]
+
+        # Only update if we have non-$ref variants
+        if cleaned:
+            # At least one alternative remains, which narrows the constraints
+            schema[combinator_key] = cleaned
+        elif not flattened:
+            schema.pop(combinator_key, None)
+
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list):
+        flattened = _flatten_combinator(all_of, "allOf")
+
+        cleaned = [variant for variant in flattened if not _is_empty(variant)]
+        if cleaned:
+            schema["allOf"] = cleaned
+        else:
+            schema.pop("allOf", None)
+
+
+def _flatten_combinator(variants: list, key: str) -> list:
+    """Flatten nested same-type combinators."""
+    result = []
+    for variant in variants:
+        if isinstance(variant, dict) and key in variant and isinstance(variant[key], list):
+            result.extend(variant[key])
+        else:
+            result.append(variant)
+    return result
+
+
+def _is_empty(schema: JsonSchema) -> bool:
+    """Check if schema accepts anything."""
+    if schema is True:
+        return True
+
+    if not isinstance(schema, dict):
+        return False
+
+    if not schema:
+        return True
+
+    # Only non-validating keywords
+    NON_VALIDATING = {
+        "$id",
+        "$schema",
+        "$defs",
+        "definitions",
+        "title",
+        "description",
+        "default",
+        "examples",
+        "example",
+        "$comment",
+        "deprecated",
+        "readOnly",
+        "writeOnly",
+    }
+
+    return all(key in NON_VALIDATING for key in schema.keys())
+
+
+def _sanitize_properties(schema: JsonSchemaObject) -> None:
+    """Remove OPTIONAL property schemas if they have $ref."""
+    if "properties" not in schema:
+        return
+
+    properties = schema["properties"]
+    if not isinstance(properties, dict):
+        return
+
+    required = schema.get("required", [])
+
+    for name, subschema in list(properties.items()):
+        if not _has_ref(subschema):
+            continue
+
+        if name not in required:
+            del properties[name]
+
+
+def _sanitize_items(schema: JsonSchemaObject) -> None:
+    """Convert to empty array ONLY if minItems allows it."""
+    items = schema["items"]
+
+    has_ref = False
+    if isinstance(items, dict):
+        has_ref = _has_ref(items)
+    elif isinstance(items, list):
+        has_ref = any(_has_ref(item) for item in items)
+
+    if not has_ref:
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _sanitize_prefix_items(schema: JsonSchemaObject) -> None:
+    """Same logic as items."""
+    prefix_items = schema["prefixItems"]
+
+    if not isinstance(prefix_items, list):
+        return
+
+    if not any(_has_ref(item) for item in prefix_items):
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
+    schema.pop("items", None)
+    schema.pop("prefixItems", None)
+    schema["maxItems"] = 0
+    schema["minItems"] = 0
+
+
+def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalProperties"]
+    if _has_ref(additional):
+        schema["additionalProperties"] = False
+
+
+def _sanitize_additional_items(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalItems"]
+    if _has_ref(additional):
+        schema["additionalItems"] = False
+
+
+def _has_ref(schema: Any) -> bool:
+    """Check if schema contains $ref at any level."""
+    if not isinstance(schema, dict):
+        return False
+
+    if "$ref" in schema:
+        return True
+    for value in schema.values():
+        if isinstance(value, dict):
+            if _has_ref(value):
+                return True
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict) and _has_ref(item):
+                    return True
+
+    return False
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Collect all remaining $ref."""
+    if isinstance(schema, dict):
+        ref = schema.get("$ref")
+        if isinstance(ref, str):
+            remaining.add(ref)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)

{schemathesis-4.2.1 → schemathesis-4.2.2}/src/schemathesis/specs/openapi/examples.py

@@ -109,15 +109,19 @@ def extract_top_level(
     assert isinstance(operation.schema, BaseOpenAPISchema)
 
     responses = list(operation.responses.iter_examples())
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path: tuple[str, ...] = ()
             definitions = [
                 parameter.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [parameter.definition]
@@ -138,10 +142,15 @@ def extract_top_level(
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and parameter.adapter.examples_container_keyword in expanded:
-                    for value in expanded[parameter.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if (
+                    isinstance(expanded_schema, dict)
+                    and parameter.adapter.examples_container_keyword in expanded_schema
+                ):
+                    for value in expanded_schema[parameter.adapter.examples_container_keyword]:
                         yield ParameterExample(
                             container=parameter.location.container_name, name=parameter.name, value=value
                         )
@@ -152,10 +161,15 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path = ()
             definitions = [
                 body.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [body.definition]
@@ -172,58 +186,76 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and body.adapter.examples_container_keyword in expanded:
-                    for value in expanded[body.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if isinstance(expanded_schema, dict) and body.adapter.examples_container_keyword in expanded_schema:
+                    for value in expanded_schema[body.adapter.examples_container_keyword]:
                         yield BodyExample(value=value, media_type=body.media_type)
 
 
 @overload
 def _resolve_bundled(
-    schema: dict[str, Any], resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any]: ...  # pragma: no cover
+    schema: dict[str, Any], resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any], tuple[str, ...]]: ...
 
 
 @overload
-def _resolve_bundled(schema: bool, resolver: RefResolver, seen_references: set[str]) -> bool: ...  # pragma: no cover
+def _resolve_bundled(
+    schema: bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[bool, tuple[str, ...]]: ...
 
 
 def _resolve_bundled(
-    schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any] | bool:
+    schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any] | bool, tuple[str, ...]]:
+    """Resolve $ref if present."""
     if isinstance(schema, dict):
         reference = schema.get("$ref")
         if isinstance(reference, str):
-            if reference in seen_references:
+            # Check if this reference is already in the current path
+            if reference in reference_path:
                 # Try to remove recursive references to avoid infinite recursion
                 remaining_references = references.sanitize(schema)
                 if reference in remaining_references:
                     raise InfiniteRecursiveReference(reference)
-            seen_references.add(reference)
+
+            new_path = reference_path + (reference,)
+
             try:
-                _, schema = resolver.resolve(schema["$ref"])
+                _, resolved_schema = resolver.resolve(reference)
             except RefResolutionError as exc:
                 raise UnresolvableReference(reference) from exc
-    return schema
+
+            return resolved_schema, new_path
+
+    return schema, reference_path
 
 
 def _expand_subschemas(
-    *, schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> Generator[dict[str, Any] | bool, None, None]:
-    schema = _resolve_bundled(schema, resolver, seen_references)
-    yield schema
+    *, schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> Generator[tuple[dict[str, Any] | bool, tuple[str, ...]], None, None]:
+    """Expand schema and all its subschemas."""
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    yield (schema, current_path)
+
     if isinstance(schema, dict):
+        # For anyOf/oneOf, yield each alternative with the same path
         for key in ("anyOf", "oneOf"):
             if key in schema:
                 for subschema in schema[key]:
-                    yield subschema
+                    # Each alternative starts with the current path
+                    yield (subschema, current_path)
+
+        # For allOf, merge all alternatives
         if "allOf" in schema:
             subschema = deepclone(schema["allOf"][0])
-            subschema = _resolve_bundled(subschema, resolver, seen_references)
+            subschema, _ = _resolve_bundled(subschema, resolver, current_path)
+
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
-                    sub = _resolve_bundled(sub, resolver, seen_references)
+                    sub, _ = _resolve_bundled(sub, resolver, current_path)
                     for key, value in sub.items():
                         if key == "properties":
                             subschema.setdefault("properties", {}).update(value)
@@ -235,7 +267,8 @@ def _expand_subschemas(
                             subschema.setdefault("examples", []).append(value)
                         else:
                             subschema[key] = value
-            yield subschema
+
+            yield (subschema, current_path)
 
 
 def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:
@@ -269,13 +302,12 @@ def extract_from_schemas(
     operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
 ) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         schema = parameter.optimized_schema
         if isinstance(schema, bool):
             continue
         resolver = RefResolver.from_schema(schema)
-        seen_references.clear()
+        reference_path: tuple[str, ...] = ()
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for value in extract_from_schema(
             operation=operation,
@@ -283,7 +315,7 @@ def extract_from_schemas(
             example_keyword=parameter.adapter.example_keyword,
             examples_container_keyword=parameter.adapter.examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=reference_path,
             bundle_storage=bundle_storage,
         ):
             yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
@@ -295,14 +327,14 @@ def extract_from_schemas(
         resolver = RefResolver.from_schema(schema)
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for example_keyword, examples_container_keyword in (("example", "examples"), ("x-example", "x-examples")):
-            seen_references.clear()
+            reference_path = ()
             for value in extract_from_schema(
                 operation=operation,
                 schema=schema,
                 example_keyword=example_keyword,
                 examples_container_keyword=examples_container_keyword,
                 resolver=resolver,
-                seen_references=seen_references,
+                reference_path=reference_path,
                 bundle_storage=bundle_storage,
             ):
                 yield BodyExample(value=value, media_type=body.media_type)
@@ -315,49 +347,57 @@ def extract_from_schema(
     example_keyword: str,
     examples_container_keyword: str,
     resolver: RefResolver,
-    seen_references: set[str],
+    reference_path: tuple[str, ...],
     bundle_storage: dict[str, Any] | None,
 ) -> Generator[Any, None, None]:
     """Extract all examples from a single schema definition."""
     # This implementation supports only `properties` and `items`
-    schema = _resolve_bundled(schema, resolver, seen_references)
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+
     if "properties" in schema:
         variants = {}
         required = schema.get("required", [])
         to_generate: dict[str, Any] = {}
+
         for name, subschema in schema["properties"].items():
             values = []
-            for subsubschema in _expand_subschemas(
-                schema=subschema, resolver=resolver, seen_references=seen_references
+            for expanded_schema, expanded_path in _expand_subschemas(
+                schema=subschema, resolver=resolver, reference_path=current_path
             ):
-                if isinstance(subsubschema, bool):
-                    to_generate[name] = subsubschema
+                if isinstance(expanded_schema, bool):
+                    to_generate[name] = expanded_schema
                     continue
-                if example_keyword in subsubschema:
-                    values.append(subsubschema[example_keyword])
-                if examples_container_keyword in subsubschema and isinstance(
-                    subsubschema[examples_container_keyword], list
+
+                if example_keyword in expanded_schema:
+                    values.append(expanded_schema[example_keyword])
+
+                if examples_container_keyword in expanded_schema and isinstance(
+                    expanded_schema[examples_container_keyword], list
                 ):
                     # These are JSON Schema examples, which is an array of values
-                    values.extend(subsubschema[examples_container_keyword])
+                    values.extend(expanded_schema[examples_container_keyword])
+
                 # Check nested examples as well
                 values.extend(
                     extract_from_schema(
                         operation=operation,
-                        schema=subsubschema,
+                        schema=expanded_schema,
                         example_keyword=example_keyword,
                         examples_container_keyword=examples_container_keyword,
                         resolver=resolver,
-                        seen_references=seen_references,
+                        reference_path=expanded_path,
                         bundle_storage=bundle_storage,
                     )
                 )
+
                 if not values:
                     if name in required:
                         # Defer generation to only generate these variants if at least one property has examples
-                        to_generate[name] = subsubschema
+                        to_generate[name] = expanded_schema
                     continue
+
                 variants[name] = values
+
         if variants:
             config = operation.schema.config.generation_for(operation=operation, phase="examples")
             for name, subschema in to_generate.items():
@@ -369,6 +409,7 @@ def extract_from_schema(
                     subschema[BUNDLE_STORAGE_KEY] = bundle_storage
                 generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
+
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())
             # Evenly distribute examples by cycling through them
@@ -377,6 +418,7 @@ def extract_from_schema(
                     name: next(islice(cycle(property_variants), idx, None))
                     for name, property_variants in variants.items()
                 }
+
     elif "items" in schema and isinstance(schema["items"], dict):
         # Each inner value should be wrapped in an array
         for value in extract_from_schema(
@@ -385,7 +427,7 @@ def extract_from_schema(
             example_keyword=example_keyword,
             examples_container_keyword=examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=current_path,
             bundle_storage=bundle_storage,
         ):
             yield [value]

{schemathesis-4.2.1 → schemathesis-4.2.2}/test/__snapshots__/test_dereferencing/test_multiple_hops_references[paths0-components0].raw

@@ -24,7 +24,7 @@ Schemathesis dev
 ________________________________ POST /changes _________________________________
 Runtime Error
 
-Required reference `#/x-bundled/schema3` creates a cycle
+Required reference `#/x-bundled/schema4` creates a cycle
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.2.1 → schemathesis-4.2.2}/test/__snapshots__/test_dereferencing/test_multiple_hops_references[paths1-components1].raw

@@ -24,7 +24,7 @@ Schemathesis dev
 ________________________________ POST /changes _________________________________
 Runtime Error
 
-Required reference `#/x-bundled/schema3` creates a cycle
+Required reference `#/x-bundled/schema4` creates a cycle
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA