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

schemathesis/cli/commands/run/validation.py

@@ -13,7 +13,7 @@ from urllib.parse import urlparse
 import click
 
 from schemathesis import errors, experimental
-from schemathesis.cli.commands.run.handlers.cassettes import CassetteFormat
+from schemathesis.cli.commands.run.reports import ReportFormat
 from schemathesis.cli.constants import DEFAULT_WORKERS
 from schemathesis.core import rate_limit, string_to_boolean
 from schemathesis.core.fs import file_exists
@@ -24,8 +24,10 @@ from schemathesis.generation.overrides import Override
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--generation-deterministic` implies no database, so passing `--generation-database` too is invalid."
 )
-MISSING_CASSETTE_PATH_ARGUMENT_MESSAGE = (
-    "Missing argument, `--cassette-path` should be specified as well if you use `--cassette-preserve-exact-body-bytes`."
+INVALID_REPORT_USAGE = (
+    "Can't use `--report-preserve-bytes` without enabling cassette formats. "
+    "Enable VCR or HAR format with `--report=vcr`, `--report-vcr-path`, "
+    "`--report=har`, or `--report-har-path`"
 )
 INVALID_SCHEMA_MESSAGE = "Invalid SCHEMA, must be a valid URL or file path."
 FILE_DOES_NOT_EXIST_MESSAGE = "The specified file does not exist. Please provide a valid path to an existing file."
@@ -33,7 +35,7 @@ INVALID_BASE_URL_MESSAGE = (
     "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
     "Make sure it is a properly formatted URL."
 )
-MISSING_BASE_URL_MESSAGE = "The `--base-url` option is required when specifying a schema via a file."
+MISSING_BASE_URL_MESSAGE = "The `--url` option is required when specifying a schema via a file."
 MISSING_REQUEST_CERT_MESSAGE = "The `--request-cert` option must be specified if `--request-cert-key` is used."
 
 
@@ -240,10 +242,18 @@ def validate_request_cert_key(
     return raw_value
 
 
-def validate_preserve_exact_body_bytes(ctx: click.core.Context, param: click.core.Parameter, raw_value: bool) -> bool:
-    if raw_value and ctx.params["cassette_path"] is None:
-        raise click.UsageError(MISSING_CASSETTE_PATH_ARGUMENT_MESSAGE)
-    return raw_value
+def validate_preserve_bytes(ctx: click.core.Context, param: click.core.Parameter, raw_value: bool) -> bool:
+    if not raw_value:
+        return False
+
+    report_formats = ctx.params.get("report_formats", []) or []
+    vcr_enabled = ReportFormat.VCR in report_formats or ctx.params.get("report_vcr_path")
+    har_enabled = ReportFormat.HAR in report_formats or ctx.params.get("report_har_path")
+
+    if not (vcr_enabled or har_enabled):
+        raise click.UsageError(INVALID_REPORT_USAGE)
+
+    return True
 
 
 def convert_experimental(
@@ -302,10 +312,6 @@ def convert_status_codes(
     return value
 
 
-def convert_cassette_format(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CassetteFormat:
-    return CassetteFormat.from_str(value)
-
-
 def convert_generation_mode(ctx: click.core.Context, param: click.core.Parameter, value: str) -> list[GenerationMode]:
     if value == "all":
         return GenerationMode.all()

schemathesis/cli/ext/groups.py

@@ -1,34 +1,59 @@
 from __future__ import annotations
 
-from collections import defaultdict
+import textwrap
 from typing import Any, Callable
 
 import click
 
-GROUPS: list[str] = []
+GROUPS: dict[str, OptionGroup] = {}
+
+
+class OptionGroup:
+    __slots__ = ("order", "name", "description", "options")
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        order: int | None = None,
+        description: str | None = None,
+    ):
+        self.name = name
+        self.description = description
+        self.order = order if order is not None else len(GROUPS) * 100
+        self.options: list[tuple[str, str]] = []
 
 
 class CommandWithGroupedOptions(click.Command):
     def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
-        groups = defaultdict(list)
+        # Collect options into groups or ungrouped list
         for param in self.get_params(ctx):
             rv = param.get_help_record(ctx)
             if rv is not None:
-                (option_repr, message) = rv
+                option_repr, message = rv
                 if isinstance(param.type, click.Choice):
                     message += (
                         getattr(param.type, "choices_repr", None)
                         or f" [possible values: {', '.join(param.type.choices)}]"
                     )
 
-                if isinstance(param, GroupedOption):
-                    group = param.group
+                if isinstance(param, GroupedOption) and param.group is not None:
+                    group = GROUPS.get(param.group)
+                    if group:
+                        group.options.append((option_repr, message))
                 else:
-                    group = "Global options"
-                groups[group].append((option_repr, message))
-        for group in GROUPS:
-            with formatter.section(group or "Options"):
-                formatter.write_dl(groups[group], col_max=40)
+                    GROUPS["Global options"].options.append((option_repr, message))
+
+        groups = sorted(GROUPS.values(), key=lambda g: g.order)
+        # Format each group
+        for group in groups:
+            with formatter.section(group.name):
+                if group.description:
+                    formatter.write(textwrap.indent(group.description, " " * formatter.current_indent))
+                    formatter.write("\n\n")
+
+                if group.options:
+                    formatter.write_dl(group.options)
 
 
 class GroupedOption(click.Option):
@@ -37,8 +62,12 @@ class GroupedOption(click.Option):
         self.group = group
 
 
-def group(name: str) -> Callable:
-    GROUPS.append(name)
+def group(
+    name: str,
+    *,
+    description: str | None = None,
+) -> Callable:
+    GROUPS[name] = OptionGroup(name, description=description)
 
     def _inner(cmd: Callable) -> Callable:
         for param in reversed(cmd.__click_params__):  # type: ignore[attr-defined]

schemathesis/cli/ext/options.py

@@ -22,8 +22,13 @@ class CustomHelpMessageChoice(click.Choice):
 
 class BaseCsvChoice(click.Choice):
     def parse_value(self, value: str) -> tuple[list[str], set[str]]:
-        selected = [item for item in value.split(",") if item]
-        invalid_options = set(selected) - set(self.choices)
+        selected = [item.strip() for item in value.split(",") if item.strip()]
+        if not self.case_sensitive:
+            invalid_options = {
+                item for item in selected if item.upper() not in {choice.upper() for choice in self.choices}
+            }
+        else:
+            invalid_options = set(selected) - set(self.choices)
         return selected, invalid_options
 
     def fail_on_invalid_options(self, invalid_options: set[str], selected: list[str]) -> NoReturn:  # type: ignore[misc]
@@ -44,16 +49,18 @@ class CsvChoice(BaseCsvChoice):
 
 
 class CsvEnumChoice(BaseCsvChoice):
-    def __init__(self, choices: type[Enum]):
+    def __init__(self, choices: type[Enum], case_sensitive: bool = False):
         self.enum = choices
-        super().__init__(tuple(el.name for el in choices))
+        super().__init__(tuple(el.name.lower() for el in choices), case_sensitive=case_sensitive)
 
-    def convert(  # type: ignore[return]
-        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> list[Enum]:
+    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[Enum]:
         selected, invalid_options = self.parse_value(value)
         if not invalid_options and selected:
-            return [self.enum[item] for item in selected]
+            # Match case-insensitively to find the correct enum
+            return [
+                next(enum_value for enum_value in self.enum if enum_value.value.upper() == item.upper())
+                for item in selected
+            ]
         self.fail_on_invalid_options(invalid_options, selected)
 
 

schemathesis/core/errors.py

@@ -35,20 +35,16 @@ class InvalidSchema(SchemathesisError):
 
     def __init__(
         self,
-        message: str | None = None,
+        message: str,
         path: str | None = None,
         method: str | None = None,
-        full_path: str | None = None,
     ) -> None:
         self.message = message
         self.path = path
         self.method = method
-        self.full_path = full_path
 
     @classmethod
-    def from_jsonschema_error(
-        cls, error: ValidationError, path: str | None, method: str | None, full_path: str | None
-    ) -> InvalidSchema:
+    def from_jsonschema_error(cls, error: ValidationError, path: str | None, method: str | None) -> InvalidSchema:
         if error.absolute_path:
             part = error.absolute_path[-1]
             if isinstance(part, int) and len(error.absolute_path) > 1:
@@ -69,11 +65,11 @@ class InvalidSchema(SchemathesisError):
         else:
             message += error.message
         message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
-        return cls(message, path=path, method=method, full_path=full_path)
+        return cls(message, path=path, method=method)
 
     @classmethod
     def from_reference_resolution_error(
-        cls, error: RefResolutionError, path: str | None, method: str | None, full_path: str | None
+        cls, error: RefResolutionError, path: str | None, method: str | None
     ) -> InvalidSchema:
         notes = getattr(error, "__notes__", [])
         # Some exceptions don't have the actual reference in them, hence we add it manually via notes
@@ -83,7 +79,7 @@ class InvalidSchema(SchemathesisError):
         message += f"\n\nError details:\n    JSON pointer: {pointer}"
         message += "\n    This typically means that the schema is referencing a component that doesn't exist."
         message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
-        return cls(message, path=path, method=method, full_path=full_path)
+        return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
         """Create a test function that will fail.
@@ -102,8 +98,80 @@ class InvalidRegexType(InvalidSchema):
     """Raised when an invalid type is used where a regex pattern is expected."""
 
 
-class InvalidLinkDefinition(InvalidSchema):
-    """Raised when an Open API link references a non-existent operation."""
+class InvalidStateMachine(SchemathesisError):
+    """Collection of validation errors found in API state machine transitions.
+
+    Raised during schema initialization when one or more transitions
+    contain invalid definitions, such as references to non-existent parameters
+    or operations.
+    """
+
+    errors: list[InvalidTransition]
+
+    __slots__ = ("errors",)
+
+    def __init__(self, errors: list[InvalidTransition]) -> None:
+        self.errors = errors
+
+    def __str__(self) -> str:
+        """Format state machine validation errors in a clear, hierarchical structure."""
+        result = "The following API operations contain invalid link definitions:"
+
+        # Group transitions by source operation, then by target and status
+        by_source: dict[str, dict[tuple[str, str], list[InvalidTransition]]] = {}
+        for transition in self.errors:
+            source_group = by_source.setdefault(transition.source, {})
+            target_key = (transition.target, transition.status_code)
+            source_group.setdefault(target_key, []).append(transition)
+
+        for source, target_groups in by_source.items():
+            for (target, status), transitions in target_groups.items():
+                for transition in transitions:
+                    result += f"\n\n  {_format_transition(source, status, transition.name, target)}\n"
+                    for error in transition.errors:
+                        result += f"\n     - {error.message}"
+        return result
+
+
+def _format_transition(source: str, status: str, transition: str, target: str) -> str:
+    return f"{source} -> [{status}] {transition} -> {target}"
+
+
+class InvalidTransition(SchemathesisError):
+    """Raised when a stateful transition contains one or more errors."""
+
+    name: str
+    source: str
+    target: str
+    status_code: str
+    errors: list[TransitionValidationError]
+
+    __slots__ = ("name", "source", "target", "status_code", "errors")
+
+    def __init__(
+        self,
+        name: str,
+        source: str,
+        target: str,
+        status_code: str,
+        errors: list[TransitionValidationError],
+    ) -> None:
+        self.name = name
+        self.source = source
+        self.target = target
+        self.status_code = status_code
+        self.errors = errors
+
+
+class TransitionValidationError(SchemathesisError):
+    """Single validation error found during stateful transition validation."""
+
+    message: str
+
+    __slots__ = ("message",)
+
+    def __init__(self, message: str) -> None:
+        self.message = message
 
 
 class MalformedMediaType(ValueError):

schemathesis/core/failures.py

@@ -228,9 +228,10 @@ class MalformedJson(Failure):
 
     @classmethod
     def from_exception(cls, *, operation: str, exc: JSONDecodeError) -> MalformedJson:
+        message = f"Response must be valid JSON with 'Content-Type: application/json' header:\n\n  {exc}"
         return cls(
             operation=operation,
-            message=str(exc),
+            message=message,
             validation_message=exc.msg,
             document=exc.doc,
             position=exc.pos,

schemathesis/core/transforms.py

@@ -106,7 +106,7 @@ def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | fl
         elif isinstance(target, list):
             try:
                 target = target[int(token)]
-            except IndexError:
+            except (IndexError, ValueError):
                 return UNRESOLVABLE
         else:
             return UNRESOLVABLE

schemathesis/engine/errors.py

@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 from schemathesis import errors
 from schemathesis.core.errors import (
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
-    InvalidLinkDefinition,
+    InvalidTransition,
     SerializationNotPossible,
     format_exception,
     get_request_error_extras,
@@ -77,7 +77,7 @@ class EngineErrorInfo:
         """A general error description."""
         import requests
 
-        if isinstance(self._error, InvalidLinkDefinition):
+        if isinstance(self._error, InvalidTransition):
             return "Invalid Link Definition"
 
         if isinstance(self._error, requests.RequestException):
@@ -101,6 +101,7 @@ class EngineErrorInfo:
         return {
             RuntimeErrorKind.SCHEMA_UNSUPPORTED: "Unsupported Schema",
             RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND: "Missing Open API links",
+            RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE: "Invalid OpenAPI Links Definition",
             RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Unknown GraphQL Scalar",
             RuntimeErrorKind.SERIALIZATION_UNBOUNDED_PREFIX: "XML serialization error",
             RuntimeErrorKind.SERIALIZATION_NOT_POSSIBLE: "Serialization not possible",
@@ -169,6 +170,7 @@ class EngineErrorInfo:
     def has_useful_traceback(self) -> bool:
         return self._kind not in (
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
+            RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE,
             RuntimeErrorKind.SCHEMA_UNSUPPORTED,
             RuntimeErrorKind.SCHEMA_GENERIC,
             RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND,
@@ -246,7 +248,7 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
         return f"Bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
 
     return {
-        RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--request-tls-verify=false`')}.",
+        RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--tls-verify=false`')}.",
         RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
         RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND: "Review your endpoint filters to include linked operations",
         RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
@@ -302,6 +304,7 @@ class RuntimeErrorKind(str, enum.Enum):
     HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE = "hypothesis_health_check_large_base_example"
 
     SCHEMA_INVALID_REGULAR_EXPRESSION = "schema_invalid_regular_expression"
+    SCHEMA_INVALID_STATE_MACHINE = "schema_invalid_state_machine"
     SCHEMA_NO_LINKS_FOUND = "schema_no_links_found"
     SCHEMA_UNSUPPORTED = "schema_unsupported"
     SCHEMA_GENERIC = "schema_generic"
@@ -354,6 +357,8 @@ def _classify(*, error: Exception) -> RuntimeErrorKind:
         if isinstance(error, errors.InvalidRegexPattern):
             return RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION
         return RuntimeErrorKind.SCHEMA_GENERIC
+    if isinstance(error, errors.InvalidStateMachine):
+        return RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE
     if isinstance(error, errors.NoLinksFound):
         return RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND
     if isinstance(error, UnsupportedRecursiveReference):

schemathesis/engine/phases/stateful/_executor.py

@@ -134,7 +134,7 @@ def execute_state_machine_loop(
             return result
 
         def validate_response(
-            self, response: Response, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
+            self, response: Response, case: Case, additional_checks: tuple[CheckFunction, ...] = (), **kwargs: Any
         ) -> None:
             self.recorder.record_response(case_id=case.id, response=response)
             ctx.collect_metric(case, response)

schemathesis/engine/phases/unit/__init__.py

@@ -123,7 +123,7 @@ def worker_task(*, events_queue: Queue, producer: TaskProducer, ctx: EngineConte
                 else:
                     error = result.err()
                     if error.method:
-                        label = f"{error.method.upper()} {error.full_path}"
+                        label = f"{error.method.upper()} {error.path}"
                         scenario_started = events.ScenarioStarted(
                             label=label, phase=PhaseName.UNIT_TESTING, suite_id=suite_id
                         )
@@ -149,12 +149,11 @@ def worker_task(*, events_queue: Queue, producer: TaskProducer, ctx: EngineConte
                             )
                         )
                     else:
-                        assert error.full_path is not None
                         events_queue.put(
                             events.NonFatalError(
                                 error=error,
                                 phase=PhaseName.UNIT_TESTING,
-                                label=error.full_path,
+                                label=error.path,
                                 related_to_operation=False,
                             )
                         )

schemathesis/engine/phases/unit/_executor.py

@@ -70,6 +70,19 @@ def run_test(
             error=error, phase=PhaseName.UNIT_TESTING, label=operation.label, related_to_operation=True
         )
 
+    def scenario_finished(status: Status) -> events.ScenarioFinished:
+        return events.ScenarioFinished(
+            id=scenario_started.id,
+            suite_id=suite_id,
+            phase=PhaseName.UNIT_TESTING,
+            label=operation.label,
+            recorder=recorder,
+            status=status,
+            elapsed_time=time.monotonic() - test_start_time,
+            skip_reason=skip_reason,
+            is_final=False,
+        )
+
     try:
         setup_hypothesis_database_key(test_function, operation)
         with catch_warnings(record=True) as warnings, ignore_hypothesis_output():
@@ -111,6 +124,7 @@ def run_test(
         status = Status.ERROR
         yield non_fatal_error(hypothesis.errors.Unsatisfiable("Failed to generate test cases for this API operation"))
     except KeyboardInterrupt:
+        yield scenario_finished(Status.INTERRUPTED)
         yield events.Interrupted(phase=PhaseName.UNIT_TESTING)
         return
     except AssertionError as exc:  # May come from `hypothesis-jsonschema` or `hypothesis`
@@ -131,7 +145,6 @@ def run_test(
                     exc,
                     path=operation.path,
                     method=operation.method,
-                    full_path=operation.schema.get_full_path(operation.path),
                 )
             )
     except HypothesisRefResolutionError:
@@ -194,20 +207,10 @@ def run_test(
     if invalid_headers:
         status = Status.ERROR
         yield non_fatal_error(InvalidHeadersExample.from_headers(invalid_headers))
-    test_elapsed_time = time.monotonic() - test_start_time
     for error in deduplicate_errors(errors):
         yield non_fatal_error(error)
-    yield events.ScenarioFinished(
-        id=scenario_started.id,
-        suite_id=suite_id,
-        phase=PhaseName.UNIT_TESTING,
-        label=operation.label,
-        recorder=recorder,
-        status=status,
-        elapsed_time=test_elapsed_time,
-        skip_reason=skip_reason,
-        is_final=False,
-    )
+
+    yield scenario_finished(status)
 
 
 def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> None:

schemathesis/errors.py

@@ -4,17 +4,19 @@ from schemathesis.core.errors import (
     IncorrectUsage,
     InternalError,
     InvalidHeadersExample,
-    InvalidLinkDefinition,
     InvalidRateLimit,
     InvalidRegexPattern,
     InvalidRegexType,
     InvalidSchema,
+    InvalidStateMachine,
+    InvalidTransition,
     LoaderError,
     NoLinksFound,
     OperationNotFound,
     SchemathesisError,
     SerializationError,
     SerializationNotPossible,
+    TransitionValidationError,
     UnboundPrefix,
 )
 
@@ -22,16 +24,18 @@ __all__ = [
     "IncorrectUsage",
     "InternalError",
     "InvalidHeadersExample",
-    "InvalidLinkDefinition",
     "InvalidRateLimit",
     "InvalidRegexPattern",
     "InvalidRegexType",
     "InvalidSchema",
+    "InvalidStateMachine",
+    "InvalidTransition",
     "LoaderError",
     "OperationNotFound",
     "NoLinksFound",
     "SchemathesisError",
     "SerializationError",
     "SerializationNotPossible",
+    "TransitionValidationError",
     "UnboundPrefix",
 ]

schemathesis/filters.py

@@ -268,6 +268,8 @@ class FilterSet:
                 # To match anything the regex should match the expected value, hence passing them together is useless
                 raise IncorrectUsage(ERROR_EXPECTED_AND_REGEX)
             if expected is not None:
+                if attribute == "method":
+                    expected = _normalize_method(expected)
                 matchers.append(Matcher.for_value(attribute, expected))
             if regex is not None:
                 matchers.append(Matcher.for_regex(attribute, regex))
@@ -283,6 +285,12 @@ class FilterSet:
             self._excludes.add(filter_)
 
 
+def _normalize_method(value: FilterValue) -> FilterValue:
+    if isinstance(value, list):
+        return [item.upper() for item in value]
+    return value.upper()
+
+
 def attach_filter_chain(
     target: Callable,
     attribute: str,

schemathesis/generation/coverage.py

@@ -437,7 +437,12 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
-                elif key == "additionalProperties" and not value and "pattern" not in schema:
+                elif (
+                    key == "additionalProperties"
+                    and not value
+                    and "pattern" not in schema
+                    and schema.get("type") in ["object", None]
+                ):
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield NegativeValue(
                         {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},

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/pytest/lazy.py

@@ -168,7 +168,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 +236,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)