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

schemathesis/cli/__init__.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
 
 from schemathesis.cli.commands import Group, run, schemathesis
+from schemathesis.cli.commands.run.context import ExecutionContext
+from schemathesis.cli.commands.run.events import LoadingFinished, LoadingStarted
 from schemathesis.cli.commands.run.executor import handler
 from schemathesis.cli.commands.run.handlers import EventHandler
 from schemathesis.cli.ext.groups import GROUPS
 
-__all__ = ["schemathesis", "run", "EventHandler", "add_group", "handler"]
+__all__ = [
+    "schemathesis",
+    "run",
+    "EventHandler",
+    "ExecutionContext",
+    "LoadingStarted",
+    "LoadingFinished",
+    "add_group",
+    "handler",
+]
 
 
 def add_group(name: str, *, index: int | None = None) -> Group:

schemathesis/cli/commands/run/events.py

@@ -16,10 +16,28 @@ class LoadingStarted(events.EngineEvent):
 
 
 class LoadingFinished(events.EngineEvent):
-    __slots__ = ("id", "timestamp", "location", "duration", "base_url", "specification", "statistic")
+    __slots__ = (
+        "id",
+        "timestamp",
+        "location",
+        "duration",
+        "base_url",
+        "base_path",
+        "specification",
+        "statistic",
+        "schema",
+    )
 
     def __init__(
-        self, location: str, start_time: float, base_url: str, specification: Specification, statistic: ApiStatistic
+        self,
+        *,
+        location: str,
+        start_time: float,
+        base_url: str,
+        base_path: str,
+        specification: Specification,
+        statistic: ApiStatistic,
+        schema: dict,
     ) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
@@ -28,3 +46,5 @@ class LoadingFinished(events.EngineEvent):
         self.base_url = base_url
         self.specification = specification
         self.statistic = statistic
+        self.schema = schema
+        self.base_path = base_path

schemathesis/cli/commands/run/executor.py

@@ -83,6 +83,8 @@ def into_event_stream(config: RunConfig) -> EventGenerator:
         base_url=schema.get_base_url(),
         specification=schema.specification,
         statistic=schema.statistic,
+        schema=schema.raw_schema,
+        base_path=schema.base_path,
     )
 
     try:
@@ -104,6 +106,7 @@ def _execute(event_stream: EventGenerator, config: RunConfig) -> None:
     handlers.append(
         OutputHandler(
             workers_num=config.engine.execution.workers_num,
+            seed=config.engine.execution.seed,
             rate_limit=config.rate_limit,
             wait_for_schema=config.wait_for_schema,
             cassette_config=config.cassette,

schemathesis/cli/commands/run/handlers/output.py

@@ -40,7 +40,7 @@ def display_section_name(title: str, separator: str = "=", **kwargs: Any) -> Non
     """Print section name with separators in terminal with the given title nicely centered."""
     message = f" {title} ".center(get_terminal_width(), separator)
     kwargs.setdefault("bold", True)
-    click.secho(message, **kwargs)
+    click.echo(_style(message, **kwargs))
 
 
 def bold(option: str) -> str:
@@ -58,12 +58,14 @@ def display_failures(ctx: ExecutionContext) -> None:
 
 
 if IO_ENCODING != "utf-8":
+    HEADER_SEPARATOR = "-"
 
     def _style(text: str, **kwargs: Any) -> str:
         text = text.encode(IO_ENCODING, errors="replace").decode("utf-8")
         return click.style(text, **kwargs)
 
 else:
+    HEADER_SEPARATOR = "━"
 
     def _style(text: str, **kwargs: Any) -> str:
         return click.style(text, **kwargs)
@@ -122,14 +124,14 @@ def _display_extras(extras: list[str]) -> None:
     if extras:
         click.echo()
     for extra in extras:
-        click.secho(f"    {extra}")
+        click.echo(_style(f"    {extra}"))
 
 
 def display_header(version: str) -> None:
     prefix = "v" if version != "dev" else ""
     header = f"Schemathesis {prefix}{version}"
-    click.secho(header, bold=True)
-    click.secho("━" * len(header), bold=True)
+    click.echo(_style(header, bold=True))
+    click.echo(_style(HEADER_SEPARATOR * len(header), bold=True))
     click.echo()
 
 
@@ -558,6 +560,7 @@ class StatefulProgressManager:
 
     console: Console
     title: str
+    links_selected: int
     links_total: int
     start_time: float
 
@@ -574,13 +577,14 @@ class StatefulProgressManager:
 
     # State
     scenarios: int
-    links_seen: set[str]
+    links_covered: set[str]
     stats: dict[Status, int]
     is_interrupted: bool
 
     __slots__ = (
         "console",
         "title",
+        "links_selected",
         "links_total",
         "start_time",
         "title_progress",
@@ -591,17 +595,18 @@ class StatefulProgressManager:
         "progress_task_id",
         "stats_task_id",
         "scenarios",
-        "links_seen",
+        "links_covered",
         "stats",
         "is_interrupted",
     )
 
-    def __init__(self, console: Console, title: str, links_total: int) -> None:
+    def __init__(self, *, console: Console, title: str, links_selected: int, links_total: int) -> None:
         from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
         from rich.style import Style
 
         self.console = console
         self.title = title
+        self.links_selected = links_selected
         self.links_total = links_total
         self.start_time = time.monotonic()
 
@@ -633,7 +638,7 @@ class StatefulProgressManager:
 
         # Initialize state
         self.scenarios = 0
-        self.links_seen = set()
+        self.links_covered = set()
         self.stats = {
             Status.SUCCESS: 0,
             Status.FAILURE: 0,
@@ -650,7 +655,9 @@ class StatefulProgressManager:
 
         # Initialize progress displays
         self.title_task_id = self.title_progress.add_task("Stateful tests")
-        self.progress_task_id = self.progress_bar.add_task("", scenarios=0, links=f"0/{self.links_total} links")
+        self.progress_task_id = self.progress_bar.add_task(
+            "", scenarios=0, links=f"0 covered / {self.links_selected} selected / {self.links_total} total links"
+        )
 
         # Create live display
         group = Group(
@@ -668,10 +675,10 @@ class StatefulProgressManager:
         if self.live:
             self.live.stop()
 
-    def update(self, links_seen: set[str], status: Status | None = None) -> None:
+    def update(self, links_covered: set[str], status: Status | None = None) -> None:
         """Update progress and stats."""
         self.scenarios += 1
-        self.links_seen.update(links_seen)
+        self.links_covered.update(links_covered)
 
         if status is not None:
             self.stats[status] += 1
@@ -685,7 +692,7 @@ class StatefulProgressManager:
         self.progress_bar.update(
             self.progress_task_id,
             scenarios=self.scenarios,
-            links=f"{len(self.links_seen)}/{self.links_total} links",
+            links=f"{len(self.links_covered)} covered / {self.links_selected} selected / {self.links_total} total links",
         )
 
     def _get_stats_message(self) -> str:
@@ -770,6 +777,8 @@ def format_duration(duration_ms: int) -> str:
 @dataclass
 class OutputHandler(EventHandler):
     workers_num: int
+    # Seed can't be absent in the deterministic mode
+    seed: int | None
     rate_limit: str | None
     wait_for_schema: float | None
 
@@ -892,6 +901,7 @@ class OutputHandler(EventHandler):
         self.stateful_tests_manager = StatefulProgressManager(
             console=self.console,
             title="Stateful tests",
+            links_selected=self.statistic.links.selected,
             links_total=self.statistic.links.total,
         )
         self.stateful_tests_manager.start()
@@ -984,7 +994,8 @@ class OutputHandler(EventHandler):
             table.add_column("Value", style="cyan")
             table.add_row("Scenarios:", f"{self.stateful_tests_manager.scenarios}")
             table.add_row(
-                "API Links:", f"{len(self.stateful_tests_manager.links_seen)}/{self.stateful_tests_manager.links_total}"
+                "API Links:",
+                f"{len(self.stateful_tests_manager.links_covered)} covered / {self.stateful_tests_manager.links_selected} selected / {self.stateful_tests_manager.links_total} total",
             )
 
             self.console.print()
@@ -1081,7 +1092,7 @@ class OutputHandler(EventHandler):
             if not (event.exception.kind == LoaderErrorKind.CONNECTION_OTHER and self.wait_for_schema is not None):
                 suggestion = LOADER_ERROR_SUGGESTIONS.get(event.exception.kind)
                 if suggestion is not None:
-                    click.secho(f"{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+                    click.echo(_style(f"{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
 
             raise click.Abort
         title = "Test Execution Error"
@@ -1089,16 +1100,16 @@ class OutputHandler(EventHandler):
         traceback = format_exception(event.exception, with_traceback=True)
         extras = split_traceback(traceback)
         suggestion = f"Please consider reporting the traceback above to our issue tracker:\n\n  {ISSUE_TRACKER_URL}."
-        click.secho(title, fg="red", bold=True)
+        click.echo(_style(title, fg="red", bold=True))
         click.echo()
-        click.secho(message)
+        click.echo(message)
         _display_extras(extras)
         if not (
             isinstance(event.exception, LoaderError)
             and event.exception.kind == LoaderErrorKind.CONNECTION_OTHER
             and self.wait_for_schema is not None
         ):
-            click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+            click.echo(_style(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}"))
 
         raise click.Abort
 
@@ -1106,29 +1117,33 @@ class OutputHandler(EventHandler):
         display_section_name("WARNINGS")
         total = sum(len(endpoints) for endpoints in self.warnings.missing_auth.values())
         suffix = "" if total == 1 else "s"
-        click.secho(
-            f"\nMissing or invalid API credentials: {total} API operation{suffix} returned authentication errors\n",
-            fg="yellow",
+        click.echo(
+            _style(
+                f"\nMissing or invalid API credentials: {total} API operation{suffix} returned authentication errors\n",
+                fg="yellow",
+            )
         )
 
         for status_code, operations in self.warnings.missing_auth.items():
             status_text = "Unauthorized" if status_code == 401 else "Forbidden"
             count = len(operations)
             suffix = "" if count == 1 else "s"
-            click.secho(
-                f"{status_code} {status_text} ({count} operation{suffix}):",
-                fg="yellow",
+            click.echo(
+                _style(
+                    f"{status_code} {status_text} ({count} operation{suffix}):",
+                    fg="yellow",
+                )
             )
             # Show first few API operations
             for endpoint in operations[:3]:
-                click.secho(f"  • {endpoint}", fg="yellow")
+                click.echo(_style(f"  - {endpoint}", fg="yellow"))
             if len(operations) > 3:
-                click.secho(f"  + {len(operations) - 3} more", fg="yellow")
+                click.echo(_style(f"  + {len(operations) - 3} more", fg="yellow"))
             click.echo()
-        click.secho("Tip: ", bold=True, fg="yellow", nl=False)
-        click.secho(f"Use {bold('--auth')} ", fg="yellow", nl=False)
-        click.secho(f"or {bold('-H')} ", fg="yellow", nl=False)
-        click.secho("to provide authentication credentials", fg="yellow")
+        click.echo(_style("Tip: ", bold=True, fg="yellow"), nl=False)
+        click.echo(_style(f"Use {bold('--auth')} ", fg="yellow"), nl=False)
+        click.echo(_style(f"or {bold('-H')} ", fg="yellow"), nl=False)
+        click.echo(_style("to provide authentication credentials", fg="yellow"))
         click.echo()
 
     def display_experiments(self) -> None:
@@ -1136,26 +1151,30 @@ class OutputHandler(EventHandler):
 
         click.echo()
         for experiment in sorted(GLOBAL_EXPERIMENTS.enabled, key=lambda e: e.name):
-            click.secho(f"🧪 {experiment.name}: ", bold=True, nl=False)
-            click.secho(experiment.description)
-            click.secho(f"   Feedback: {experiment.discussion_url}")
+            click.echo(_style(f"🧪 {experiment.name}: ", bold=True), nl=False)
+            click.echo(_style(experiment.description))
+            click.echo(_style(f"   Feedback: {experiment.discussion_url}"))
             click.echo()
 
-        click.secho(
-            "Your feedback is crucial for experimental features. "
-            "Please visit the provided URL(s) to share your thoughts.",
-            dim=True,
+        click.echo(
+            _style(
+                "Your feedback is crucial for experimental features. "
+                "Please visit the provided URL(s) to share your thoughts.",
+                dim=True,
+            )
         )
         click.echo()
 
     def display_api_operations(self, ctx: ExecutionContext) -> None:
         assert self.statistic is not None
-        click.secho("API Operations:", bold=True)
-        click.secho(
-            f"  Selected: {click.style(str(self.statistic.operations.selected), bold=True)}/"
-            f"{click.style(str(self.statistic.operations.total), bold=True)}"
+        click.echo(_style("API Operations:", bold=True))
+        click.echo(
+            _style(
+                f"  Selected: {click.style(str(self.statistic.operations.selected), bold=True)}/"
+                f"{click.style(str(self.statistic.operations.total), bold=True)}"
+            )
         )
-        click.secho(f"  Tested: {click.style(str(len(ctx.statistic.tested_operations)), bold=True)}")
+        click.echo(_style(f"  Tested: {click.style(str(len(ctx.statistic.tested_operations)), bold=True)}"))
         errors = len(
             {
                 err.label
@@ -1167,48 +1186,48 @@ class OutputHandler(EventHandler):
             }
         )
         if errors:
-            click.secho(f"  Errored: {click.style(str(errors), bold=True)}")
+            click.echo(_style(f"  Errored: {click.style(str(errors), bold=True)}"))
 
         # API operations that are skipped due to fail-fast are counted here as well
         total_skips = self.statistic.operations.selected - len(ctx.statistic.tested_operations) - errors
         if total_skips:
-            click.secho(f"  Skipped: {click.style(str(total_skips), bold=True)}")
+            click.echo(_style(f"  Skipped: {click.style(str(total_skips), bold=True)}"))
             for reason in sorted(set(self.skip_reasons)):
-                click.secho(f"    - {reason.rstrip('.')}")
+                click.echo(_style(f"    - {reason.rstrip('.')}"))
         click.echo()
 
     def display_phases(self) -> None:
-        click.secho("Test Phases:", bold=True)
+        click.echo(_style("Test Phases:", bold=True))
 
         for phase in PhaseName:
             status, skip_reason = self.phases[phase]
 
             if status == Status.SKIP:
-                click.secho(f"  ⏭️ {phase.value}", fg="yellow", nl=False)
+                click.echo(_style(f"  ⏭️ {phase.value}", fg="yellow"), nl=False)
                 if skip_reason:
-                    click.secho(f" ({skip_reason.value})", fg="yellow")
+                    click.echo(_style(f" ({skip_reason.value})", fg="yellow"))
                 else:
                     click.echo()
             elif status == Status.SUCCESS:
-                click.secho(f"  ✅ {phase.value}", fg="green")
+                click.echo(_style(f"  ✅ {phase.value}", fg="green"))
             elif status == Status.FAILURE:
-                click.secho(f"  ❌ {phase.value}", fg="red")
+                click.echo(_style(f"  ❌ {phase.value}", fg="red"))
             elif status == Status.ERROR:
-                click.secho(f"  🚫 {phase.value}", fg="red")
+                click.echo(_style(f"  🚫 {phase.value}", fg="red"))
             elif status == Status.INTERRUPTED:
-                click.secho(f"  ⚡ {phase.value}", fg="yellow")
+                click.echo(_style(f"  ⚡ {phase.value}", fg="yellow"))
         click.echo()
 
     def display_test_cases(self, ctx: ExecutionContext) -> None:
         if ctx.statistic.total_cases == 0:
-            click.secho("Test cases:", bold=True)
-            click.secho("  No test cases were generated\n")
+            click.echo(_style("Test cases:", bold=True))
+            click.echo("  No test cases were generated\n")
             return
 
         unique_failures = sum(
             len(group.failures) for grouped in ctx.statistic.failures.values() for group in grouped.values()
         )
-        click.secho("Test cases:", bold=True)
+        click.echo(_style("Test cases:", bold=True))
 
         parts = [f"  {click.style(str(ctx.statistic.total_cases), bold=True)} generated"]
 
@@ -1227,7 +1246,7 @@ class OutputHandler(EventHandler):
             if ctx.statistic.cases_without_checks > 0:
                 parts.append(f"{click.style(str(ctx.statistic.cases_without_checks), bold=True)} skipped")
 
-        click.secho(", ".join(parts) + "\n")
+        click.echo(_style(", ".join(parts) + "\n"))
 
     def display_failures_summary(self, ctx: ExecutionContext) -> None:
         # Collect all unique failures and their counts by title
@@ -1238,14 +1257,14 @@ class OutputHandler(EventHandler):
                     data = failure_counts.get(failure.title, (failure.severity, 0))
                     failure_counts[failure.title] = (failure.severity, data[1] + 1)
 
-        click.secho("Failures:", bold=True)
+        click.echo(_style("Failures:", bold=True))
 
         # Sort by severity first, then by title
         sorted_failures = sorted(failure_counts.items(), key=lambda x: (x[1][0], x[0]))
 
         for title, (_, count) in sorted_failures:
-            click.secho(f"  ❌ {title}: ", nl=False)
-            click.secho(str(count), bold=True)
+            click.echo(_style(f"  ❌ {title}: "), nl=False)
+            click.echo(_style(str(count), bold=True))
         click.echo()
 
     def display_errors_summary(self) -> None:
@@ -1255,11 +1274,11 @@ class OutputHandler(EventHandler):
             title = error.info.title
             error_counts[title] = error_counts.get(title, 0) + 1
 
-        click.secho("Errors:", bold=True)
+        click.echo(_style("Errors:", bold=True))
 
         for title in sorted(error_counts):
-            click.secho(f"  🚫 {title}: ", nl=False)
-            click.secho(str(error_counts[title]), bold=True)
+            click.echo(_style(f"  🚫 {title}: "), nl=False)
+            click.echo(_style(str(error_counts[title]), bold=True))
         click.echo()
 
     def display_final_line(self, ctx: ExecutionContext, event: events.EngineFinished) -> None:
@@ -1269,14 +1288,17 @@ class OutputHandler(EventHandler):
             len(group.failures) for grouped in ctx.statistic.failures.values() for group in grouped.values()
         )
         if unique_failures:
-            parts.append(f"{unique_failures} failures")
+            suffix = "s" if unique_failures > 1 else ""
+            parts.append(f"{unique_failures} failure{suffix}")
 
         if self.errors:
-            parts.append(f"{len(self.errors)} errors")
+            suffix = "s" if len(self.errors) > 1 else ""
+            parts.append(f"{len(self.errors)} error{suffix}")
 
         total_warnings = sum(len(endpoints) for endpoints in self.warnings.missing_auth.values())
         if total_warnings:
-            parts.append(f"{total_warnings} warnings")
+            suffix = "s" if total_warnings > 1 else ""
+            parts.append(f"{total_warnings} warning{suffix}")
 
         if parts:
             message = f"{', '.join(parts)} in {event.running_time:.2f}s"
@@ -1299,21 +1321,35 @@ class OutputHandler(EventHandler):
             reports.append(("JUnit XML", self.junit_xml_file))
 
         if reports:
-            click.secho("Reports:", bold=True)
+            click.echo(_style("Reports:", bold=True))
             for report_type, path in reports:
-                click.secho(f"  • {report_type}: {path}")
+                click.echo(_style(f"  - {report_type}: {path}"))
             click.echo()
 
+    def display_seed(self) -> None:
+        click.echo(_style("Seed: ", bold=True), nl=False)
+        if self.seed is None:
+            click.echo("not used in the deterministic mode")
+        else:
+            click.echo(str(self.seed))
+        click.echo()
+
     def _on_engine_finished(self, ctx: ExecutionContext, event: events.EngineFinished) -> None:
+        assert self.loading_manager is None
+        assert self.probing_manager is None
+        assert self.unit_tests_manager is None
+        assert self.stateful_tests_manager is None
         if self.errors:
             display_section_name("ERRORS")
             errors = sorted(self.errors, key=lambda r: (r.phase.value, r.label))
             for error in errors:
                 display_section_name(error.label, "_", fg="red")
                 click.echo(error.info.format(bold=lambda x: click.style(x, bold=True)))
-            click.secho(
-                f"\nNeed more help?\n    Join our Discord server: {DISCORD_LINK}",
-                fg="red",
+            click.echo(
+                _style(
+                    f"\nNeed more help?\n    Join our Discord server: {DISCORD_LINK}",
+                    fg="red",
+                )
             )
         display_failures(ctx)
         if self.warnings.missing_auth:
@@ -1336,8 +1372,8 @@ class OutputHandler(EventHandler):
 
         if self.warnings.missing_auth:
             affected = sum(len(operations) for operations in self.warnings.missing_auth.values())
-            click.secho("Warnings:", bold=True)
-            click.secho(f"  ⚠️ Missing authentication: {bold(str(affected))}", fg="yellow")
+            click.echo(_style("Warnings:", bold=True))
+            click.echo(_style(f"  ⚠️ Missing authentication: {bold(str(affected))}", fg="yellow"))
             click.echo()
 
         if ctx.summary_lines:
@@ -1346,6 +1382,7 @@ class OutputHandler(EventHandler):
 
         self.display_test_cases(ctx)
         self.display_reports()
+        self.display_seed()
         self.display_final_line(ctx, event)
 
 

schemathesis/core/errors.py

@@ -102,6 +102,10 @@ 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 MalformedMediaType(ValueError):
     """Raised on parsing of incorrect media type."""
 
@@ -148,6 +152,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/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,
+    InvalidLinkDefinition,
     SerializationNotPossible,
     format_exception,
     get_request_error_extras,
@@ -76,6 +77,9 @@ class EngineErrorInfo:
         """A general error description."""
         import requests
 
+        if isinstance(self._error, InvalidLinkDefinition):
+            return "Invalid Link Definition"
+
         if isinstance(self._error, requests.RequestException):
             return "Network Error"
 
@@ -96,6 +100,7 @@ class EngineErrorInfo:
 
         return {
             RuntimeErrorKind.SCHEMA_UNSUPPORTED: "Unsupported Schema",
+            RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND: "Missing Open API links",
             RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Unknown GraphQL Scalar",
             RuntimeErrorKind.SERIALIZATION_UNBOUNDED_PREFIX: "XML serialization error",
             RuntimeErrorKind.SERIALIZATION_NOT_POSSIBLE: "Serialization not possible",
@@ -166,6 +171,7 @@ class EngineErrorInfo:
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
             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 +190,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")
 
@@ -246,6 +248,7 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     return {
         RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--request-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 +302,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_NO_LINKS_FOUND = "schema_no_links_found"
     SCHEMA_UNSUPPORTED = "schema_unsupported"
     SCHEMA_GENERIC = "schema_generic"
 
@@ -350,6 +354,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.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()