schemathesis 4.3.4__tar.gz → 4.3.6__tar.gz

{schemathesis-4.3.4 → schemathesis-4.3.6}/.pre-commit-config.yaml

@@ -33,11 +33,11 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
+    rev: v0.14.1
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
+    rev: v0.14.1
     hooks:
       - id: ruff-check

{schemathesis-4.3.4 → schemathesis-4.3.6}/CHANGELOG.md

@@ -1,15 +1,32 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.4...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.6...HEAD) - TBD
 
-## [4.3.4](https://github.com/schemathesis/schemathesis/compare/v4.3.3...v4.3.4) - 2025-10-17
+## [4.3.6](https://github.com/schemathesis/schemathesis/compare/v4.3.5...v4.3.6) - 2025-10-20
 
 ### :wrench: Changed
 
-- Deduplicate explicit and inferred links.
+- Support inference of dependencies from listings to subresources (`GET /orders` -> `GET /orders/{id}/notes`).
+
+## [4.3.5](https://github.com/schemathesis/schemathesis/compare/v4.3.4...v4.3.5) - 2025-10-19
+
+### :bug: Fixed
+
+- Setting an empty list to `phases.coverage.unexpected-methods` will disable testing of unexpected HTTP methods.
+- Schema bundler to correctly detect unbreakable indirect recursive cycles instead of failing with `RecursionError`.
 
 ### :wrench: Changed
 
+- Display extraction failures for `requestBody` in explicit links.
+- If `requestBody` is optional, choose empty body only in 5% of cases (instead of 50%).
+- Add matching required fields from known resources during dependency analysis.
+- Improve deduplication of inferred links.
+
+## [4.3.4](https://github.com/schemathesis/schemathesis/compare/v4.3.3...v4.3.4) - 2025-10-17
+
+### :wrench: Changed
+
+- Deduplicate explicit and inferred links.
 - Do not report extraction failures for inferred links.
 
 ## [4.3.3](https://github.com/schemathesis/schemathesis/compare/v4.3.2...v4.3.3) - 2025-10-15

{schemathesis-4.3.4 → schemathesis-4.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.4
+Version: 4.3.6
 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.3.4 → schemathesis-4.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.4"
+version = "4.3.6"
 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.3.4 → schemathesis-4.3.6}/src/schemathesis/cli/commands/run/context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable, Generator
 
@@ -121,10 +122,32 @@ class Statistic:
             # We need a response to get there, so it should be present
             assert response is not None
 
+            history = None
+
+            if (
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is UNRESOLVABLE
+            ):
+                history = collect_history(parent, response)
+                extraction_failures.add(
+                    ExtractionFailure(
+                        id=transition.id,
+                        case_id=case_id,
+                        source=parent.value.operation.label,
+                        target=case.value.operation.label,
+                        parameter_name="body",
+                        expression=json.dumps(transition.request_body.definition),
+                        history=history,
+                        response=response,
+                        error=None,
+                    )
+                )
+
             for params in transition.parameters.values():
                 for parameter, extracted in params.items():
                     if isinstance(extracted.value, Ok) and extracted.value.ok() is UNRESOLVABLE:
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,
@@ -139,7 +162,7 @@ class Statistic:
                             )
                         )
                     elif isinstance(extracted.value, Err):
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/cli/commands/run/handlers/output.py

@@ -1295,9 +1295,10 @@ class OutputHandler(EventHandler):
                     else:
                         click.echo(f"\n{indent}{failure.error.__class__.__name__}: {failure.error}")
                 else:
-                    description = (
-                        f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
-                    )
+                    if failure.parameter_name == "body":
+                        description = f"\n{indent}Could not resolve request body via {failure.expression}"
+                    else:
+                        description = f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
                     prefix = "$response.body"
                     if failure.expression.startswith(prefix):
                         description += f"\n{indent}Path `{failure.expression[len(prefix) :]}` not found in response"

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/core/jsonschema/bundler.py

@@ -41,6 +41,7 @@ class Bundler:
             return schema
 
         # Track visited URIs and their local definition names
+        inlining_for_recursion: set[str] = set()
         visited: set[str] = set()
         uri_to_def_name: dict[str, str] = {}
         defs = {}
