schemathesis 4.0.0a3__py3-none-any.whl → 4.0.0a5__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,19 +13,22 @@ 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
+from schemathesis.engine.config import EngineConfig
 from schemathesis.engine.errors import EngineErrorInfo
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.phases.probes import ProbeOutcome
-from schemathesis.engine.recorder import Interaction
+from schemathesis.engine.recorder import Interaction, ScenarioRecorder
 from schemathesis.experimental import GLOBAL_EXPERIMENTS
+from schemathesis.generation.modes import GenerationMode
 from schemathesis.schemas import ApiStatistic
 
 if TYPE_CHECKING:
@@ -32,6 +37,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"
 
@@ -100,7 +107,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,
@@ -318,7 +325,8 @@ class ProbingProgressManager:
 
 @dataclass
 class WarningData:
-    missing_auth: dict[int, list[str]] = field(default_factory=dict)
+    missing_auth: dict[int, set[str]] = field(default_factory=dict)
+    only_4xx_responses: set[str] = field(default_factory=set)  # operations that only returned 4xx
 
 
 @dataclass
@@ -379,6 +387,7 @@ class UnitTestProgressManager:
 
     def __init__(
         self,
+        *,
         console: Console,
         title: str,
         total: int,
@@ -437,6 +446,7 @@ class UnitTestProgressManager:
             Status.FAILURE: 0,
             Status.SKIP: 0,
             Status.ERROR: 0,
+            Status.INTERRUPTED: 0,
         }
         self._update_stats_display()
 
@@ -452,9 +462,10 @@ class UnitTestProgressManager:
         if self.stats[Status.FAILURE]:
             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")
+            suffix = "s" if self.stats[Status.ERROR] > 1 else ""
+            parts.append(f"🚫 {self.stats[Status.ERROR]:{width}d} error{suffix}")
+        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:
@@ -506,7 +517,11 @@ class UnitTestProgressManager:
         if operation := self.current_operations.pop(label, None):
             if not self.current_operations:
                 assert self.title_task_id is not None
-                self.title_progress.update(self.title_task_id)
+                if self.current == self.total - 1:
+                    description = f"  {self.title}"
+                else:
+                    description = self.title
+                self.title_progress.update(self.title_task_id, description=description)
             self.operations_progress.update(operation.task_id, visible=False)
 
     def update_stats(self, status: Status) -> None:
@@ -535,7 +550,7 @@ class UnitTestProgressManager:
         elif self.stats[Status.SUCCESS] > 0:
             icon = "✅"
         elif self.stats[Status.SKIP] > 0:
-            icon = "⏭️"
+            icon = "⏭ "
         else:
             icon = default_icon
         return icon
@@ -654,7 +669,7 @@ class StatefulProgressManager:
         from rich.text import Text
 
         # Initialize progress displays
-        self.title_task_id = self.title_progress.add_task("Stateful tests")
+        self.title_task_id = self.title_progress.add_task("Stateful")
         self.progress_task_id = self.progress_bar.add_task(
             "", scenarios=0, links=f"0 covered / {self.links_selected} selected / {self.links_total} total links"
         )
@@ -703,9 +718,10 @@ class StatefulProgressManager:
         if self.stats[Status.FAILURE]:
             parts.append(f"❌ {self.stats[Status.FAILURE]} failed")
         if self.stats[Status.ERROR]:
-            parts.append(f"🚫 {self.stats[Status.ERROR]} errors")
+            suffix = "s" if self.stats[Status.ERROR] > 1 else ""
+            parts.append(f"🚫 {self.stats[Status.ERROR]} error{suffix}")
         if self.stats[Status.SKIP]:
-            parts.append(f"⏭️ {self.stats[Status.SKIP]} skipped")
+            parts.append(f"⏭  {self.stats[Status.SKIP]} skipped")
         return "  ".join(parts)
 
     def _update_stats_display(self) -> None:
