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

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

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import os
+import textwrap
 import time
 from dataclasses import dataclass, field
+from json.decoder import JSONDecodeError
 from types import GeneratorType
 from typing import TYPE_CHECKING, Any, Generator, Iterable
 
@@ -11,11 +13,12 @@ import click
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
 from schemathesis.cli.commands.run.events import LoadingFinished, LoadingStarted
 from schemathesis.cli.commands.run.handlers.base import EventHandler
-from schemathesis.cli.commands.run.handlers.cassettes import CassetteConfig
+from schemathesis.cli.commands.run.reports import ReportConfig, ReportFormat
 from schemathesis.cli.constants import ISSUE_TRACKER_URL
 from schemathesis.cli.core import get_terminal_width
 from schemathesis.core.errors import LoaderError, LoaderErrorKind, format_exception, split_traceback
 from schemathesis.core.failures import MessageBlock, Severity, format_failures
+from schemathesis.core.output import prepare_response_payload
 from schemathesis.core.result import Err, Ok
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 from schemathesis.engine import Status, events
@@ -32,6 +35,8 @@ if TYPE_CHECKING:
     from rich.progress import Progress, TaskID
     from rich.text import Text
 
+    from schemathesis.generation.stateful.state_machine import ExtractionFailure
+
 IO_ENCODING = os.getenv("PYTHONIOENCODING", "utf-8")
 DISCORD_LINK = "https://discord.gg/R9ASRAmHnA"
 