@@ -90,19 +91,26 @@ class Bundler:
                         # L is the number of levels. Even quadratic growth can be unacceptable for large schemas.
                         #
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
-                        cloned = deepclone(resolved_schema)
-                        remaining_references = sanitize(cloned)
-                        if reference in remaining_references:
-                            # This schema is either infinitely recursive or the sanitization logic misses it
+                        if resolved_uri in inlining_for_recursion:
+                            # Check if we're already trying to inline this schema
+                            # If yes, it means we have an unbreakable cycle
                             cycle = scopes[scopes.index(resolved_uri) :]
                             raise InfiniteRecursiveReference(reference, cycle)
 
-                        result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
-                        # Recursive references need `$ref` to be in them, which is only possible with `dict`
-                        bundled_clone = _bundle_recursive(cloned)
-                        assert isinstance(bundled_clone, dict)
-                        result.update(bundled_clone)
-                        return result
+                        # Track that we're inlining this schema
+                        inlining_for_recursion.add(resolved_uri)
+                        try:
+                            cloned = deepclone(resolved_schema)
+                            # Sanitize to remove optional recursive references
+                            sanitize(cloned)
+
+                            result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
+                            bundled_clone = _bundle_recursive(cloned)
+                            assert isinstance(bundled_clone, dict)
+                            result.update(bundled_clone)
+                            return result
+                        finally:
+                            inlining_for_recursion.discard(resolved_uri)
                     elif resolved_uri not in visited:
                         # Bundle only new schemas
                         visit(resolved_uri)

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/generation/hypothesis/builder.py