@@ -722,7 +738,7 @@ class StatefulProgressManager:
         elif self.stats[Status.SUCCESS] > 0:
             icon = "✅"
         elif self.stats[Status.SKIP] > 0:
-            icon = "⏭️"
+            icon = "⏭ "
         else:
             icon = default_icon
         return icon
@@ -748,39 +764,18 @@ class StatefulProgressManager:
 
 
 def format_duration(duration_ms: int) -> str:
-    """Format duration in milliseconds to human readable string."""
-    parts = []
-
-    # Convert to components
-    ms = duration_ms % 1000
-    seconds = (duration_ms // 1000) % 60
-    minutes = (duration_ms // (1000 * 60)) % 60
-    hours = duration_ms // (1000 * 60 * 60)
-
-    # Add non-empty components
-    if hours > 0:
-        parts.append(f"{hours} h")
-    if minutes > 0:
-        parts.append(f"{minutes} m")
-    if seconds > 0:
-        parts.append(f"{seconds} s")
-    if ms > 0:
-        parts.append(f"{ms} ms")
-
-    # Handle zero duration
-    if not parts:
-        return "0 ms"
-
-    return " ".join(parts)
+    """Format duration in milliseconds to seconds with 2 decimal places."""
+    return f"{duration_ms / 1000:.2f}s"
 
 
 @dataclass
 class OutputHandler(EventHandler):
     workers_num: int
-    # Seed can't be absent in the deterministic mode
+    # Seed can be absent in the deterministic mode
     seed: int | None
     rate_limit: str | None
     wait_for_schema: float | None
+    engine_config: EngineConfig
 
     loading_manager: LoadingProgressManager | None = None
     probing_manager: ProbingProgressManager | None = None
@@ -789,10 +784,9 @@ 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)
+    errors: set[events.NonFatalError] = field(default_factory=set)
     phases: dict[PhaseName, tuple[Status, PhaseSkipReason | None]] = field(
         default_factory=lambda: {phase: (Status.SKIP, None) for phase in PhaseName}
     )
@@ -814,7 +808,7 @@ class OutputHandler(EventHandler):
         elif isinstance(event, events.FatalError):
             self._on_fatal_error(ctx, event)
         elif isinstance(event, events.NonFatalError):
-            self.errors.append(event)
+            self.errors.add(event)
         elif isinstance(event, LoadingStarted):
             self._on_loading_started(event)
         elif isinstance(event, LoadingFinished):
@@ -865,7 +859,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)
@@ -878,8 +873,8 @@ class OutputHandler(EventHandler):
         phase = event.phase
         if phase.name == PhaseName.PROBING and phase.is_enabled:
             self._start_probing()
-        elif phase.name == PhaseName.UNIT_TESTING and phase.is_enabled:
-            self._start_unit_tests()
+        elif phase.name in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING] and phase.is_enabled:
+            self._start_unit_tests(phase.name)
         elif phase.name == PhaseName.STATEFUL_TESTING and phase.is_enabled and phase.skip_reason is None:
             self._start_stateful_tests()
 
@@ -887,12 +882,13 @@ class OutputHandler(EventHandler):
         self.probing_manager = ProbingProgressManager(console=self.console)
         self.probing_manager.start()
 
-    def _start_unit_tests(self) -> None:
+    def _start_unit_tests(self, phase: PhaseName) -> None:
         assert self.statistic is not None
+        assert self.unit_tests_manager is None
         self.unit_tests_manager = UnitTestProgressManager(
             console=self.console,
-            title="Unit tests",
-            total=self.statistic.operations.total,
+            title=phase.value,
+            total=self.statistic.operations.selected,
         )
         self.unit_tests_manager.start()
 
@@ -900,7 +896,7 @@ class OutputHandler(EventHandler):
         assert self.statistic is not None
         self.stateful_tests_manager = StatefulProgressManager(
             console=self.console,
-            title="Stateful tests",
+            title="Stateful",
             links_selected=self.statistic.links.selected,
             links_total=self.statistic.links.total,
         )
