schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/cli/output/default.py

@@ -1,20 +1,17 @@
 from __future__ import annotations
 
-import base64
 import os
 import platform
 import shutil
 import textwrap
 import time
 from importlib import metadata
-from itertools import groupby
-from queue import Queue
-from typing import Any, Generator, cast
+from types import GeneratorType
+from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
 import click
 
-from ... import service
-from ...code_samples import CodeSampleStyle
+from ... import experimental, service
 from ...constants import (
     DISCORD_LINK,
     FALSE_VALUES,
@@ -25,17 +22,33 @@ from ...constants import (
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
 )
-from ...exceptions import RuntimeErrorType, prepare_response_payload
+from ...exceptions import (
+    RuntimeErrorType,
+    extract_requests_exception_details,
+    format_exception,
+)
 from ...experimental import GLOBAL_EXPERIMENTS
+from ...internal.output import prepare_response_payload
+from ...internal.result import Ok
 from ...models import Status
 from ...runner import events
 from ...runner.events import InternalErrorType, SchemaErrorType
 from ...runner.probes import ProbeOutcome
-from ...runner.serialization import SerializedCheck, SerializedError, SerializedTestResult, deduplicate_failures
+from ...runner.serialization import SerializedError, SerializedTestResult
+from ...service.models import AnalysisSuccess, ErrorState, UnknownExtension
+from ...stateful import events as stateful_events
+from ...stateful.sink import StateMachineSink
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
+from ..reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+    import requests
 
 SPINNER_REPETITION_NUMBER = 10
+IO_ENCODING = os.getenv("PYTHONIOENCODING", "utf-8")
 
 
 def get_terminal_width() -> int:
@@ -60,14 +73,14 @@ def get_percentage(position: int, length: int) -> str:
     return f"[{percentage_message}]"
 
 
-def display_execution_result(context: ExecutionContext, event: events.AfterExecution) -> None:
+def display_execution_result(context: ExecutionContext, status: Literal["success", "failure", "error", "skip"]) -> None:
     """Display an appropriate symbol for the given event's execution result."""
     symbol, color = {
-        Status.success: (".", "green"),
-        Status.failure: ("F", "red"),
-        Status.error: ("E", "red"),
-        Status.skip: ("S", "yellow"),
-    }[event.status]
+        "success": (".", "green"),
+        "failure": ("F", "red"),
+        "error": ("E", "red"),
+        "skip": ("S", "yellow"),
+    }[status]
     context.current_line_length += len(symbol)
     click.secho(symbol, nl=False, fg=color)
 
@@ -132,7 +145,9 @@ def display_hypothesis_output(hypothesis_output: list[str]) -> None:
 
 def display_errors(context: ExecutionContext, event: events.Finished) -> None:
     """Display all errors in the test run."""
-    if not event.has_errors:
+    probes = context.probes or []
+    has_probe_errors = any(probe.outcome == ProbeOutcome.ERROR for probe in probes)
+    if not event.has_errors and not has_probe_errors:
         return
 
     display_section_name("ERRORS")
@@ -149,6 +164,12 @@ def display_errors(context: ExecutionContext, event: events.Finished) -> None:
         should_display_full_traceback_message |= display_single_error(context, result)
     if event.generic_errors:
         display_generic_errors(context, event.generic_errors)