@@ -530,7 +530,6 @@ def _iter_coverage_cases(
     instant = Instant()
     responses = list(operation.responses.iter_examples())
     # NOTE: The HEAD method is excluded
-    unexpected_methods = unexpected_methods or {"get", "put", "post", "delete", "options", "patch", "trace"}
     custom_formats = _build_custom_formats(generation_config)
 
     seen_negative = coverage.HashSet()

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/_hypothesis.py

@@ -56,7 +56,7 @@ StrategyFactory = Callable[
 
 @st.composite  # type: ignore
 def openapi_cases(
-    draw: Callable,
+    draw: st.DrawFn,
     *,
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
@@ -116,7 +116,7 @@ def openapi_cases(
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
-            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
+            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config, draw)
             strategy = apply_hooks(operation, ctx, hooks, strategy, ParameterLocation.BODY)
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
@@ -200,11 +200,15 @@ def openapi_cases(
     return instance
 
 
+OPTIONAL_BODY_RATE = 0.05
+
+
 def _get_body_strategy(
     parameter: OpenApiBody,
     strategy_factory: StrategyFactory,
     operation: APIOperation,
     generation_config: GenerationConfig,
+    draw: st.DrawFn,
 ) -> st.SearchStrategy:
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
@@ -220,7 +224,12 @@ def _get_body_strategy(
         generation_config,
         operation.schema.adapter.jsonschema_validator_cls,
     )
-    if not parameter.is_required:
+    # It is likely will be rejected, hence choose it rarely
+    if (
+        not parameter.is_required
+        and draw(st.floats(min_value=0.0, max_value=1.0, allow_infinity=False, allow_nan=False, allow_subnormal=False))
+        < OPTIONAL_BODY_RATE
+    ):
         strategy |= st.just(NOT_SET)
     return strategy
 
@@ -228,7 +237,7 @@ def _get_body_strategy(
 def get_parameters_value(
     value: dict[str, Any] | None,
     location: ParameterLocation,
-    draw: Callable,
+    draw: st.DrawFn,
     operation: APIOperation,
     ctx: HookContext,
     hooks: HookDispatcher | None,
@@ -279,7 +288,7 @@ def generate_parameter(
     location: ParameterLocation,
     explicit: dict[str, Any] | None,
     operation: APIOperation,
-    draw: Callable,
+    draw: st.DrawFn,
     ctx: HookContext,
     hooks: HookDispatcher | None,
     generator: GenerationMode,

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/stateful/dependencies/__init__.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from schemathesis.core import NOT_SET
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.result import Ok
 from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
@@ -107,9 +108,10 @@ def inject_links(schema: BaseOpenAPISchema) -> int:
         for link_name, definition in response_links.links.items():
             inferred_link = definition.to_openapi()
 
-            # Check if duplicate exists
+            # Check if duplicate / subsets exists
             if normalized_existing:
-                if _normalize_link(inferred_link, schema) in normalized_existing:
+                normalized = _normalize_link(inferred_link, schema)
+                if any(_is_subset_link(normalized, existing) for existing in normalized_existing):
                     continue
 
             # Find unique name if collision exists
@@ -170,3 +172,39 @@ def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, A
         if candidate not in existing_links:
             return candidate
         suffix += 1
+
+
+def _is_subset_link(inferred: NormalizedLink, existing: NormalizedLink) -> bool:
+    """Check if inferred link is a subset of existing link."""
+    # Must target the same operation
+    if inferred.path != existing.path or inferred.method != existing.method:
+        return False
+
+    # Inferred parameters must be subset of existing parameters
+    if not inferred.parameters.issubset(existing.parameters):
+        return False
+
+    # Inferred request body must be subset of existing body
+    return _is_request_body_subset(inferred.request_body, existing.request_body)
+
+
+def _is_request_body_subset(inferred_body: Any, existing_body: Any) -> bool:
+    """Check if inferred body is a subset of existing body."""
+    # Empty inferred body is always a subset
+    if not inferred_body:
+        return True
+
+    # If existing is empty but inferred isn't, not a subset
+    if not existing_body:
+        return False
+
+    # Both must be dicts for subset comparison, otherwise check for equality
+    if not isinstance(inferred_body, dict) or not isinstance(existing_body, dict):
+        return inferred_body == existing_body
+
+    # Check if all inferred fields exist in existing with same values
+    for key, value in inferred_body.items():
+        if existing_body.get(key, NOT_SET) != value:
+            return False
+
+    return True

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Iterator
 from schemathesis.core import media_types
 from schemathesis.core.errors import MalformedMediaType
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
+from schemathesis.core.jsonschema.types import get_type
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.specs.openapi.stateful.dependencies import naming
 from schemathesis.specs.openapi.stateful.dependencies.models import (
@@ -36,6 +37,7 @@ def extract_inputs(
     Connects each parameter (e.g., `userId`) to its resource definition (`User`),
     creating placeholder resources if not yet discovered from their schemas.
     """
+    known_dependencies = set()
     for param in operation.path_parameters:
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
@@ -47,12 +49,16 @@ def extract_inputs(
             canonicalization_cache=canonicalization_cache,
         )
         if input_slot is not None:
+            if input_slot.resource.source >= DefinitionSource.SCHEMA_WITH_PROPERTIES:
+                known_dependencies.add(input_slot.resource.name)
             yield input_slot
 
     for body in operation.body:
         try:
             if media_types.is_json(body.media_type):
-                yield from _resolve_body_dependencies(body=body, operation=operation, resources=resources)
+                yield from _resolve_body_dependencies(
+                    body=body, operation=operation, resources=resources, known_dependencies=known_dependencies
+                )
         except MalformedMediaType:
             continue
 
@@ -162,8 +168,23 @@ def _find_resource_in_responses(
     return None
 
 
+GENERIC_FIELD_NAMES = frozenset(
+    {
+        "body",
+        "text",
+        "content",
+        "message",
+        "description",
+    }
+)
+
+
 def _resolve_body_dependencies(
-    *, body: OpenApiBody, operation: APIOperation, resources: ResourceMap
+    *,
+    body: OpenApiBody,
+    operation: APIOperation,
+    resources: ResourceMap,
+    known_dependencies: set[str],
 ) -> Iterator[InputSlot]:
     schema = body.raw_schema
     if not isinstance(schema, dict):
@@ -178,31 +199,57 @@ def _resolve_body_dependencies(
 
     # Inspect each property that could be a part of some other resource
     properties = resolved.get("properties", {})
+    required = resolved.get("required", [])
     path = operation.path
-    for property_name in properties:
+    for property_name, subschema in properties.items():
         resource_name = naming.from_parameter(property_name, path)
-        if resource_name is None:
-            continue
-        resource = resources.get(resource_name)
-        if resource is None:
-            resource = ResourceDefinition.inferred_from_parameter(
-                name=resource_name,
-                parameter_name=property_name,
-            )
-            resources[resource_name] = resource
-            field = property_name
-        else:
-            field = (
-                naming.find_matching_field(
-                    parameter=property_name,
-                    resource=resource_name,
-                    fields=resource.fields,
+        if resource_name is not None:
+            resource = resources.get(resource_name)
+            if resource is None:
+                resource = ResourceDefinition.inferred_from_parameter(
+                    name=resource_name,
+                    parameter_name=property_name,
+                )
+                resources[resource_name] = resource
+                field = property_name
+            else:
+                field = (
+                    naming.find_matching_field(
+                        parameter=property_name,
+                        resource=resource_name,
+                        fields=resource.fields,
+                    )
+                    or "id"
                 )
-                or "id"
+            yield InputSlot(
+                resource=resource,
+                resource_field=field,
+                parameter_name=property_name,
+                parameter_location=ParameterLocation.BODY,
             )
+            continue
+
+        # Skip generic property names & optional fields (at least for now)
+        if property_name in GENERIC_FIELD_NAMES or property_name not in required:
+            continue
+
+        # Find candidate resources among known dependencies that actually have this field
+        candidates = [
+            resources[dep] for dep in known_dependencies if dep in resources and property_name in resources[dep].fields
+        ]
+
+        # Skip ambiguous cases when multiple resources have same field name
+        if len(candidates) != 1:
+            continue
+
+        resource = candidates[0]
+        # Ensure the target field supports the same type
+        if not resource.types[property_name] & set(get_type(subschema)):
+            continue
+
         yield InputSlot(
             resource=resource,
-            resource_field=field,
+            resource_field=property_name,
             parameter_name=property_name,
             parameter_location=ParameterLocation.BODY,
         )

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/stateful/dependencies/models.py

@@ -73,6 +73,11 @@ class DependencyGraph:
                                 parameters = {
                                     f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
                                 }
+                            existing = links.get(link_name)
+                            if existing is not None:
+                                existing.parameters.update(parameters)
+                                existing.request_body.update(request_body)
+                                continue
                             links[link_name] = LinkDefinition(
                                 operation_ref=f"#/paths/{consumer_path}/{consumer.method}",
                                 parameters=parameters,
@@ -267,18 +272,20 @@ class ResourceDefinition:
     name: str
     # A sorted list of resource fields
     fields: list[str]
+    # Field types mapping
+    types: dict[str, set[str]]
     # How this resource was created
     source: DefinitionSource
 
-    __slots__ = ("name", "fields", "source")
+    __slots__ = ("name", "fields", "types", "source")
 
     @classmethod
     def without_properties(cls, name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[], source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
+        return cls(name=name, fields=[], types={}, source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
 
     @classmethod
     def inferred_from_parameter(cls, name: str, parameter_name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[parameter_name], source=DefinitionSource.PARAMETER_INFERENCE)
+        return cls(name=name, fields=[parameter_name], types={}, source=DefinitionSource.PARAMETER_INFERENCE)
 
 
 class DefinitionSource(enum.IntEnum):

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -4,26 +4,45 @@ from __future__ import annotations
 def from_parameter(parameter: str, path: str) -> str | None:
     # TODO: support other naming patterns
     # Named like "userId" -> look for "User" resource
-    if parameter.endswith("Id"):
+    if parameter.endswith("Id") and len(parameter) > 2:
         return to_pascal_case(parameter[:-2])
     # Named like "user_id" -> look for "User" resource
     elif parameter.endswith("_id"):
         return to_pascal_case(parameter[:-3])
     # Just "id" -> infer from path context
     elif parameter == "id":
-        return from_path(path)
+        return from_path(path, parameter_name=parameter)
     return None
 
 
-def from_path(path: str) -> str | None:
-    segments = [s for s in path.split("/") if s and "{" not in s]
+def from_path(path: str, parameter_name: str | None = None) -> str | None:
+    """Detect resource name from OpenAPI path."""
+    segments = [s for s in path.split("/") if s]
 
     if not segments:
         # API Root
         return None
 
-    singular = to_singular(segments[-1])
-    return to_pascal_case(singular)
+    # If parameter name provided, find the resource it refers to
+    if parameter_name:
+        placeholder = f"{{{parameter_name}}}"
+        try:
+            param_index = segments.index(placeholder)
+            if param_index > 0:
+                resource_segment = segments[param_index - 1]
+                if "{" not in resource_segment:
+                    singular = to_singular(resource_segment)
+                    return to_pascal_case(singular)
+        except ValueError:
+            pass  # Parameter not found in path
+
+    # Fallback to last non-parameter segment
+    non_param_segments = [s for s in segments if "{" not in s]
+    if non_param_segments:
+        singular = to_singular(non_param_segments[-1])
+        return to_pascal_case(singular)
+
+    return None
 
 
 IRREGULAR_TO_PLURAL = {

{schemathesis-4.3.4 → schemathesis-4.3.6}/src/schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Iterator, Mapping, cast
 
 from schemathesis.core.errors import InfiniteRecursiveReference
 from schemathesis.core.jsonschema.bundler import BundleError
+from schemathesis.core.jsonschema.types import get_type
 from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
 from schemathesis.specs.openapi.adapter.references import maybe_resolve
 from schemathesis.specs.openapi.stateful.dependencies import naming
@@ -265,18 +266,21 @@ def _extract_resource_from_schema(
 
         properties = resolved.get("properties")
         if properties:
-            fields = list(properties)
+            fields = sorted(properties)
+            types = {field: set(get_type(subschema)) for field, subschema in properties.items()}
             source = DefinitionSource.SCHEMA_WITH_PROPERTIES
         else:
             fields = []
+            types = {}
             source = DefinitionSource.SCHEMA_WITHOUT_PROPERTIES
         if resource is not None:
             if resource.source < source:
                 resource.source = source
                 resource.fields = fields
+                resource.types = types
                 updated_resources.add(resource_name)
         else:
-            resource = ResourceDefinition(name=resource_name, fields=fields, source=source)
+            resource = ResourceDefinition(name=resource_name, fields=fields, types=types, source=source)
             resources[resource_name] = resource
 
     return resource

{schemathesis-4.3.4 → schemathesis-4.3.6}/test/cli/__snapshots__/test_checks/test_ensure_resource_availability_does_not_trigger_on_subsequent_error.raw

@@ -19,7 +19,7 @@ Schemathesis dev
  ✅  Stateful (in 0.00s)
 
      Scenarios:    N
-     API Links:    N covered / 2 selected / 2 total
+     API Links:    N covered / 3 selected / 3 total (1 inferred)
 
      ✅ N passed
 

{schemathesis-4.3.4 → schemathesis-4.3.6}/test/cli/__snapshots__/test_checks/test_use_after_free_does_not_trigger_on_error.raw

@@ -19,7 +19,7 @@ Schemathesis dev
  ✅  Stateful (in 0.00s)
 
      Scenarios:    N
-     API Links:    N covered / 2 selected / 2 total
+     API Links:    N covered / 3 selected / 3 total (1 inferred)
 
      ✅ N passed
 

{schemathesis-4.3.4 → schemathesis-4.3.6}/test/conftest.py

@@ -302,6 +302,7 @@ class CliSnapshotConfig:
     replace_test_cases: bool = True
     replace_phase_statistic: bool = False
     remove_last_line: bool = False
+    replace: bool = True
 
     @classmethod
     def from_request(cls, request: FixtureRequest) -> CliSnapshotConfig:
@@ -315,6 +316,8 @@ class CliSnapshotConfig:
         return self.request.getfixturevalue("testdir")
 
     def serialize(self, data: str) -> str:
+        if not self.replace:
+            return data
         if self.replace_test_cases:
             data = re.sub(r"Test cases:\n  (\d+) generated, \1 skipped", "Test cases:\n  N generated, N skipped", data)
             # Cases with failures and skips

{schemathesis-4.3.4 → schemathesis-4.3.6}/test/core/jsonschema/test_bundler.py

@@ -1,6 +1,7 @@
 import pytest
 
 from schemathesis.core.compat import RefResolutionError, RefResolver
+from schemathesis.core.errors import InfiniteRecursiveReference
 from schemathesis.core.jsonschema import BUNDLE_STORAGE_KEY, bundle
 from schemathesis.core.jsonschema.bundler import BundleError
 from schemathesis.core.transforms import deepclone
@@ -451,3 +452,41 @@ def test_bundles_open_api_schemas(schema):
     # This is a smoke test, they should be bundled without errors
     resolver = RefResolver.from_schema(deepclone(schema))
     bundle(deepclone(schema), resolver, inline_recursive=True)
+
+
+def test_bundle_infinite_recursive_required_cycle_message():
+    schema = {"$ref": "#/definitions/A"}
+    store = {
+        "definitions": {
+            "A": {
+                "type": "object",
+                "properties": {"b": {"$ref": "#/definitions/B"}},
+                "required": ["b"],  # cannot remove `b` without breaking A
+            },
+            "B": {
+                "type": "object",
+                "properties": {"c": {"$ref": "#/definitions/C"}},
+                "required": ["c"],
+            },
+            "C": {
+                "type": "object",
+                "properties": {"a": {"$ref": "#/definitions/A"}},
+                "required": ["a"],
+            },
+        }
+    }
+
+    resolver = RefResolver.from_schema(store)
+
+    with pytest.raises(InfiniteRecursiveReference) as exc:
+        bundle(schema, resolver, inline_recursive=True)
+
+    assert (
+        str(exc.value)
+        == """Schema `#/definitions/A` has required references forming a cycle:
+
+  #/definitions/A ->
+  #/definitions/B ->
+  #/definitions/C ->
+  #/definitions/A"""
+    )