@@ -956,7 +952,7 @@ class OutputHandler(EventHandler):
             elif event.status == Status.SKIP:
                 message = Padding(
                     Text.assemble(
-                        ("⏭️  ", ""),
+                        ("⏭   ", ""),
                         ("API probing skipped", Style(color="yellow")),
                     ),
                     BLOCK_PADDING,
@@ -974,8 +970,7 @@ class OutputHandler(EventHandler):
                 )
             self.console.print(message)
             self.console.print()
-        elif phase.name == PhaseName.STATEFUL_TESTING and phase.is_enabled:
-            assert self.stateful_tests_manager is not None
+        elif phase.name == PhaseName.STATEFUL_TESTING and phase.is_enabled and self.stateful_tests_manager is not None:
             self.stateful_tests_manager.stop()
             if event.status == Status.ERROR:
                 title, summary = self.stateful_tests_manager.get_completion_message("🚫")
@@ -1004,27 +999,29 @@ class OutputHandler(EventHandler):
             self.console.print(Padding(Text(summary, style="bright_white"), (0, 0, 0, 5)))
             self.console.print()
             self.stateful_tests_manager = None
-        elif phase.name == PhaseName.UNIT_TESTING and phase.is_enabled:
-            assert self.unit_tests_manager is not None
+        elif (
+            phase.name in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING]
+            and phase.is_enabled
+            and self.unit_tests_manager is not None
+        ):
             self.unit_tests_manager.stop()
             if event.status == Status.ERROR:
                 message = self.unit_tests_manager.get_completion_message("🚫")
             else:
                 message = self.unit_tests_manager.get_completion_message()
             self.console.print(Padding(Text(message, style="white"), BLOCK_PADDING))
-            if event.status != Status.INTERRUPTED:
-                self.console.print()
+            self.console.print()
             self.unit_tests_manager = None
 
     def _on_scenario_started(self, event: events.ScenarioStarted) -> None:
-        if event.phase == PhaseName.UNIT_TESTING:
+        if event.phase in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING]:
             # We should display execution result + percentage in the end. For example:
             assert event.label is not None
             assert self.unit_tests_manager is not None
             self.unit_tests_manager.start_operation(event.label)
 
     def _on_scenario_finished(self, event: events.ScenarioFinished) -> None:
-        if event.phase == PhaseName.UNIT_TESTING:
+        if event.phase in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING]:
             assert self.unit_tests_manager is not None
             if event.label:
                 self.unit_tests_manager.finish_operation(event.label)
@@ -1043,9 +1040,39 @@ class OutputHandler(EventHandler):
             self.stateful_tests_manager.update(links_seen, event.status)
 
     def _check_warnings(self, event: events.ScenarioFinished) -> None:
+        statistic = aggregate_status_codes(event.recorder.interactions.values())
+
+        if statistic.total == 0:
+            return
+
         for status_code in (401, 403):
-            if has_too_many_responses_with_status(event.recorder.interactions.values(), status_code):
-                self.warnings.missing_auth.setdefault(status_code, []).append(event.recorder.label)
+            if statistic.ratio_for(status_code) >= TOO_MANY_RESPONSES_THRESHOLD:
+                self.warnings.missing_auth.setdefault(status_code, set()).add(event.recorder.label)
+
+        # Warn if all positive test cases got 4xx in return and no failure was found
+        def all_positive_are_rejected(recorder: ScenarioRecorder) -> bool:
+            seen_positive = False
+            for case in recorder.cases.values():
+                if not (case.value.meta is not None and case.value.meta.generation.mode == GenerationMode.POSITIVE):
+                    continue
+                seen_positive = True
+                interaction = recorder.interactions.get(case.value.id)
+                if not (interaction is not None and interaction.response is not None):
+                    continue
+                # At least one positive response for positive test case
+                if 200 <= interaction.response.status_code < 300:
+                    return False
+            # If there are positive test cases, and we ended up here, then there are no 2xx responses for them
+            # Otherwise, there are no positive test cases at all and this check should pass
+            return seen_positive
+
+        if (
+            event.status == Status.SUCCESS
+            and GenerationMode.POSITIVE in self.engine_config.execution.generation.modes
+            and all_positive_are_rejected(event.recorder)
+            and statistic.should_warn_about_only_4xx()
+        ):
+            self.warnings.only_4xx_responses.add(event.recorder.label)
 
     def _on_interrupted(self, event: events.Interrupted) -> None:
         from rich.padding import Padding