+    if has_probe_errors:
+        display_section_name("API Probe errors", "_", fg="red")
+        for probe in probes:
+            if probe.error is not None:
+                error = SerializedError.from_exception(probe.error)
+                _display_error(context, error)
     if should_display_full_traceback_message and not context.show_trace:
         click.secho(
             "\nAdd this option to your command line parameters to see full tracebacks: --show-trace",
@@ -181,16 +202,20 @@ def display_generic_errors(context: ExecutionContext, errors: list[SerializedErr
 
 def display_full_traceback_message(error: SerializedError) -> bool:
     # Some errors should not trigger the message that suggests to show full tracebacks to the user
-    return not error.exception.startswith(
-        (
-            "DeadlineExceeded",
-            "OperationSchemaError",
-            "requests.exceptions",
-            "SerializationNotPossible",
-            "hypothesis.errors.FailedHealthCheck",
-            "hypothesis.errors.InvalidArgument: Scalar ",
-            "hypothesis.errors.InvalidArgument: min_size=",
+    return (
+        not error.exception.startswith(
+            (
+                "DeadlineExceeded",
+                "OperationSchemaError",
+                "requests.exceptions",
+                "SerializationNotPossible",
+                "hypothesis.errors.FailedHealthCheck",
+                "hypothesis.errors.InvalidArgument: Scalar ",
+                "hypothesis.errors.InvalidArgument: min_size=",
+                "hypothesis.errors.Unsatisfiable",
+            )
         )
+        and "can never generate an example, because min_size is larger than Hypothesis supports." not in error.exception
     )
 
 
@@ -243,11 +268,11 @@ def _display_error(context: ExecutionContext, error: SerializedError) -> bool:
     if error.extras:
         extras = error.extras
     elif context.show_trace and error.type.has_useful_traceback:
-        extras = _split_traceback(error.exception_with_traceback)
+        extras = split_traceback(error.exception_with_traceback)
     else:
         extras = []
     _display_extras(extras)
-    suggestion = RUNTIME_ERROR_SUGGESTIONS.get(error.type)
+    suggestion = get_runtime_error_suggestion(error.type)
     _maybe_display_tip(suggestion)
     return display_full_traceback_message(error)
 
@@ -266,7 +291,16 @@ def display_failures(context: ExecutionContext, event: events.Finished) -> None:
         display_failures_for_single_test(context, result)
 
 
-TEST_CASE_ID_TITLE = "Test Case ID"
+if IO_ENCODING != "utf-8":
+
+    def _secho(text: str, **kwargs: Any) -> None:
+        text = text.encode(IO_ENCODING, errors="replace").decode("utf-8")
+        click.secho(text, **kwargs)
+
+else:
+
+    def _secho(text: str, **kwargs: Any) -> None:
+        click.secho(text, **kwargs)
 
 
 def display_failures_for_single_test(context: ExecutionContext, result: SerializedTestResult) -> None:
@@ -284,63 +318,31 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
         for check_idx, check in enumerate(checks):
             if check_idx == 0:
                 click.secho(f"{idx}. {TEST_CASE_ID_TITLE}: {check.example.id}", bold=True)
-            if check.context is not None:
-                title = check.context.title
-                if check.context.message:
-                    message = check.context.message
-                else:
-                    message = None
-            else:
-                title = f"Custom check failed: `{check.name}`"
-                message = check.message
-            click.secho(f"\n- {title}", fg="red", bold=True)
+            click.secho(f"\n- {check.title}", fg="red", bold=True)
+            message = check.formatted_message
             if message:
-                message = textwrap.indent(message, prefix="    ")
-                click.secho(f"\n{message}", fg="red")
+                _secho(f"\n{message}", fg="red")
             if check_idx + 1 == len(checks):
                 if check.response is not None:
                     status_code = check.response.status_code
                     reason = get_reason(status_code)
                     response = bold(f"[{check.response.status_code}] {reason}")
                     click.echo(f"\n{response}:")
-
-                    response_body = check.response.body
-                    if check.response is not None and response_body is not None:
-                        if not response_body:
+                    if check.response.body is not None:
+                        if not check.response.body:
                             click.echo("\n    <EMPTY>")
                         else:
                             encoding = check.response.encoding or "utf8"
                             try:
-                                payload = base64.b64decode(response_body).decode(encoding)
-                                payload = prepare_response_payload(payload)
+                                # Checked that is not None
+                                body = cast(bytes, check.response.deserialize_body())
+                                payload = body.decode(encoding)
+                                payload = prepare_response_payload(payload, config=context.output_config)
                                 payload = textwrap.indent(f"\n`{payload}`", prefix="    ")
                                 click.echo(payload)
                             except UnicodeDecodeError:
                                 click.echo("\n    <BINARY>")
-
-        click.echo(
-            f"\n{bold('Reproduce with')}: \n\n    {code_sample}\n",
-        )
-
-
-def group_by_case(
-    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
-) -> Generator[tuple[str, Generator[SerializedCheck, None, None]], None, None]:
-    checks = deduplicate_failures(checks)
-    checks = sorted(checks, key=lambda c: _by_unique_code_sample(c, code_sample_style))
-    yield from groupby(checks, lambda c: _by_unique_code_sample(c, code_sample_style))
-
-
-def _by_unique_code_sample(check: SerializedCheck, code_sample_style: CodeSampleStyle) -> str:
-    request_body = base64.b64decode(check.example.body).decode() if check.example.body is not None else None
-    return code_sample_style.generate(
-        method=check.example.method,
-        url=check.example.url,
-        body=request_body,
-        headers=check.example.headers,
-        verify=check.example.verify,
-        extra_headers=check.example.extra_headers,
-    )
+        _secho(f"\n{bold('Reproduce with')}: \n\n    {code_sample}\n")
 
 
 def display_application_logs(context: ExecutionContext, event: events.Finished) -> None:
@@ -359,11 +361,89 @@ def display_single_log(result: SerializedTestResult) -> None:
     click.echo("\n\n".join(result.logs))
 
 
+def display_analysis(context: ExecutionContext) -> None:
+    """Display schema analysis details."""
+    import requests.exceptions
+
+    if context.analysis is None:
+        return
+    display_section_name("SCHEMA ANALYSIS")
+    if isinstance(context.analysis, Ok):
+        analysis = context.analysis.ok()
+        click.echo()
+        if isinstance(analysis, AnalysisSuccess):
+            click.secho(analysis.message, bold=True)
+            click.echo(f"\nAnalysis took: {analysis.elapsed:.2f}ms")
+            if analysis.extensions:
+                known = []
+                failed = []
+                unknown = []
+                for extension in analysis.extensions:
+                    if isinstance(extension, UnknownExtension):
+                        unknown.append(extension)
+                    elif isinstance(extension.state, ErrorState):
+                        failed.append(extension)
+                    else:
+                        known.append(extension)
+                if known:
+                    click.echo("\nThe following extensions have been applied:\n")
+                    for extension in known:
+                        click.echo(f"  - {extension.summary}")
+                if failed:
+                    click.echo("\nThe following extensions errored:\n")
+                    for extension in failed:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Please, consider reporting this to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+                if unknown:
+                    noun = "extension" if len(unknown) == 1 else "extensions"
+                    specific_noun = "this extension" if len(unknown) == 1 else "these extensions"
+                    title = click.style("Compatibility Notice", bold=True)
+                    click.secho(f"\n{title}: {len(unknown)} {noun} not recognized:\n")
+                    for extension in unknown:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Consider updating the CLI to add support for {specific_noun}."
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+            else:
+                click.echo("\nNo extensions have been applied.")
+        else:
+            click.echo("An error happened during schema analysis:\n")
+            click.secho(f"  {analysis.message}", bold=True)
+        click.echo()
+    else:
+        exception = context.analysis.err()
+        suggestion = None
+        if isinstance(exception, requests.exceptions.HTTPError):
+            response = exception.response
+            click.secho("Error\n", fg="red", bold=True)
+            _display_service_network_error(response)
+            click.echo()
+            return
+        if isinstance(exception, requests.RequestException):
+            message, extras = extract_requests_exception_details(exception)
+            suggestion = "Please check your network connection and try again."
+            title = "Network Error"
+        else:
+            traceback = format_exception(exception, True)
+            extras = split_traceback(traceback)
+            title = "Internal Error"
+            message = f"We apologize for the inconvenience. This appears to be an internal issue.\nPlease, consider reporting the following details to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+            suggestion = "Please update your CLI to the latest version and try again."
+        click.secho(f"{title}\n", fg="red", bold=True)
+        click.echo(message)
+        _display_extras(extras)
+        _maybe_display_tip(suggestion)
+        click.echo()
+
+
 def display_statistic(context: ExecutionContext, event: events.Finished) -> None:
     """Format and print statistic collected by :obj:`models.TestResult`."""
     display_section_name("SUMMARY")
     click.echo()
     total = event.total
+    if context.state_machine_sink is not None:
+        click.echo(context.state_machine_sink.transitions.to_formatted_table(get_terminal_width()))
+        click.echo()
     if event.is_empty or not total:
         click.secho("No checks were performed.", bold=True)
 
@@ -471,7 +551,7 @@ def display_report_metadata(meta: service.Metadata) -> None:
             if value is not None:
                 click.secho(f"  -> {key}: {value}")
         click.echo()
-    click.secho(f"Compressed report size: {meta.size / 1024.:,.0f} KB", bold=True)
+    click.secho(f"Compressed report size: {meta.size / 1024.0:,.0f} KB", bold=True)
 
 
 def display_service_unauthorized(hostname: str) -> None:
@@ -493,39 +573,45 @@ def display_service_error(event: service.Error, message_prefix: str = "") -> Non
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
-        status_code = response.status_code
-        if 500 <= status_code <= 599:
-            click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
-            # Server error, should be resolved soon
-            click.secho(
-                "\nIt is likely that we are already notified about the issue and working on a fix\n"
-                "Please, try again in 30 minutes",
-                fg="red",
-            )
-        elif status_code == 401:
-            # Likely an invalid token
-            click.echo("Your CLI is not authenticated.")
-            display_service_unauthorized("schemathesis.io")
-        else:
-            try:
-                data = response.json()
-                detail = data["detail"]
-                click.secho(f"{message_prefix}{detail}", fg="red")
-            except Exception:
-                # Other client-side errors are likely caused by a bug on the CLI side
-                click.secho(
-                    "We apologize for the inconvenience. This appears to be an internal issue.\n"
-                    "Please, consider reporting the following details to our issue "
-                    f"tracker:\n\n  {ISSUE_TRACKER_URL}\n\nResponse: {response.text!r}\n"
-                    f"Headers: {response.headers!r}",
-                    fg="red",
-                )
+        _display_service_network_error(response, message_prefix)
     elif isinstance(event.exception, RequestException):
         ask_to_report(event, report_to_issues=False)
     else:
         ask_to_report(event)
 
 
+def _display_service_network_error(response: requests.Response, message_prefix: str = "") -> None:
+    status_code = response.status_code
+    if 500 <= status_code <= 599:
+        click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
+        # Server error, should be resolved soon
+        click.secho(
+            "\nIt is likely that we are already notified about the issue and working on a fix\n"
+            "Please, try again in 30 minutes",
+            fg="red",
+        )
+    elif status_code == 401:
+        # Likely an invalid token
+        click.echo("Your CLI is not authenticated.")
+        display_service_unauthorized("schemathesis.io")
+    else:
+        try:
+            data = response.json()
+            detail = data["detail"]
+            click.secho(f"{message_prefix}{detail}", fg="red")
+        except Exception:
+            # Other client-side errors are likely caused by a bug on the CLI side
+            click.secho(
+                "We apologize for the inconvenience. This appears to be an internal issue.\n"
+                "Please, consider reporting the following details to our issue "
+                f"tracker:\n\n  {ISSUE_TRACKER_URL}\n\nResponse: {response.text!r}\n"
+                f"Status: {response.status_code}\n"
+                f"Headers: {response.headers!r}",
+                fg="red",
+            )
+            _maybe_display_tip("Please update your CLI to the latest version and try again.")
+
+
 SERVICE_ERROR_MESSAGE = "An error happened during uploading reports to Schemathesis.io"
 
 
@@ -564,7 +650,6 @@ def wait_for_report_handler(queue: Queue, title: str, timeout: float = service.W
 
 def create_spinner(repetitions: int) -> Generator[str, None, None]:
     """A simple spinner that yields its individual characters."""
-    assert repetitions > 0, "The number of repetitions should be greater than zero"
     while True:
         for ch in "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏":
             # Skip branch coverage, as it is not possible because of the assertion above
@@ -625,10 +710,6 @@ def should_skip_suggestion(context: ExecutionContext, event: events.InternalErro
     return event.subtype == SchemaErrorType.CONNECTION_OTHER and context.wait_for_schema is not None
 
 
-def _split_traceback(traceback: str) -> list[str]:
-    return [entry for entry in traceback.splitlines() if entry]
-
-
 def _display_extras(extras: list[str]) -> None:
     if extras:
         click.echo()
@@ -649,7 +730,7 @@ def display_internal_error(context: ExecutionContext, event: events.InternalErro
     if event.type == InternalErrorType.SCHEMA:
         extras = event.extras
     elif context.show_trace:
-        extras = _split_traceback(event.exception_with_traceback)
+        extras = split_traceback(event.exception_with_traceback)
     else:
         extras = [event.exception]
     _display_extras(extras)
@@ -696,6 +777,8 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
+    if context.initialization_lines:
+        _print_lines(context.initialization_lines)
 
 
 def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
@@ -712,7 +795,23 @@ def handle_after_probing(context: ExecutionContext, event: events.AfterProbing)
                 status = "SUCCESS"
             elif probe.outcome == ProbeOutcome.ERROR:
                 status = "ERROR"
-    click.secho(f"API probing: {status}\r", bold=True, nl=False)
+    click.secho(f"API probing: {status}", bold=True, nl=False)
+    click.echo()
+
+
+def handle_before_analysis(context: ExecutionContext, event: events.BeforeAnalysis) -> None:
+    click.secho("Schema analysis: ...\r", bold=True, nl=False)
+
+
+def handle_after_analysis(context: ExecutionContext, event: events.AfterAnalysis) -> None:
+    context.analysis = event.analysis
+    status = "SKIP"
+    if event.analysis is not None:
+        if isinstance(event.analysis, Ok) and isinstance(event.analysis.ok(), AnalysisSuccess):
+            status = "SUCCESS"
+        else:
+            status = "ERROR"
+    click.secho(f"Schema analysis: {status}", bold=True, nl=False)
     click.echo()
     operations_count = cast(int, context.operations_count)  # INVARIANT: should not be `None`
     if operations_count >= 1:
@@ -741,7 +840,7 @@ def handle_after_execution(context: ExecutionContext, event: events.AfterExecuti
     """Display the execution result + current progress at the same line with the method / path names."""
     context.operations_processed += 1
     context.results.append(event.result)
-    display_execution_result(context, event)
+    display_execution_result(context, event.status.value)
     display_percentage(context, event)
 
 
@@ -752,13 +851,30 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_errors(context, event)
     display_failures(context, event)
     display_application_logs(context, event)
+    display_analysis(context)
     display_statistic(context, event)
+    if context.summary_lines:
+        click.echo()
+        _print_lines(context.summary_lines)
     click.echo()
     display_summary(event)
 
 
+def _print_lines(lines: list[str | Generator[str, None, None]]) -> None:
+    for entry in lines:
+        if isinstance(entry, str):
+            click.echo(entry)
+        elif isinstance(entry, GeneratorType):
+            for line in entry:
+                click.echo(line)
+
+
 def handle_interrupted(context: ExecutionContext, event: events.Interrupted) -> None:
     click.echo()
+    _handle_interrupted(context)
+
+
+def _handle_interrupted(context: ExecutionContext) -> None:
     context.is_interrupted = True
     display_section_name("KeyboardInterrupt", "!", bold=False)
 
@@ -768,23 +884,53 @@ def handle_internal_error(context: ExecutionContext, event: events.InternalError
     raise click.Abort
 
 
+def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent) -> None:
+    if isinstance(event.data, stateful_events.RunStarted):
+        context.state_machine_sink = event.data.state_machine.sink()
+        if not experimental.STATEFUL_ONLY.is_enabled:
+            click.echo()
+        click.secho("Stateful tests\n", bold=True)
+    elif isinstance(event.data, stateful_events.ScenarioFinished) and not event.data.is_final:
+        if event.data.status == stateful_events.ScenarioStatus.INTERRUPTED:
+            _handle_interrupted(context)
+        elif event.data.status != stateful_events.ScenarioStatus.REJECTED:
+            display_execution_result(context, event.data.status.value)
+    elif isinstance(event.data, stateful_events.RunFinished):
+        click.echo()
+    # It is initialized in `RunStarted`
+    sink = cast(StateMachineSink, context.state_machine_sink)
+    sink.consume(event.data)
+
+
+def handle_after_stateful_execution(context: ExecutionContext, event: events.AfterStatefulExecution) -> None:
+    context.results.append(event.result)
+
+
 class DefaultOutputStyleHandler(EventHandler):
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         """Choose and execute a proper handler for the given event."""
         if isinstance(event, events.Initialized):
             handle_initialized(context, event)
-        if isinstance(event, events.BeforeProbing):
+        elif isinstance(event, events.BeforeProbing):
             handle_before_probing(context, event)
-        if isinstance(event, events.AfterProbing):
+        elif isinstance(event, events.AfterProbing):
             handle_after_probing(context, event)
-        if isinstance(event, events.BeforeExecution):
+        elif isinstance(event, events.BeforeAnalysis):
+            handle_before_analysis(context, event)
+        elif isinstance(event, events.AfterAnalysis):
+            handle_after_analysis(context, event)
+        elif isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
-        if isinstance(event, events.AfterExecution):
+        elif isinstance(event, events.AfterExecution):
             context.hypothesis_output.extend(event.hypothesis_output)
             handle_after_execution(context, event)
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.Finished):
             handle_finished(context, event)
-        if isinstance(event, events.Interrupted):
+        elif isinstance(event, events.Interrupted):
             handle_interrupted(context, event)
-        if isinstance(event, events.InternalError):
+        elif isinstance(event, events.InternalError):
             handle_internal_error(context, event)
+        elif isinstance(event, events.StatefulEvent):
+            handle_stateful_event(context, event)
+        elif isinstance(event, events.AfterStatefulExecution):
+            handle_after_stateful_execution(context, event)

schemathesis/cli/output/short.py

@@ -1,6 +1,7 @@
 import click
 
 from ...runner import events
+from ...stateful import events as stateful_events
 from ..context import ExecutionContext
 from ..handlers import EventHandler
 from . import default
@@ -15,7 +16,13 @@ def handle_after_execution(context: ExecutionContext, event: events.AfterExecuti
     context.operations_processed += 1
     context.results.append(event.result)
     context.hypothesis_output.extend(event.hypothesis_output)
-    default.display_execution_result(context, event)
+    default.display_execution_result(context, event.status.value)
+
+
+def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent) -> None:
+    if isinstance(event.data, stateful_events.RunStarted):
+        click.echo()
+    default.handle_stateful_event(context, event)
 
 
 class ShortOutputStyleHandler(EventHandler):
@@ -26,19 +33,27 @@ class ShortOutputStyleHandler(EventHandler):
         """
         if isinstance(event, events.Initialized):
             default.handle_initialized(context, event)
-        if isinstance(event, events.BeforeProbing):
+        elif isinstance(event, events.BeforeProbing):
             default.handle_before_probing(context, event)
-        if isinstance(event, events.AfterProbing):
+        elif isinstance(event, events.AfterProbing):
             default.handle_after_probing(context, event)
-        if isinstance(event, events.BeforeExecution):
+        elif isinstance(event, events.BeforeAnalysis):
+            default.handle_before_analysis(context, event)
+        elif isinstance(event, events.AfterAnalysis):
+            default.handle_after_analysis(context, event)
+        elif isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
-        if isinstance(event, events.AfterExecution):
+        elif isinstance(event, events.AfterExecution):
             handle_after_execution(context, event)
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.Finished):
             if context.operations_count == context.operations_processed:
                 click.echo()
             default.handle_finished(context, event)
-        if isinstance(event, events.Interrupted):
+        elif isinstance(event, events.Interrupted):
             default.handle_interrupted(context, event)
-        if isinstance(event, events.InternalError):
+        elif isinstance(event, events.InternalError):
             default.handle_internal_error(context, event)
+        elif isinstance(event, events.StatefulEvent):
+            handle_stateful_event(context, event)
+        elif isinstance(event, events.AfterStatefulExecution):
+            default.handle_after_stateful_execution(context, event)