@@ -40,7 +45,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 +63,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)
@@ -98,7 +105,7 @@ def display_failures_for_single_test(ctx: ExecutionContext, label: str, checks:
 
 
 VERIFY_URL_SUGGESTION = "Verify that the URL points directly to the Open API schema or GraphQL endpoint"
-DISABLE_SSL_SUGGESTION = f"Bypass SSL verification with {bold('`--request-tls-verify=false`')}."
+DISABLE_SSL_SUGGESTION = f"Bypass SSL verification with {bold('`--tls-verify=false`')}."
 LOADER_ERROR_SUGGESTIONS = {
     # SSL-specific connection issue
     LoaderErrorKind.CONNECTION_SSL: DISABLE_SSL_SUGGESTION,
@@ -122,14 +129,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()
 
 
@@ -377,6 +384,7 @@ class UnitTestProgressManager:
 
     def __init__(
         self,
+        *,
         console: Console,
         title: str,
         total: int,
@@ -435,6 +443,7 @@ class UnitTestProgressManager:
             Status.FAILURE: 0,
             Status.SKIP: 0,
             Status.ERROR: 0,
+            Status.INTERRUPTED: 0,
         }
         self._update_stats_display()
 
@@ -451,8 +460,8 @@ class UnitTestProgressManager:
             parts.append(f"❌ {self.stats[Status.FAILURE]:{width}d} failed")
         if self.stats[Status.ERROR]:
             parts.append(f"🚫 {self.stats[Status.ERROR]:{width}d} errors")
-        if self.stats[Status.SKIP]:
-            parts.append(f"⏭️ {self.stats[Status.SKIP]:{width}d} skipped")
+        if self.stats[Status.SKIP] or self.stats[Status.INTERRUPTED]:
+            parts.append(f"⏭️ {self.stats[Status.SKIP] + self.stats[Status.INTERRUPTED]:{width}d} skipped")
         return "  ".join(parts)
 
     def _update_stats_display(self) -> None:
@@ -558,6 +567,7 @@ class StatefulProgressManager:
 
     console: Console
     title: str
+    links_selected: int
     links_total: int
     start_time: float
 
@@ -574,13 +584,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 +602,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 +645,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 +662,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 +682,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 +699,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 +784,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
 
@@ -780,8 +796,7 @@ class OutputHandler(EventHandler):
 
     statistic: ApiStatistic | None = None
     skip_reasons: list[str] = field(default_factory=list)
-    cassette_config: CassetteConfig | None = None
-    junit_xml_file: str | None = None
+    report_config: ReportConfig | None = None
     warnings: WarningData = field(default_factory=WarningData)
     errors: list[events.NonFatalError] = field(default_factory=list)
     phases: dict[PhaseName, tuple[Status, PhaseSkipReason | None]] = field(
@@ -856,7 +871,8 @@ class OutputHandler(EventHandler):
 
         table.add_row("Base URL:", event.base_url)
         table.add_row("Specification:", event.specification.name)
-        table.add_row("Operations:", str(event.statistic.operations.total))
+        statistic = event.statistic.operations
+        table.add_row("Operations:", f"{statistic.selected} selected / {statistic.total} total")
 
         message = Padding(table, BLOCK_PADDING)
         self.console.print(message)
@@ -883,7 +899,7 @@ class OutputHandler(EventHandler):
         self.unit_tests_manager = UnitTestProgressManager(
             console=self.console,
             title="Unit tests",
-            total=self.statistic.operations.total,
+            total=self.statistic.operations.selected,
         )
         self.unit_tests_manager.start()
 
@@ -892,6 +908,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 +1001,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 +1099,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 +1107,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 +1124,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 +1158,78 @@ 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_stateful_failures(self, ctx: ExecutionContext) -> None:
+        display_section_name("Stateful tests")
+
+        click.echo("\nFailed to extract data from response:")
+
+        grouped: dict[str, list[ExtractionFailure]] = {}
+        for failure in ctx.statistic.extraction_failures:
+            grouped.setdefault(failure.id, []).append(failure)
+
+        for idx, (transition_id, failures) in enumerate(grouped.items(), 1):
+            for failure in failures:
+                click.echo(f"\n    {idx}. Test Case ID: {failure.case_id}\n")
+                click.echo(f"    {transition_id}")
+
+                indent = "        "
+                if failure.error:
+                    if isinstance(failure.error, JSONDecodeError):
+                        click.echo(f"\n{indent}Failed to parse JSON from response")
+                    else:
+                        click.echo(f"\n{indent}{failure.error.__class__.__name__}: {failure.error}")
+                else:
+                    description = (
+                        f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
+                    )
+                    prefix = "$response.body"
+                    if failure.expression.startswith(prefix):
+                        description += f"\n{indent}Path `{failure.expression[len(prefix) :]}` not found in response"
+                    click.echo(description)
+
+                click.echo()
+
+                for case, response in reversed(failure.history):
+                    curl = case.as_curl_command(headers=dict(response.request.headers), verify=response.verify)
+                    click.echo(f"{indent}[{response.status_code}] {curl}")
+
+                response = failure.response
+
+                if response.content is None or not response.content:
+                    click.echo(f"\n{indent}<EMPTY>")
+                else:
+                    try:
+                        payload = prepare_response_payload(response.text, config=ctx.output_config)
+                        click.echo(textwrap.indent(f"\n{payload}", prefix=indent))
+                    except UnicodeDecodeError:
+                        click.echo(f"\n{indent}<BINARY>")
+
+        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 +1241,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 +1301,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 +1312,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 +1329,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 +1343,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"
@@ -1291,35 +1368,50 @@ class OutputHandler(EventHandler):
         display_section_name(message, fg=color)
 
     def display_reports(self) -> None:
-        reports = []
-        if self.cassette_config is not None:
-            format_name = self.cassette_config.format.name.upper()
-            reports.append((format_name, self.cassette_config.path.name))
-        if self.junit_xml_file is not None:
-            reports.append(("JUnit XML", self.junit_xml_file))
-
-        if reports:
-            click.secho("Reports:", bold=True)
+        if self.report_config is not None:
+            reports = [
+                (format.value.upper(), self.report_config.get_path(format).name)
+                for format in ReportFormat
+                if format in self.report_config.formats
+            ]
+
+            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:
             self.display_warnings()
         if GLOBAL_EXPERIMENTS.enabled:
             self.display_experiments()
+        if ctx.statistic.extraction_failures:
+            self.display_stateful_failures(ctx)
         display_section_name("SUMMARY")
         click.echo()
 
@@ -1336,8 +1428,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 +1438,7 @@ class OutputHandler(EventHandler):
 
         self.display_test_cases(ctx)
         self.display_reports()
+        self.display_seed()
         self.display_final_line(ctx, event)