@@ -1115,36 +1142,58 @@ class OutputHandler(EventHandler):
 
     def display_warnings(self) -> None:
         display_section_name("WARNINGS")
-        total = sum(len(endpoints) for endpoints in self.warnings.missing_auth.values())
-        suffix = "" if total == 1 else "s"
-        click.echo(
-            _style(
-                f"\nMissing or invalid API credentials: {total} API operation{suffix} returned authentication errors\n",
-                fg="yellow",
+        click.echo()
+        if self.warnings.missing_auth:
+            total = sum(len(endpoints) for endpoints in self.warnings.missing_auth.values())
+            suffix = "" if total == 1 else "s"
+            click.echo(
+                _style(
+                    f"Missing 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)
+            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.echo(
+                    _style(
+                        f"{status_code} {status_text} ({count} operation{suffix}):",
+                        fg="yellow",
+                    )
+                )
+                # Show first few API operations
+                for endpoint in sorted(operations)[:3]:
+                    click.echo(_style(f"  - {endpoint}", fg="yellow"))
+                if len(operations) > 3:
+                    click.echo(_style(f"  + {len(operations) - 3} more", fg="yellow"))
+                click.echo()
+            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()
+
+        if self.warnings.only_4xx_responses:
+            count = len(self.warnings.only_4xx_responses)
             suffix = "" if count == 1 else "s"
             click.echo(
                 _style(
-                    f"{status_code} {status_text} ({count} operation{suffix}):",
+                    f"Schemathesis configuration: {count} operation{suffix} returned only 4xx responses during unit tests\n",
                     fg="yellow",
                 )
             )
-            # Show first few API operations
-            for endpoint in operations[:3]:
+
+            for endpoint in sorted(self.warnings.only_4xx_responses)[:3]:
                 click.echo(_style(f"  - {endpoint}", fg="yellow"))
-            if len(operations) > 3:
-                click.echo(_style(f"  + {len(operations) - 3} more", fg="yellow"))
+            if len(self.warnings.only_4xx_responses) > 3:
+                click.echo(_style(f"  + {len(self.warnings.only_4xx_responses) - 3} more", fg="yellow"))
+            click.echo()
+
+            click.echo(_style("Tip: ", bold=True, fg="yellow"), nl=False)
+            click.echo(_style("Check base URL or adjust data generation settings", fg="yellow"))
             click.echo()
-        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:
         display_section_name("EXPERIMENTS")
@@ -1165,6 +1214,54 @@ class OutputHandler(EventHandler):
         )
         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.echo(_style("API Operations:", bold=True))
@@ -1180,7 +1277,7 @@ class OutputHandler(EventHandler):
                 err.label
                 for err in self.errors
                 # Some API operations may have some tests before they have an error
-                if err.phase == PhaseName.UNIT_TESTING
+                if err.phase in [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING]
                 and err.label not in ctx.statistic.tested_operations
                 and err.related_to_operation
             }
@@ -1203,7 +1300,7 @@ class OutputHandler(EventHandler):
             status, skip_reason = self.phases[phase]
 
             if status == Status.SKIP:
-                click.echo(_style(f"  ⏭️ {phase.value}", fg="yellow"), nl=False)
+                click.echo(_style(f"  ⏭  {phase.value}", fg="yellow"), nl=False)
                 if skip_reason:
                     click.echo(_style(f" ({skip_reason.value})", fg="yellow"))
                 else:
@@ -1313,14 +1410,13 @@ 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:
+        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.echo(_style(f"  - {report_type}: {path}"))
@@ -1341,7 +1437,7 @@ class OutputHandler(EventHandler):
         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))
