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

schemathesis/cli/commands/run/hypothesis.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
-from enum import IntEnum, unique
+from enum import Enum, unique
 from typing import TYPE_CHECKING, Any
 
-import click
-
 if TYPE_CHECKING:
     import hypothesis
 
-PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 
 # Importing Hypothesis is expensive, hence we re-create the enums we need in CLI commands definitions
@@ -16,34 +13,13 @@ 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.
-    # The `explain` phase is not supported
-
-    def as_hypothesis(self) -> hypothesis.Phase:
-        from hypothesis import Phase
-
-        return Phase[self.name]
-
-    @staticmethod
-    def filter_from_all(variants: list[Phase]) -> list[hypothesis.Phase]:
-        from hypothesis import Phase
-
-        return list(set(Phase) - {Phase.explain} - set(variants))
-
-
-@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
@@ -63,16 +39,13 @@ def prepare_health_checks(
     return [entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()]
 
 
-def prepare_phases(
-    hypothesis_phases: list[Phase] | None, hypothesis_no_phases: list[Phase] | None
-) -> list[hypothesis.Phase] | None:
-    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)
-    return None
+def prepare_phases(no_shrink: bool = False) -> list[hypothesis.Phase] | None:
+    from hypothesis import Phase
+
+    phases = set(Phase) - {Phase.explain}
+    if no_shrink:
+        return list(phases - {Phase.shrink})
+    return list(phases)
 
 
 def prepare_settings(

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

@@ -16,6 +16,8 @@ class SpecificationFeature(str, enum.Enum):
     """Features that Schemathesis can provide for different specifications."""
 
     STATEFUL_TESTING = "stateful_testing"
+    COVERAGE = "coverage_tests"
+    EXAMPLES = "example_tests"
 
 
 @dataclass
@@ -39,7 +41,11 @@ class Specification:
     def supports_feature(self, feature: SpecificationFeature) -> bool:
         """Check if Schemathesis supports a given feature for this specification."""
         if self.kind == SpecificationKind.OPENAPI:
-            return feature in {SpecificationFeature.STATEFUL_TESTING}
+            return feature in {
+                SpecificationFeature.STATEFUL_TESTING,
+                SpecificationFeature.COVERAGE,
+                SpecificationFeature.EXAMPLES,
+            }
         return False
 
 

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

@@ -25,14 +25,14 @@ def _default_hypothesis_settings() -> hypothesis.settings:
 class ExecutionConfig:
     """Configuration for test execution."""
 
-    phases: list[PhaseName] = field(default_factory=lambda: [PhaseName.UNIT_TESTING, PhaseName.STATEFUL_TESTING])
+    phases: list[PhaseName] = field(default_factory=PhaseName.defaults)
     checks: list[CheckFunction] = field(default_factory=lambda: [not_a_server_error])
     targets: list[TargetFunction] = field(default_factory=list)
     hypothesis_settings: hypothesis.settings = field(default_factory=_default_hypothesis_settings)
     generation: GenerationConfig = field(default_factory=GenerationConfig)
     max_failures: int | None = None
     unique_inputs: bool = False
-    no_failfast: bool = False
+    continue_on_failure: bool = False
     seed: int | None = None
     workers_num: int = 1
 

schemathesis/engine/core.py

@@ -34,7 +34,17 @@ class Engine:
         """Create execution plan based on configuration."""
         phases = [
             self.get_phase_config(PhaseName.PROBING, is_supported=True, requires_links=False),
-            self.get_phase_config(PhaseName.UNIT_TESTING, is_supported=True, requires_links=False),
+            self.get_phase_config(
+                PhaseName.EXAMPLES,
+                is_supported=self.schema.specification.supports_feature(SpecificationFeature.EXAMPLES),
+                requires_links=False,
+            ),
+            self.get_phase_config(
+                PhaseName.COVERAGE,
+                is_supported=self.schema.specification.supports_feature(SpecificationFeature.COVERAGE),
+                requires_links=False,
+            ),
+            self.get_phase_config(PhaseName.FUZZING, is_supported=True, requires_links=False),
             self.get_phase_config(
                 PhaseName.STATEFUL_TESTING,
                 is_supported=self.schema.specification.supports_feature(SpecificationFeature.STATEFUL_TESTING),

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

@@ -209,6 +209,13 @@ class NonFatalError(EngineEvent):
         self.label = label
         self.related_to_operation = related_to_operation
 
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, NonFatalError)
+        return self.label == other.label and type(self.value) is type(other.value)
+
+    def __hash__(self) -> int:
+        return hash((self.label, type(self.value)))
+
 
 @dataclass
 class FatalError(EngineEvent):

schemathesis/engine/phases/__init__.py

@@ -14,14 +14,22 @@ class PhaseName(enum.Enum):
     """Available execution phases."""
 
     PROBING = "API probing"
-    UNIT_TESTING = "Unit testing"
-    STATEFUL_TESTING = "Stateful testing"
+    EXAMPLES = "Examples"
+    COVERAGE = "Coverage"
+    FUZZING = "Fuzzing"
+    STATEFUL_TESTING = "Stateful"
+
+    @classmethod
+    def defaults(cls) -> list[PhaseName]:
+        return [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING, PhaseName.STATEFUL_TESTING]
 
     @classmethod
     def from_str(cls, value: str) -> PhaseName:
         return {
             "probing": cls.PROBING,
-            "unit": cls.UNIT_TESTING,
+            "examples": cls.EXAMPLES,
+            "coverage": cls.COVERAGE,
+            "fuzzing": cls.FUZZING,
             "stateful": cls.STATEFUL_TESTING,
         }[value.lower()]
 
@@ -60,7 +68,11 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
 
         if phase.name == PhaseName.PROBING:
             yield from probes.execute(ctx, phase)
-        elif phase.name == PhaseName.UNIT_TESTING:
+        elif phase.name == PhaseName.EXAMPLES:
+            yield from unit.execute(ctx, phase)
+        elif phase.name == PhaseName.COVERAGE:
+            yield from unit.execute(ctx, phase)
+        elif phase.name == PhaseName.FUZZING:
             yield from unit.execute(ctx, phase)
         elif phase.name == PhaseName.STATEFUL_TESTING:
             yield from stateful.execute(ctx, phase)