schemathesis 4.0.0a3__py3-none-any.whl → 4.0.0a5__py3-none-any.whl

schemathesis/generation/hypothesis/builder.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import json
 from dataclasses import dataclass, field
+from enum import Enum
 from functools import wraps
 from itertools import combinations
 from time import perf_counter
@@ -13,62 +13,41 @@ from hypothesis import strategies as st
 from hypothesis.errors import Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
-from schemathesis.auths import AuthStorageMark
-from schemathesis.core import NOT_SET, NotSet, media_types
+from schemathesis import auths
+from schemathesis.auths import AuthStorage, AuthStorageMark
+from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types
 from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
 from schemathesis.core.marks import Mark
-from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import prepare_urlencoded
 from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
-from schemathesis.experimental import COVERAGE_PHASE
 from schemathesis.generation import GenerationConfig, GenerationMode, coverage
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import DEFAULT_DEADLINE, examples, setup, strategies
 from schemathesis.generation.hypothesis.given import GivenInput
-from schemathesis.generation.meta import CaseMetadata, CoveragePhaseData, GenerationInfo, PhaseInfo
+from schemathesis.generation.meta import (
+    CaseMetadata,
+    ComponentInfo,
+    ComponentKind,
+    CoveragePhaseData,
+    GenerationInfo,
+    PhaseInfo,
+)
 from schemathesis.hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookDispatcherMark
-from schemathesis.schemas import APIOperation, BaseSchema, ParameterSet
+from schemathesis.schemas import APIOperation, ParameterSet
 
 setup()
 
 
-def get_all_tests(
-    *,
-    schema: BaseSchema,
-    test_func: Callable,
-    generation_config: GenerationConfig,
-    settings: hypothesis.settings | None = None,
-    seed: int | None = None,
-    as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None,
-    given_kwargs: dict[str, GivenInput] | None = None,
-) -> Generator[Result[tuple[APIOperation, Callable], InvalidSchema], None, None]:
-    """Generate all operations and Hypothesis tests for them."""
-    for result in schema.get_all_operations(generation_config=generation_config):
-        if isinstance(result, Ok):
-            operation = result.ok()
-            if callable(as_strategy_kwargs):
-                _as_strategy_kwargs = as_strategy_kwargs(operation)
-            else:
-                _as_strategy_kwargs = {}
-            test = create_test(
-                operation=operation,
-                test_func=test_func,
-                config=HypothesisTestConfig(
-                    settings=settings,
-                    seed=seed,
-                    generation=generation_config,
-                    as_strategy_kwargs=_as_strategy_kwargs,
-                    given_kwargs=given_kwargs or {},
-                ),
-            )
-            yield Ok((operation, test))
-        else:
-            yield result
+class HypothesisTestMode(Enum):
+    EXAMPLES = "examples"
+    COVERAGE = "coverage"
+    FUZZING = "fuzzing"
 
 
 @dataclass
 class HypothesisTestConfig:
     generation: GenerationConfig
+    modes: list[HypothesisTestMode]
     settings: hypothesis.settings | None = None
     seed: int | None = None
     as_strategy_kwargs: dict[str, Any] = field(default_factory=dict)