+            errors = sorted(self.errors, key=lambda r: (r.phase.value, r.label, r.info.title))
             for error in errors:
                 display_section_name(error.label, "_", fg="red")
                 click.echo(error.info.format(bold=lambda x: click.style(x, bold=True)))
@@ -1352,10 +1448,12 @@ class OutputHandler(EventHandler):
                 )
             )
         display_failures(ctx)
-        if self.warnings.missing_auth:
+        if self.warnings.missing_auth or self.warnings.only_4xx_responses:
             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()
 
@@ -1370,10 +1468,21 @@ class OutputHandler(EventHandler):
         if self.errors:
             self.display_errors_summary()
 
-        if self.warnings.missing_auth:
-            affected = sum(len(operations) for operations in self.warnings.missing_auth.values())
+        if self.warnings.missing_auth or self.warnings.only_4xx_responses:
             click.echo(_style("Warnings:", bold=True))
-            click.echo(_style(f"  ⚠️ Missing authentication: {bold(str(affected))}", fg="yellow"))
+
+            if self.warnings.missing_auth:
+                affected = sum(len(operations) for operations in self.warnings.missing_auth.values())
+                click.echo(_style(f"  ⚠️ Missing authentication: {bold(str(affected))}", fg="yellow"))
+
+            if self.warnings.only_4xx_responses:
+                count = len(self.warnings.only_4xx_responses)
+                suffix = "" if count == 1 else "s"
+                click.echo(
+                    _style(f"  ⚠️ Schemathesis configuration: {bold(str(count))}", fg="yellow"),
+                    nl=False,
+                )
+                click.echo(_style(f" operation{suffix} returned only 4xx responses during unit tests", fg="yellow"))
             click.echo()
 
         if ctx.summary_lines:
@@ -1392,14 +1501,41 @@ TOO_MANY_RESPONSES_WARNING_TEMPLATE = (
 TOO_MANY_RESPONSES_THRESHOLD = 0.9
 
 
-def has_too_many_responses_with_status(interactions: Iterable[Interaction], status_code: int) -> bool:
-    matched = 0
+@dataclass
+class StatusCodeStatistic:
+    """Statistics about HTTP status codes in a scenario."""
+
+    counts: dict[int, int]
+    total: int
+
+    __slots__ = ("counts", "total")
+
+    def ratio_for(self, status_code: int) -> float:
+        """Calculate the ratio of responses with the given status code."""
+        if self.total == 0:
+            return 0.0
+        return self.counts.get(status_code, 0) / self.total
+
+    def should_warn_about_only_4xx(self) -> bool:
+        """Check if an operation should be warned about (only 4xx responses, excluding auth)."""
+        if self.total == 0:
+            return False
+        # Don't duplicate auth warnings
+        if set(self.counts.keys()) <= {401, 403}:
+            return False
+        # At this point we know we only have 4xx responses
+        return True
+
+
+def aggregate_status_codes(interactions: Iterable[Interaction]) -> StatusCodeStatistic:
+    """Analyze status codes from interactions."""
+    counts: dict[int, int] = {}
     total = 0
+
     for interaction in interactions:
         if interaction.response is not None:
-            if interaction.response.status_code == status_code:
-                matched += 1
+            status = interaction.response.status_code
+            counts[status] = counts.get(status, 0) + 1
             total += 1
-    if not total:
-        return False
-    return matched / total >= TOO_MANY_RESPONSES_THRESHOLD
+
+    return StatusCodeStatistic(counts=counts, total=total)