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

schemathesis/cli/commands/run/hypothesis.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from enum import IntEnum, unique
+from enum import Enum, unique
 from typing import TYPE_CHECKING, Any
 
 import click
@@ -16,12 +16,11 @@ HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 
 
 @unique
-class Phase(IntEnum):
-    explicit = 0  #: controls whether explicit examples are run.
-    reuse = 1  #: controls whether previous examples will be reused.
-    generate = 2  #: controls whether new examples will be generated.
-    target = 3  #: controls whether examples will be mutated for targeting.
-    shrink = 4  #: controls whether examples will be shrunk.
+class Phase(str, Enum):
+    explicit = "explicit"  #: controls whether explicit examples are run.
+    reuse = "reuse"  #: controls whether previous examples will be reused.
+    generate = "generate"  #: controls whether new examples will be generated.
+    target = "target"  #: controls whether examples will be mutated for targeting.
     # The `explain` phase is not supported
 
     def as_hypothesis(self) -> hypothesis.Phase:
@@ -30,20 +29,23 @@ class Phase(IntEnum):
         return Phase[self.name]
 
     @staticmethod
-    def filter_from_all(variants: list[Phase]) -> list[hypothesis.Phase]:
+    def filter_from_all(variants: list[Phase], no_shrink: bool) -> list[hypothesis.Phase]:
         from hypothesis import Phase
 
-        return list(set(Phase) - {Phase.explain} - set(variants))
+        phases = set(Phase) - {Phase.explain} - set(variants)
+        if no_shrink:
+            return list(phases - {Phase.shrink})
+        return list(phases)
 
 
 @unique
-class HealthCheck(IntEnum):
+class HealthCheck(str, Enum):
     # We remove not relevant checks
-    data_too_large = 1
-    filter_too_much = 2
-    too_slow = 3
-    large_base_example = 7
-    all = 8
+    data_too_large = "data_too_large"
+    filter_too_much = "filter_too_much"
+    too_slow = "too_slow"
+    large_base_example = "large_base_example"
+    all = "all"
 
     def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
         from hypothesis import HealthCheck
@@ -64,14 +66,23 @@ def prepare_health_checks(
 
 
 def prepare_phases(
-    hypothesis_phases: list[Phase] | None, hypothesis_no_phases: list[Phase] | None
+    hypothesis_phases: list[Phase] | None,
+    hypothesis_no_phases: list[Phase] | None,
+    no_shrink: bool = False,
 ) -> list[hypothesis.Phase] | None:
+    from hypothesis import Phase as HypothesisPhase
+
     if hypothesis_phases is not None and hypothesis_no_phases is not None:
         raise click.UsageError(PHASES_INVALID_USAGE_MESSAGE)
     if hypothesis_phases:
-        return [phase.as_hypothesis() for phase in hypothesis_phases]
-    if hypothesis_no_phases:
-        return Phase.filter_from_all(hypothesis_no_phases)
+        phases = [phase.as_hypothesis() for phase in hypothesis_phases]
+        if not no_shrink:
+            phases.append(HypothesisPhase.shrink)
+        return phases
+    elif hypothesis_no_phases:
+        return Phase.filter_from_all(hypothesis_no_phases, no_shrink)
+    elif no_shrink:
+        return Phase.filter_from_all([], no_shrink)
     return None
 
 

schemathesis/cli/commands/run/reports.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+
+from click.utils import LazyFile
+
+DEFAULT_REPORT_DIRECTORY = Path("./schemathesis-report")
+
+
+class ReportFormat(str, Enum):
+    """Available report formats."""
+
+    JUNIT = "junit"
+    VCR = "vcr"
+    HAR = "har"
+
+    @property
+    def extension(self) -> str:
+        """File extension for this format."""
+        return {
+            self.JUNIT: "xml",
+            self.VCR: "yaml",
+            self.HAR: "json",
+        }[self]
+
+
+class ReportConfig:
+    """Configuration for test report generation."""
+
+    __slots__ = (
+        "formats",
+        "directory",
+        "junit_path",
+        "vcr_path",
+        "har_path",
+        "preserve_bytes",
+        "sanitize_output",
+    )
+
+    def __init__(
+        self,
+        formats: list[ReportFormat] | None = None,
+        directory: Path = DEFAULT_REPORT_DIRECTORY,
+        *,
+        junit_path: LazyFile | None = None,
+        vcr_path: LazyFile | None = None,
+        har_path: LazyFile | None = None,
+        preserve_bytes: bool = False,
+        sanitize_output: bool = True,
+    ) -> None:
+        self.formats = formats or []
+        # Auto-enable formats when paths are specified
+        if junit_path and ReportFormat.JUNIT not in self.formats:
+            self.formats.append(ReportFormat.JUNIT)
+        if vcr_path and ReportFormat.VCR not in self.formats:
+            self.formats.append(ReportFormat.VCR)
+        if har_path and ReportFormat.HAR not in self.formats:
+            self.formats.append(ReportFormat.HAR)
+        self.directory = directory
+        self.junit_path = junit_path
+        self.vcr_path = vcr_path
+        self.har_path = har_path
+        self.preserve_bytes = preserve_bytes
+        self.sanitize_output = sanitize_output
+
+    def get_path(self, format: ReportFormat) -> LazyFile:
+        """Get the final path for a specific format."""
+        custom_path = getattr(self, f"{format.value}_path")
+        if custom_path is not None:
+            return custom_path
+        return LazyFile(self.directory / f"{format.value}.{format.extension}", mode="w", encoding="utf-8")

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,6 +98,82 @@ class InvalidRegexType(InvalidSchema):
     """Raised when an invalid type is used where a regex pattern is expected."""
 
 
+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):
     """Raised on parsing of incorrect media type."""
 