@@ -124,16 +103,33 @@ def create_test(
         phases = tuple(phase for phase in settings.phases if phase != Phase.explain)
         settings = hypothesis.settings(settings, phases=phases)
 
+    # Remove `reuse` & `generate` phases to avoid yielding any test cases if we don't do fuzzing
+    if HypothesisTestMode.FUZZING not in config.modes and (
+        Phase.generate in settings.phases or Phase.reuse in settings.phases
+    ):
+        phases = tuple(phase for phase in settings.phases if phase not in (Phase.reuse, Phase.generate))
+        settings = hypothesis.settings(settings, phases=phases)
+
+    specification = operation.schema.specification
+
     # Add examples if explicit phase is enabled
-    if Phase.explicit in settings.phases:
+    if (
+        HypothesisTestMode.EXAMPLES in config.modes
+        and Phase.explicit in settings.phases
+        and specification.supports_feature(SpecificationFeature.EXAMPLES)
+    ):
         hypothesis_test = add_examples(hypothesis_test, operation, hook_dispatcher=hook_dispatcher, **strategy_kwargs)
 
-    if COVERAGE_PHASE.is_enabled:
-        # Ensure explicit phase is enabled if coverage is enabled
-        if Phase.explicit not in settings.phases:
-            phases = settings.phases + (Phase.explicit,)
-            settings = hypothesis.settings(settings, phases=phases)
-        hypothesis_test = add_coverage(hypothesis_test, operation, config.generation.modes)
+    if (
+        HypothesisTestMode.COVERAGE in config.modes
+        and Phase.explicit in settings.phases
+        and specification.supports_feature(SpecificationFeature.COVERAGE)
+        and not config.given_args
+        and not config.given_kwargs
+    ):
+        hypothesis_test = add_coverage(
+            hypothesis_test, operation, config.generation.modes, auth_storage, config.as_strategy_kwargs
+        )
 
     setattr(hypothesis_test, SETTINGS_ATTRIBUTE_NAME, settings)
 
@@ -184,6 +180,7 @@ def add_examples(
             NonSerializableMark.set(test, exc)
         if isinstance(exc, SchemaError):
             InvalidRegexMark.set(test, exc)
+
     context = HookContext(operation)  # context should be passed here instead
     GLOBAL_HOOK_DISPATCHER.dispatch("before_add_examples", context, result)
     operation.schema.hooks.dispatch("before_add_examples", context, result)
@@ -198,6 +195,7 @@ def add_examples(
                 continue
         adjust_urlencoded_payload(example)
         test = hypothesis.example(case=example)(test)
+
     return test
 
 
@@ -211,10 +209,37 @@ def adjust_urlencoded_payload(case: Case) -> None:
             pass
 
 
-def add_coverage(test: Callable, operation: APIOperation, generation_modes: list[GenerationMode]) -> Callable:
-    for example in _iter_coverage_cases(operation, generation_modes):
-        adjust_urlencoded_payload(example)
-        test = hypothesis.example(case=example)(test)
+def add_coverage(
+    test: Callable,
+    operation: APIOperation,
+    generation_modes: list[GenerationMode],
+    auth_storage: AuthStorage | None,
+    as_strategy_kwargs: dict[str, Any],
+) -> Callable:
+    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
+    auth_context = auths.AuthContext(
+        operation=operation,
+        app=operation.app,
+    )
+    overrides = {
+        container: as_strategy_kwargs[container]
+        for container in LOCATION_TO_CONTAINER.values()
+        if container in as_strategy_kwargs
+    }
+    for case in _iter_coverage_cases(operation, generation_modes):
+        if case.media_type and operation.schema.transport.get_first_matching_media_type(case.media_type) is None:
+            continue
+        adjust_urlencoded_payload(case)
+        auths.set_on_case(case, auth_context, auth_storage)
+        for container_name, value in overrides.items():
+            container = getattr(case, container_name)
+            if container is None:
+                setattr(case, container_name, value)
+            else:
+                container.update(value)
+
+        test = hypothesis.example(case=case)(test)
     return test
 
 
@@ -229,23 +254,123 @@ class Instant:
         return perf_counter() - self.start
 
 
+class Template:
+    __slots__ = ("_components", "_template", "_serializers")
+
+    def __init__(self, serializers: dict[str, Callable]) -> None:
+        self._components: dict[ComponentKind, ComponentInfo] = {}
+        self._template: dict[str, Any] = {}
+        self._serializers = serializers
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._template
+
+    def __getitem__(self, key: str) -> dict:
+        return self._template[key]
+
+    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)
+        if info is None:
+            self._components[kind] = ComponentInfo(mode=value.generation_mode)
+        elif value.generation_mode == GenerationMode.NEGATIVE:
+            info.mode = GenerationMode.NEGATIVE
+
+        container = self._template.setdefault(component_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)
+
+    def _serialize(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        from schemathesis.specs.openapi._hypothesis import quote_all
+
+        output = {}
+        for container_name, value in kwargs.items():
+            serializer = self._serializers.get(container_name)
+            if container_name in ("headers", "cookies") and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if serializer is not None:
+                value = serializer(value)
+            if container_name == "query" and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if container_name == "path_parameters" and isinstance(value, dict):
+                value = _stringify_value(quote_all(value), container_name)
+            output[container_name] = value
+        return output
+
+    def unmodified(self) -> TemplateValue:
+        kwargs = self._template.copy()
+        kwargs = self._serialize(kwargs)
+        return TemplateValue(kwargs=kwargs, components=self._components.copy())
+
+    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)}
+        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_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)}
+        kwargs = self._serialize(kwargs)
+        return TemplateValue(kwargs=kwargs, components=components)
+
+
+@dataclass
+class TemplateValue:
+    kwargs: dict[str, Any]
+    components: dict[ComponentKind, ComponentInfo]
+    __slots__ = ("kwargs", "components")
+
+
+def _stringify_value(val: Any, container_name: str) -> Any:
+    if val is None:
+        return "null"
+    if val is True:
+        return "true"
+    if val is False:
+        return "false"
+    if isinstance(val, (int, float)):
+        return str(val)
+    if isinstance(val, list):
+        if container_name == "query":
+            # Having a list here ensures there will be multiple query parameters wit the same name
+            return [_stringify_value(item, container_name) for item in val]
+        # use comma-separated values style for arrays
+        return ",".join(_stringify_value(sub, container_name) for sub in val)
+    if isinstance(val, dict):
+        return {key: _stringify_value(sub, container_name) for key, sub in val.items()}
+    return val
+
+
 def _iter_coverage_cases(
     operation: APIOperation, generation_modes: list[GenerationMode]
 ) -> Generator[Case, None, None]:
     from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
     from schemathesis.specs.openapi.examples import find_in_responses, find_matching_in_responses
