schemathesis 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

schemathesis/generation/hypothesis/builder.py

@@ -21,8 +21,15 @@ from schemathesis import auths
 from schemathesis.auths import AuthStorage, AuthStorageMark
 from schemathesis.config import GenerationConfig, ProjectConfig
 from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, SpecificationFeature, media_types
-from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
+from schemathesis.core.errors import (
+    InfiniteRecursiveReference,
+    InvalidSchema,
+    MalformedMediaType,
+    SerializationNotPossible,
+    UnresolvableReference,
+)
 from schemathesis.core.marks import Mark
+from schemathesis.core.parameters import LOCATION_TO_CONTAINER, ParameterLocation
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import prepare_urlencoded
 from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
@@ -34,7 +41,6 @@ from schemathesis.generation.hypothesis.given import GivenInput
 from schemathesis.generation.meta import (
     CaseMetadata,
     ComponentInfo,
-    ComponentKind,
     CoveragePhaseData,
     GenerationInfo,
     PhaseInfo,
@@ -263,16 +269,15 @@ def generate_example_cases(
     **kwargs: Any,
 ) -> Generator[Case]:
     """Add examples to the Hypothesis test, if they are specified in the schema."""
-    from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-
     try:
         result: list[Case] = [
             examples.generate_one(strategy) for strategy in operation.get_strategies_from_examples(**kwargs)
         ]
     except (
         InvalidSchema,
-        HypothesisRefResolutionError,
+        InfiniteRecursiveReference,
         Unsatisfiable,
+        UnresolvableReference,
         SerializationNotPossible,
         SchemaError,
     ) as exc:
@@ -283,6 +288,10 @@ def generate_example_cases(
             NonSerializableMark.set(test, exc)
         if isinstance(exc, SchemaError):
             InvalidRegexMark.set(test, exc)
+        if isinstance(exc, InfiniteRecursiveReference):
+            InfiniteRecursiveReferenceMark.set(test, exc)
+        if isinstance(exc, UnresolvableReference):
+            UnresolvableReferenceMark.set(test, exc)
 
     if fill_missing and not result:
         strategy = operation.as_strategy()
@@ -347,7 +356,7 @@ def generate_coverage_cases(
     unexpected_methods: set[str],
     generation_config: GenerationConfig,
 ) -> Generator[Case]:
-    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+    from schemathesis.core.parameters import LOCATION_TO_CONTAINER
 
     auth_context = auths.AuthContext(
         operation=operation,
@@ -397,7 +406,7 @@ class Template:
     __slots__ = ("_components", "_template", "_serializers")
 
     def __init__(self, serializers: dict[str, Callable]) -> None:
-        self._components: dict[ComponentKind, ComponentInfo] = {}
+        self._components: dict[ParameterLocation, ComponentInfo] = {}
         self._template: dict[str, Any] = {}
         self._serializers = serializers
 
@@ -410,24 +419,20 @@ class Template:
     def get(self, key: str, default: Any = None) -> dict:
         return self._template.get(key, default)
 
-    def add_parameter(self, location: str, name: str, value: coverage.GeneratedValue) -> None:
-        from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
-
-        component_name = LOCATION_TO_CONTAINER[location]
-        kind = ComponentKind(component_name)
-        info = self._components.get(kind)
+    def add_parameter(self, location: ParameterLocation, name: str, value: coverage.GeneratedValue) -> None:
+        info = self._components.get(location)
         if info is None:
-            self._components[kind] = ComponentInfo(mode=value.generation_mode)
+            self._components[location] = ComponentInfo(mode=value.generation_mode)
         elif value.generation_mode == GenerationMode.NEGATIVE:
             info.mode = GenerationMode.NEGATIVE
 
-        container = self._template.setdefault(component_name, {})
+        container = self._template.setdefault(location.container_name, {})
         container[name] = value.value
 
     def set_body(self, body: coverage.GeneratedValue, media_type: str) -> None:
         self._template["body"] = body.value
         self._template["media_type"] = media_type
-        self._components[ComponentKind.BODY] = ComponentInfo(mode=body.generation_mode)
+        self._components[ParameterLocation.BODY] = ComponentInfo(mode=body.generation_mode)
 
     def _serialize(self, kwargs: dict[str, Any]) -> dict[str, Any]:
         from schemathesis.specs.openapi._hypothesis import quote_all
@@ -454,21 +459,24 @@ class Template:
     def with_body(self, *, media_type: str, value: coverage.GeneratedValue) -> TemplateValue:
         kwargs = {**self._template, "media_type": media_type, "body": value.value}
         kwargs = self._serialize(kwargs)
-        components = {**self._components, ComponentKind.BODY: ComponentInfo(mode=value.generation_mode)}
+        components = {**self._components, ParameterLocation.BODY: ComponentInfo(mode=value.generation_mode)}
         return TemplateValue(kwargs=kwargs, components=components)
 
-    def with_parameter(self, *, location: str, name: str, value: coverage.GeneratedValue) -> TemplateValue:
-        from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
-
-        container_name = LOCATION_TO_CONTAINER[location]
-        container = self._template[container_name]
-        return self.with_container(
-            container_name=container_name, value={**container, name: value.value}, generation_mode=value.generation_mode
+    def with_parameter(
+        self, *, location: ParameterLocation, name: str, value: coverage.GeneratedValue
+    ) -> TemplateValue:
+        container = self._template[location.container_name]
+        return self.with_location(
+            location=location,
+            value={**container, name: value.value},
+            generation_mode=value.generation_mode,
         )
 
-    def with_container(self, *, container_name: str, value: Any, generation_mode: GenerationMode) -> TemplateValue:
-        kwargs = {**self._template, container_name: value}
-        components = {**self._components, ComponentKind(container_name): ComponentInfo(mode=generation_mode)}
+    def with_location(
+        self, *, location: ParameterLocation, value: Any, generation_mode: GenerationMode
+    ) -> TemplateValue:
+        kwargs = {**self._template, location.container_name: value}
+        components = {**self._components, location: ComponentInfo(mode=generation_mode)}
         kwargs = self._serialize(kwargs)
         return TemplateValue(kwargs=kwargs, components=components)
 
@@ -476,7 +484,7 @@ class Template:
 @dataclass
 class TemplateValue:
     kwargs: dict[str, Any]
-    components: dict[ComponentKind, ComponentInfo]
+    components: dict[ParameterLocation, ComponentInfo]
 
     __slots__ = ("kwargs", "components")
 
@@ -510,17 +518,17 @@ def _iter_coverage_cases(
     generation_config: GenerationConfig,
 ) -> Generator[Case, None, None]:
     from schemathesis.specs.openapi._hypothesis import _build_custom_formats
-    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
-    from schemathesis.specs.openapi.examples import find_in_responses, find_matching_in_responses
+    from schemathesis.specs.openapi.examples import find_matching_in_responses
+    from schemathesis.specs.openapi.media_types import MEDIA_TYPES
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
     from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
-    generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
+    generators: dict[tuple[ParameterLocation, str], Generator[coverage.GeneratedValue, None, None]] = {}
     serializers = get_serializers_for_operation(operation)
     template = Template(serializers)
 
     instant = Instant()
-    responses = find_in_responses(operation)
+    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)
@@ -528,17 +536,23 @@ def _iter_coverage_cases(
     seen_negative = coverage.HashSet()
     seen_positive = coverage.HashSet()
     assert isinstance(operation.schema, BaseOpenAPISchema)
-    validator_cls = operation.schema.validator_cls
+    validator_cls = operation.schema.adapter.jsonschema_validator_cls
 
     for parameter in operation.iter_parameters():
         location = parameter.location
         name = parameter.name
-        schema = parameter.as_json_schema(operation, update_quantifiers=False)
+        schema = parameter.unoptimized_schema
+        examples = parameter.examples
+        if examples:
+            schema = dict(schema)
+            schema["examples"] = examples
         for value in find_matching_in_responses(responses, parameter.name):
             schema.setdefault("examples", []).append(value)
         gen = coverage.cover_schema_iter(
             coverage.CoverageContext(
+                root_schema=schema,
                 location=location,
+                media_type=None,
                 generation_modes=generation_modes,
                 is_required=parameter.is_required,
                 custom_formats=custom_formats,
@@ -548,6 +562,27 @@ def _iter_coverage_cases(
         )
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
+            if location == ParameterLocation.PATH:
+                # Can't skip path parameters - they should be filled
+                schema = dict(schema)
+                schema.setdefault("type", "string")
+                schema.setdefault("minLength", 1)
+                gen = coverage.cover_schema_iter(
+                    coverage.CoverageContext(
+                        root_schema=schema,
+                        location=location,
+                        media_type=None,
+                        generation_modes=[GenerationMode.POSITIVE],
+                        is_required=parameter.is_required,
+                        custom_formats=custom_formats,
+                        validator_cls=validator_cls,
+                    ),
+                    schema,
+                )
+                value = next(gen, NOT_SET)
+                assert not isinstance(value, NotSet), f"It should always be possible: {schema!r}"
+                template.add_parameter(location, name, value)
+                continue
             continue
         template.add_parameter(location, name, value)
         generators[(location, name)] = gen
@@ -555,15 +590,24 @@ def _iter_coverage_cases(
     if operation.body:
         for body in operation.body:
             instant = Instant()
-            schema = body.as_json_schema(operation, update_quantifiers=False)
-            # Definition could be a list for Open API 2.0
-            definition = body.definition if isinstance(body.definition, dict) else {}
-            examples = [example["value"] for example in definition.get("examples", {}).values() if "value" in example]
+            schema = body.unoptimized_schema
+            examples = body.examples
             if examples:
-                schema.setdefault("examples", []).extend(examples)
+                schema = dict(schema)
+                # User-registered media types should only handle text / binary data
+                if body.media_type in MEDIA_TYPES:
+                    schema["examples"] = [example for example in examples if isinstance(example, (str, bytes))]
+                else:
+                    schema["examples"] = examples
+            try:
+                media_type = media_types.parse(body.media_type)
+            except MalformedMediaType:
+                media_type = None
             gen = coverage.cover_schema_iter(
                 coverage.CoverageContext(
-                    location="body",
+                    root_schema=schema,
+                    location=ParameterLocation.BODY,
+                    media_type=media_type,
                     generation_modes=generation_modes,
                     is_required=body.is_required,
                     custom_formats=custom_formats,
@@ -591,7 +635,7 @@ def _iter_coverage_cases(
                         description=value.description,
                         location=value.location,
                         parameter=body.media_type,
-                        parameter_location="body",
+                        parameter_location=ParameterLocation.BODY,
                     ),
                 ),
             )
@@ -613,7 +657,7 @@ def _iter_coverage_cases(
                                 description=next_value.description,
                                 location=next_value.location,
                                 parameter=body.media_type,
-                                parameter_location="body",
+                                parameter_location=ParameterLocation.BODY,
                             ),
                         ),
                     )
@@ -689,8 +733,8 @@ def _iter_coverage_cases(
                 # I.e. contains just `default` value without any other keywords
                 value = container.get(parameter.name, NOT_SET)
                 if value is not NOT_SET:
-                    data = template.with_container(
-                        container_name="query",
+                    data = template.with_location(
+                        location=ParameterLocation.QUERY,
                         value={**container, parameter.name: [value, value]},
                         generation_mode=GenerationMode.NEGATIVE,
                     )
@@ -702,20 +746,19 @@ def _iter_coverage_cases(
                             phase=PhaseInfo.coverage(
                                 description=f"Duplicate `{parameter.name}` query parameter",
                                 parameter=parameter.name,
-                                parameter_location="query",
+                                parameter_location=ParameterLocation.QUERY,
                             ),
                         ),
                     )
         # Generate missing required parameters
         for parameter in operation.iter_parameters():
-            if parameter.is_required and parameter.location != "path":
+            if parameter.is_required and parameter.location != ParameterLocation.PATH:
                 instant = Instant()
                 name = parameter.name
                 location = parameter.location
-                container_name = LOCATION_TO_CONTAINER[location]
-                container = template.get(container_name, {})
-                data = template.with_container(
-                    container_name=container_name,
+                container = template.get(location.container_name, {})
+                data = template.with_location(
+                    location=location,
                     value={k: v for k, v in container.items() if k != name},
                     generation_mode=GenerationMode.NEGATIVE,
                 )
@@ -727,7 +770,7 @@ def _iter_coverage_cases(
                             generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                             components=data.components,
                             phase=PhaseInfo.coverage(
-                                description=f"Missing `{name}` at {location}",
+                                description=f"Missing `{name}` at {location.value}",
                                 parameter=name,
                                 parameter_location=location,
                             ),
@@ -735,14 +778,14 @@ def _iter_coverage_cases(
                     )
     # Generate combinations for each location
     for location, parameter_set in [
-        ("query", operation.query),
-        ("header", operation.headers),
-        ("cookie", operation.cookies),
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
     ]:
         if not parameter_set:
             continue
 
-        container_name = LOCATION_TO_CONTAINER[location]
+        container_name = location.container_name
         base_container = template.get(container_name, {})
 
         # Get required and optional parameters
@@ -754,15 +797,12 @@ def _iter_coverage_cases(
         def make_case(
             container_values: dict,
             description: str,
-            _location: str,
-            _container_name: str,
+            _location: ParameterLocation,
             _parameter: str | None,
             _generation_mode: GenerationMode,
             _instant: Instant,
         ) -> Case:
-            data = template.with_container(
-                container_name=_container_name, value=container_values, generation_mode=_generation_mode
-            )
+            data = template.with_location(location=_location, value=container_values, generation_mode=_generation_mode)
             return operation.Case(
                 **data.kwargs,
                 _meta=CaseMetadata(
@@ -784,7 +824,7 @@ def _iter_coverage_cases(
         ) -> dict[str, Any]:
             return {
                 "properties": {
-                    parameter.name: parameter.as_json_schema(operation)
+                    parameter.name: parameter.optimized_schema
                     for parameter in _parameter_set
                     if parameter.name in combination
                 },
@@ -793,12 +833,14 @@ def _iter_coverage_cases(
             }
 
         def _yield_negative(
-            subschema: dict[str, Any], _location: str, _container_name: str, is_required: bool
+            subschema: dict[str, Any], _location: ParameterLocation, is_required: bool
         ) -> Generator[Case, None, None]:
             iterator = iter(
                 coverage.cover_schema_iter(
                     coverage.CoverageContext(
+                        root_schema=subschema,
                         location=_location,
+                        media_type=None,
                         generation_modes=[GenerationMode.NEGATIVE],
                         is_required=is_required,
                         custom_formats=custom_formats,
@@ -815,7 +857,6 @@ def _iter_coverage_cases(
                         more.value,
                         more.description,
                         _location,
-                        _container_name,
                         more.parameter,
                         GenerationMode.NEGATIVE,
                         instant,
@@ -831,14 +872,13 @@ def _iter_coverage_cases(
                     only_required,
                     "Only required properties",
                     location,
-                    container_name,
                     None,
                     GenerationMode.POSITIVE,
                     Instant(),
                 )
             if GenerationMode.NEGATIVE in generation_modes:
                 subschema = _combination_schema(only_required, required, parameter_set)
-                for case in _yield_negative(subschema, location, container_name, is_required=bool(required)):
+                for case in _yield_negative(subschema, location, is_required=bool(required)):
                     kwargs = _case_to_kwargs(case)
                     if not seen_negative.insert(kwargs):
                         continue
@@ -858,14 +898,13 @@ def _iter_coverage_cases(
                     combo,
                     f"All required properties and optional '{opt_param}'",
                     location,
-                    container_name,
                     None,
                     GenerationMode.POSITIVE,
                     Instant(),
                 )
                 if GenerationMode.NEGATIVE in generation_modes:
                     subschema = _combination_schema(combo, required, parameter_set)
-                    for case in _yield_negative(subschema, location, container_name, is_required=bool(required)):
+                    for case in _yield_negative(subschema, location, is_required=bool(required)):
                         assert case.meta is not None
                         assert isinstance(case.meta.phase.data, CoveragePhaseData)
                         # Already generated in one of the blocks above
@@ -884,7 +923,6 @@ def _iter_coverage_cases(
                             combo,
                             f"All required and {size} optional properties",
                             location,
-                            container_name,
                             None,
                             GenerationMode.POSITIVE,
                             Instant(),
@@ -892,8 +930,6 @@ def _iter_coverage_cases(
 
 
 def _case_to_kwargs(case: Case) -> dict:
-    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
-
     kwargs = {}
     for container_name in LOCATION_TO_CONTAINER.values():
         value = getattr(case, container_name)
@@ -915,3 +951,5 @@ NonSerializableMark = Mark[SerializationNotPossible](attr_name="non_serializable
 InvalidRegexMark = Mark[SchemaError](attr_name="invalid_regex")
 InvalidHeadersExampleMark = Mark[dict[str, str]](attr_name="invalid_example_header")
 MissingPathParameters = Mark[InvalidSchema](attr_name="missing_path_parameters")
+InfiniteRecursiveReferenceMark = Mark[InfiniteRecursiveReference](attr_name="infinite_recursive_reference")
+UnresolvableReferenceMark = Mark[UnresolvableReference](attr_name="unresolvable_reference")

schemathesis/generation/meta.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from enum import Enum
 
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.generation import GenerationMode
 
 
@@ -15,16 +16,6 @@ class TestPhase(str, Enum):
     STATEFUL = "stateful"
 
 
-class ComponentKind(str, Enum):
-    """Components that can be generated."""
-
-    QUERY = "query"
-    PATH_PARAMETERS = "path_parameters"
-    HEADERS = "headers"
-    COOKIES = "cookies"
-    BODY = "body"
-
-
 @dataclass
 class ComponentInfo:
     """Information about how a specific component was generated."""
@@ -62,7 +53,7 @@ class CoveragePhaseData:
     description: str
     location: str | None
     parameter: str | None
-    parameter_location: str | None
+    parameter_location: ParameterLocation | None
 
     __slots__ = ("description", "location", "parameter", "parameter_location")
 
@@ -82,7 +73,7 @@ class PhaseInfo:
         description: str,
         location: str | None = None,
         parameter: str | None = None,
-        parameter_location: str | None = None,
+        parameter_location: ParameterLocation | None = None,
     ) -> PhaseInfo:
         return cls(
             name=TestPhase.COVERAGE,
@@ -111,7 +102,7 @@ class CaseMetadata:
     """Complete metadata for generated cases."""
 
     generation: GenerationInfo
-    components: dict[ComponentKind, ComponentInfo]
+    components: dict[ParameterLocation, ComponentInfo]
     phase: PhaseInfo
 
     __slots__ = ("generation", "components", "phase")
@@ -119,7 +110,7 @@ class CaseMetadata:
     def __init__(
         self,
         generation: GenerationInfo,
-        components: dict[ComponentKind, ComponentInfo],
+        components: dict[ParameterLocation, ComponentInfo],
         phase: PhaseInfo,
     ) -> None:
         self.generation = generation

schemathesis/generation/overrides.py

@@ -5,12 +5,12 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Iterator
 
 from schemathesis.config import ProjectConfig
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import diff
-from schemathesis.generation.meta import ComponentKind
 
 if TYPE_CHECKING:
     from schemathesis.generation.case import Case
-    from schemathesis.schemas import APIOperation, Parameter
+    from schemathesis.schemas import APIOperation, OperationParameter
 
 
 @dataclass
@@ -24,21 +24,21 @@ class Override:
 
     __slots__ = ("query", "headers", "cookies", "path_parameters")
 
-    def items(self) -> Iterator[tuple[str, dict[str, str]]]:
+    def items(self) -> Iterator[tuple[ParameterLocation, dict[str, str]]]:
         for key, value in (
-            ("query", self.query),
-            ("headers", self.headers),
-            ("cookies", self.cookies),
-            ("path_parameters", self.path_parameters),
+            (ParameterLocation.QUERY, self.query),
+            (ParameterLocation.HEADER, self.headers),
+            (ParameterLocation.COOKIE, self.cookies),
+            (ParameterLocation.PATH, self.path_parameters),
         ):
             if value:
                 yield key, value
 
     @classmethod
-    def from_components(cls, components: dict[ComponentKind, StoredValue], case: Case) -> Override:
+    def from_components(cls, components: dict[ParameterLocation, StoredValue], case: Case) -> Override:
         return Override(
             **{
-                kind.value: get_component_diff(stored=stored, current=getattr(case, kind.value))
+                kind.container_name: get_component_diff(stored=stored, current=getattr(case, kind.container_name))
                 for kind, stored in components.items()
             }
         )
@@ -69,9 +69,9 @@ def for_operation(config: ProjectConfig, *, operation: APIOperation) -> Override
     return output
 
 
-def _get_override_value(param: Parameter, parameters: dict[str, Any]) -> Any:
+def _get_override_value(param: OperationParameter, parameters: dict[str, Any]) -> Any:
     key = param.name
-    full_key = f"{param.location}.{param.name}"
+    full_key = f"{param.location.value}.{param.name}"
     if key in parameters:
         return parameters[key]
     elif full_key in parameters:
@@ -102,17 +102,17 @@ def get_component_diff(stored: StoredValue, current: dict[str, Any] | None) -> d
     return current
 
 
-def store_components(case: Case) -> dict[ComponentKind, StoredValue]:
+def store_components(case: Case) -> dict[ParameterLocation, StoredValue]:
     """Store original component states for a test case."""
     return {
         kind: StoredValue(
-            value=store_original_state(getattr(case, kind.value)),
+            value=store_original_state(getattr(case, kind.container_name)),
             is_generated=bool(case.meta and kind in case.meta.components),
         )
         for kind in [
-            ComponentKind.QUERY,
-            ComponentKind.HEADERS,
-            ComponentKind.COOKIES,
-            ComponentKind.PATH_PARAMETERS,
+            ParameterLocation.QUERY,
+            ParameterLocation.HEADER,
+            ParameterLocation.COOKIE,
+            ParameterLocation.PATH,
         ]
     }

schemathesis/pytest/lazy.py

@@ -187,7 +187,7 @@ class LazySchema:
                 def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
                     override = overrides.for_operation(config=schema.config, operation=_operation)
 
-                    return {location: entry for location, entry in override.items() if entry}
+                    return {location.container_name: entry for location, entry in override.items() if entry}
 
                 tests = list(
                     get_all_tests(

schemathesis/pytest/plugin.py

@@ -14,7 +14,6 @@ from jsonschema.exceptions import SchemaError
 
 from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import (
-    RECURSIVE_REFERENCE_ERROR_MESSAGE,
     SERIALIZERS_SUGGESTION_MESSAGE,
     IncorrectUsage,
     InvalidHeadersExample,
@@ -147,7 +146,7 @@ class SchemathesisCase(PyCollector):
                 if override is not None:
                     for location, entry in override.items():
                         if entry:
-                            as_strategy_kwargs[location] = entry
+                            as_strategy_kwargs[location.container_name] = entry
                 modes = []
                 phases = self.schema.config.phases_for(operation=operation)
                 if phases.examples.enabled:
@@ -293,8 +292,6 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
 
     For example - kwargs validation is failed for some strategy.
     """
-    from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-
     from schemathesis.generation.hypothesis.builder import (
         InvalidHeadersExampleMark,
         InvalidRegexMark,
@@ -312,8 +309,6 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
             if "Inconsistent args" in str(exc) and "@example()" in str(exc):
                 raise IncorrectUsage(GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE) from None
             raise InvalidSchema(exc.args[0]) from None
-        except HypothesisRefResolutionError:
-            pytest.skip(RECURSIVE_REFERENCE_ERROR_MESSAGE)
         except (SkipTest, unittest.SkipTest) as exc:
             if UnsatisfiableExampleMark.is_set(pyfuncitem.obj):
                 raise Unsatisfiable("Failed to generate test cases from examples for this API operation") from None