@@ -148,6 +220,10 @@ class IncorrectUsage(SchemathesisError):
     """Indicates incorrect usage of Schemathesis' public API."""
 
 
+class NoLinksFound(IncorrectUsage):
+    """Raised when no valid links are available for stateful testing."""
+
+
 class InvalidRateLimit(IncorrectUsage):
     """Incorrect input for rate limiting."""
 

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/core.py

@@ -68,7 +68,7 @@ class Engine:
                 skip_reason=PhaseSkipReason.DISABLED,
             )
 
-        if requires_links and self.schema.statistic.links.selected == 0:
+        if requires_links and self.schema.statistic.links.total == 0:
             return Phase(
                 name=phase_name,
                 is_supported=True,

schemathesis/engine/errors.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 from schemathesis import errors
 from schemathesis.core.errors import (
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
+    InvalidTransition,
     SerializationNotPossible,
     format_exception,
     get_request_error_extras,
@@ -76,6 +77,9 @@ class EngineErrorInfo:
         """A general error description."""
         import requests
 
+        if isinstance(self._error, InvalidTransition):
+            return "Invalid Link Definition"
+
         if isinstance(self._error, requests.RequestException):
             return "Network Error"
 
@@ -96,6 +100,8 @@ 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",
@@ -164,8 +170,10 @@ 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,
             RuntimeErrorKind.SERIALIZATION_NOT_POSSIBLE,
             RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR,
             RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE,
@@ -184,11 +192,7 @@ class EngineErrorInfo:
         """Format error message with optional styling and traceback."""
         message = []
 
-        # Title
-        if self._kind == RuntimeErrorKind.SCHEMA_GENERIC:
-            title = "Schema Error"
-        else:
-            title = self.title
+        title = self.title
         if title:
             message.append(f"{title}\n")
 
@@ -244,8 +248,9 @@ 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"
         "For guidance, visit: https://docs.python.org/3/library/re.html",
         RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
@@ -299,6 +304,8 @@ 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"
 
@@ -350,6 +357,10 @@ 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):
         # Recursive references are not supported right now
         return RuntimeErrorKind.SCHEMA_UNSUPPORTED

schemathesis/engine/phases/stateful/__init__.py

@@ -20,6 +20,7 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
         state_machine = engine.schema.as_state_machine()
     except Exception as exc:
         yield events.NonFatalError(error=exc, phase=phase.name, label="Stateful tests", related_to_operation=False)
+        yield events.PhaseFinished(phase=phase, status=Status.ERROR, payload=None)
         return
 
     event_queue: queue.Queue = queue.Queue()

schemathesis/engine/phases/stateful/_executor.py

@@ -78,7 +78,6 @@ def execute_state_machine_loop(
             self._start_time = time.monotonic()
             self._scenario_id = scenario_started.id
             event_queue.put(scenario_started)
-            self.recorder = ScenarioRecorder(label="Stateful tests")
             self._check_ctx = engine.get_check_context(self.recorder)
 
         def get_call_kwargs(self, case: Case) -> dict[str, Any]:
@@ -100,12 +99,6 @@ def execute_state_machine_loop(
         def step(self, input: StepInput) -> StepOutput | None:
             # Checking the stop event once inside `step` is sufficient as it is called frequently
             # The idea is to stop the execution as soon as possible
-            if input.transition is not None:
-                self.recorder.record_case(
-                    parent_id=input.transition.parent_id, transition=input.transition, case=input.case
-                )
-            else:
-                self.recorder.record_case(parent_id=None, transition=None, case=input.case)
             if engine.has_to_stop:
                 raise KeyboardInterrupt
             try:
@@ -141,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)
@@ -176,10 +169,7 @@ def execute_state_machine_loop(
             ctx.reset_scenario()
             super().teardown()
 
-    if config.execution.seed is not None:
-        InstrumentedStateMachine = hypothesis.seed(config.execution.seed)(_InstrumentedStateMachine)
-    else:
-        InstrumentedStateMachine = _InstrumentedStateMachine
+    seed = config.execution.seed
 
     while True:
         # This loop is running until no new failures are found in a single iteration
@@ -197,6 +187,13 @@ def execute_state_machine_loop(
             )
             break
         suite_status = Status.SUCCESS
+        if seed is not None:
+            InstrumentedStateMachine = hypothesis.seed(seed)(_InstrumentedStateMachine)
+            # Predictably change the seed to avoid re-running the same sequences if tests fail
+            # yet have reproducible results
+            seed += 1
+        else:
+            InstrumentedStateMachine = _InstrumentedStateMachine
         try:
             with catch_warnings(), ignore_hypothesis_output():  # type: ignore
                 InstrumentedStateMachine.run(settings=config.execution.hypothesis_settings)