-
-    def _stringify_value(val: Any, location: str) -> str | list[str]:
-        if isinstance(val, list):
-            if location == "query":
-                # Having a list here ensures there will be multiple query parameters wit the same name
-                return [json.dumps(item) for item in val]
-            # use comma-separated values style for arrays
-            return ",".join(json.dumps(sub) for sub in val)
-        return json.dumps(val)
+    from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
-    template: dict[str, Any] = {}
+    serializers = get_serializers_for_operation(operation)
+    template = Template(serializers)
 
     instant = Instant()
     responses = find_in_responses(operation)
@@ -261,11 +386,7 @@ def _iter_coverage_cases(
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
             continue
-        container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-            container[name] = _stringify_value(value.value, location)
-        else:
-            container[name] = value.value
+        template.add_parameter(location, name, value)
         generators[(location, name)] = gen
     template_time = instant.elapsed
     if operation.body:
@@ -286,16 +407,16 @@ def _iter_coverage_cases(
             elapsed = instant.elapsed
             if "body" not in template:
                 template_time += elapsed
-                template["body"] = value.value
-                template["media_type"] = body.media_type
+                template.set_body(value, body.media_type)
+            data = template.with_body(value=value, media_type=body.media_type)
             yield operation.Case(
-                **{**template, "body": value.value, "media_type": body.media_type},
+                **data.kwargs,
                 meta=CaseMetadata(
                     generation=GenerationInfo(
                         time=elapsed,
                         mode=value.generation_mode,
                     ),
-                    components={},
+                    components=data.components,
                     phase=PhaseInfo.coverage(
                         description=value.description,
                         location=value.location,
@@ -309,14 +430,15 @@ def _iter_coverage_cases(
                 instant = Instant()
                 try:
                     next_value = next(iterator)
+                    data = template.with_body(value=next_value, media_type=body.media_type)
                     yield operation.Case(
-                        **{**template, "body": next_value.value, "media_type": body.media_type},
+                        **data.kwargs,
                         meta=CaseMetadata(
                             generation=GenerationInfo(
                                 time=instant.elapsed,
                                 mode=value.generation_mode,
                             ),
-                            components={},
+                            components=data.components,
                             phase=PhaseInfo.coverage(
                                 description=next_value.description,
                                 location=next_value.location,
@@ -328,37 +450,34 @@ def _iter_coverage_cases(
                 except StopIteration:
                     break
     elif GenerationMode.POSITIVE in generation_modes:
+        data = template.unmodified()
         yield operation.Case(
-            **template,
+            **data.kwargs,
             meta=CaseMetadata(
                 generation=GenerationInfo(
                     time=template_time,
                     mode=GenerationMode.POSITIVE,
                 ),
-                components={},
+                components=data.components,
                 phase=PhaseInfo.coverage(description="Default positive test case"),
             ),
         )
 
     for (location, name), gen in generators.items():
-        container_name = LOCATION_TO_CONTAINER[location]
-        container = template[container_name]
         iterator = iter(gen)
         while True:
             instant = Instant()
             try:
                 value = next(iterator)
-                if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-                    generated = _stringify_value(value.value, location)
-                else:
-                    generated = value.value
+                data = template.with_parameter(location=location, name=name, value=value)
             except StopIteration:
                 break
+
             yield operation.Case(
-                **{**template, container_name: {**container, name: generated}},
+                **data.kwargs,
                 meta=CaseMetadata(
                     generation=GenerationInfo(time=instant.elapsed, mode=value.generation_mode),
-                    components={},
+                    components=data.components,
                     phase=PhaseInfo.coverage(
                         description=value.description,
                         location=value.location,
@@ -372,12 +491,13 @@ def _iter_coverage_cases(
         methods = {"get", "put", "post", "delete", "options", "patch", "trace"} - set(operation.schema[operation.path])
         for method in sorted(methods):
             instant = Instant()
+            data = template.unmodified()
             yield operation.Case(
-                **template,
+                **data.kwargs,
                 method=method.upper(),
                 meta=CaseMetadata(
                     generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
-                    components={},
+                    components=data.components,
                     phase=PhaseInfo.coverage(description=f"Unspecified HTTP method: {method.upper()}"),
                 ),
             )
@@ -390,11 +510,16 @@ 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",
+                        value={**container, parameter.name: [value, value]},
+                        generation_mode=GenerationMode.NEGATIVE,
+                    )
                     yield operation.Case(
-                        **{**template, "query": {**container, parameter.name: [value, value]}},
+                        **data.kwargs,
                         meta=CaseMetadata(
                             generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
-                            components={},
+                            components=data.components,
                             phase=PhaseInfo.coverage(
                                 description=f"Duplicate `{parameter.name}` query parameter",
                                 parameter=parameter.name,
@@ -410,11 +535,16 @@ def _iter_coverage_cases(
                 location = parameter.location
                 container_name = LOCATION_TO_CONTAINER[location]
                 container = template[container_name]
+                data = template.with_container(
+                    container_name=container_name,
+                    value={k: v for k, v in container.items() if k != name},
+                    generation_mode=GenerationMode.NEGATIVE,
+                )
                 yield operation.Case(
-                    **{**template, container_name: {k: v for k, v in container.items() if k != name}},
+                    **data.kwargs,
                     meta=CaseMetadata(
                         generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
-                        components={},
+                        components=data.components,
                         phase=PhaseInfo.coverage(
                             description=f"Missing `{name}` at {location}",
                             parameter=name,
@@ -449,22 +579,17 @@ def _iter_coverage_cases(
             _generation_mode: GenerationMode,
             _instant: Instant,
         ) -> Case:
-            if _location in ("header", "cookie", "path", "query"):
-                container = {
-                    name: _stringify_value(val, _location) if not isinstance(val, str) else val
-                    for name, val in container_values.items()
-                }
-            else:
-                container = container_values
-
+            data = template.with_container(
+                container_name=_container_name, value=container_values, generation_mode=_generation_mode
+            )
             return operation.Case(
-                **{**template, _container_name: container},
+                **data.kwargs,
                 meta=CaseMetadata(
                     generation=GenerationInfo(
                         time=_instant.elapsed,
                         mode=_generation_mode,
                     ),
-                    components={},
+                    components=data.components,
                     phase=PhaseInfo.coverage(
                         description=description,
                         parameter=_parameter,

schemathesis/generation/stateful/state_machine.py

@@ -68,6 +68,52 @@ class ExtractedParam:
     __slots__ = ("definition", "value")
 
 
+@dataclass
+class ExtractionFailure:
+    """Represents a failure to extract data from a transition."""
+
+    # e.g., "GetUser"
+    id: str
+    case_id: str
+    # e.g., "POST /users"
+    source: str
+    # e.g., "GET /users/{userId}"
+    target: str
+    # e.g., "userId"
+    parameter_name: str
+    # e.g., "$response.body#/id"
+    expression: str
+    # Previous test cases in the chain, from newest to oldest
+    # Stored as a case + response pair
+    history: list[tuple[Case, Response]]
+    # The actual response that caused the failure
+    response: Response
+    error: Exception | None
+
+    __slots__ = ("id", "case_id", "source", "target", "parameter_name", "expression", "history", "response", "error")
+
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, ExtractionFailure)
+        return (
+            self.source == other.source
+            and self.target == other.target
+            and self.id == other.id
+            and self.parameter_name == other.parameter_name
+            and self.expression == other.expression
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.source,
+                self.target,
+                self.id,
+                self.parameter_name,
+                self.expression,
+            )
+        )
+
+
 @dataclass
 class StepOutput:
     """Output from a single transition of a state machine."""
@@ -172,7 +218,7 @@ class APIStateMachine(RuleBasedStateMachine):
         kwargs = self.get_call_kwargs(input.case)
         response = self.call(input.case, **kwargs)
         self.after_call(response, input.case)
-        self.validate_response(response, input.case)
+        self.validate_response(response, input.case, **kwargs)
         return StepOutput(response, input.case)
 
     def before_call(self, case: Case) -> None:
@@ -266,7 +312,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return {}
 
     def validate_response(
-        self, response: Response, case: Case, additional_checks: list[CheckFunction] | None = None
+        self, response: Response, case: Case, additional_checks: list[CheckFunction] | None = None, **kwargs: Any
     ) -> None:
         """Validate an API response.
 
@@ -298,4 +344,4 @@ class APIStateMachine(RuleBasedStateMachine):
         all provided checks rather than only the first encountered exception.
         """
         __tracebackhide__ = True
-        case.validate_response(response, additional_checks=additional_checks)
+        case.validate_response(response, additional_checks=additional_checks, transport_kwargs=kwargs)

schemathesis/openapi/checks.py

@@ -14,7 +14,9 @@ if TYPE_CHECKING:
 @dataclass
 class NegativeDataRejectionConfig:
     # 5xx will pass through
-    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "428", "5xx"])
+    allowed_statuses: list[str] = field(
+        default_factory=lambda: ["400", "401", "403", "404", "406", "422", "428", "5xx"]
+    )
 
 
 @dataclass

schemathesis/pytest/lazy.py

@@ -10,9 +10,10 @@ from hypothesis.core import HypothesisHandle
 from pytest_subtests import SubTests
 
 from schemathesis.core.errors import InvalidSchema
-from schemathesis.core.result import Ok
+from schemathesis.core.result import Ok, Result
 from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, RegexValue, is_deprecated
-from schemathesis.generation.hypothesis.builder import get_all_tests
+from schemathesis.generation import GenerationConfig
+from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode, create_test
 from schemathesis.generation.hypothesis.given import (
     GivenArgsMark,
     GivenInput,
@@ -27,11 +28,48 @@ from schemathesis.pytest.control_flow import fail_on_no_matches
 from schemathesis.schemas import BaseSchema
 
 if TYPE_CHECKING:
+    import hypothesis
     from _pytest.fixtures import FixtureRequest
 
     from schemathesis.schemas import APIOperation
 
 
+def get_all_tests(
+    *,
+    schema: BaseSchema,
+    test_func: Callable,
+    generation_config: GenerationConfig,
+    modes: list[HypothesisTestMode],
+    settings: hypothesis.settings | None = None,
+    seed: int | None = None,
+    as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None,
+    given_kwargs: dict[str, GivenInput] | None = None,
+) -> Generator[Result[tuple[APIOperation, Callable], InvalidSchema], None, None]:
+    """Generate all operations and Hypothesis tests for them."""
+    for result in schema.get_all_operations(generation_config=generation_config):
+        if isinstance(result, Ok):
+            operation = result.ok()
+            if callable(as_strategy_kwargs):
+                _as_strategy_kwargs = as_strategy_kwargs(operation)
+            else:
+                _as_strategy_kwargs = {}
+            test = create_test(
+                operation=operation,
+                test_func=test_func,
+                config=HypothesisTestConfig(
+                    settings=settings,
+                    modes=modes,
+                    seed=seed,
+                    generation=generation_config,
+                    as_strategy_kwargs=_as_strategy_kwargs,
+                    given_kwargs=given_kwargs or {},
+                ),
+            )
+            yield Ok((operation, test))
+        else:
+            yield result
+
+
 @dataclass
 class LazySchema:
     fixture_name: str
@@ -155,6 +193,7 @@ class LazySchema:
                         schema=schema,
                         test_func=test_func,
                         settings=settings,
+                        modes=list(HypothesisTestMode),
                         generation_config=schema.generation_config,
                         as_strategy_kwargs=as_strategy_kwargs,
                         given_kwargs=given_kwargs,
@@ -168,7 +207,7 @@ class LazySchema:
                 for result in tests:
                     if isinstance(result, Ok):
                         operation, sub_test = result.ok()
-                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.full_path}]"
+                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.path}]"
                         run_subtest(operation, fixtures, sub_test, subtests)
                     else:
                         _schema_error(subtests, result.err(), node_id)
@@ -236,8 +275,7 @@ SEPARATOR = "\n===================="
 def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> None:
     """Run a failing test, that will show the underlying problem."""
     sub_test = error.as_failing_test_function()
-    # `full_path` is always available in this case
-    kwargs = {"path": error.full_path}
+    kwargs = {"path": error.path}
     if error.method:
         kwargs["method"] = error.method.upper()
     subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)