schemathesis 3.29.2__py3-none-any.whl → 3.30.1__py3-none-any.whl

schemathesis/__init__.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
+
 from typing import Any
 
-from . import auths, checks, experimental, contrib, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
+from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
 from ._lazy_import import lazy_import
-from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig  # noqa: E402
 from .constants import SCHEMATHESIS_VERSION  # noqa: E402
+from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig  # noqa: E402
 from .models import Case  # noqa: E402
 from .specs import openapi  # noqa: E402
 
-
 __version__ = SCHEMATHESIS_VERSION
 
 # Default loaders

schemathesis/_compat.py

@@ -1,6 +1,6 @@
-from typing import Any, Type, Callable
-from ._lazy_import import lazy_import
+from typing import Any, Callable, Type
 
+from ._lazy_import import lazy_import
 
 __all__ = [  # noqa: F822
     "JSONMixin",

schemathesis/_dependency_versions.py

@@ -1,16 +1,14 @@
 """Compatibility flags based on installed dependency versions."""
 
-from packaging import version
-
 from importlib import metadata
 
+from packaging import version
 
 WERKZEUG_VERSION = version.parse(metadata.version("werkzeug"))
 IS_WERKZEUG_ABOVE_3 = WERKZEUG_VERSION >= version.parse("3.0")
 IS_WERKZEUG_BELOW_2_1 = WERKZEUG_VERSION < version.parse("2.1.0")
 
 PYTEST_VERSION = version.parse(metadata.version("pytest"))
-IS_PYTEST_ABOVE_54 = PYTEST_VERSION >= version.parse("5.4.0")
 IS_PYTEST_ABOVE_7 = PYTEST_VERSION >= version.parse("7.0.0")
 IS_PYTEST_ABOVE_8 = PYTEST_VERSION >= version.parse("8.0.0")
 

schemathesis/_hypothesis.py

@@ -10,6 +10,7 @@ import hypothesis
 from hypothesis import Phase
 from hypothesis import strategies as st
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
+from hypothesis.internal.entropy import deterministic_PRNG
 from hypothesis.internal.reflection import proxies
 from jsonschema.exceptions import SchemaError
 
@@ -23,6 +24,11 @@ from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .utils import GivenInput, combine_strategies
 
+# Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
+# if e.g. Schemathesis CLI is used with multiple workers
+with deterministic_PRNG():
+    pass
+
 
 def create_test(
     *,

schemathesis/_lazy_import.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Any, Callable
 
 

schemathesis/_override.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
 

schemathesis/_rate_limiter.py

@@ -3,4 +3,5 @@ from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 if IS_PYRATE_LIMITER_ABOVE_3:
     from pyrate_limiter import Limiter, Rate, RateItem
 else:
-    from pyrate_limiter import Limiter, RequestRate as Rate
+    from pyrate_limiter import Limiter
+    from pyrate_limiter import RequestRate as Rate

schemathesis/_xml.py

@@ -1,6 +1,7 @@
 """XML serialization."""
 
 from __future__ import annotations
+
 from io import StringIO
 from typing import Any, Dict, List, Union
 from xml.etree import ElementTree

schemathesis/auths.py

@@ -1,6 +1,7 @@
 """Support for custom API authentication mechanisms."""
 
 from __future__ import annotations
+
 import inspect
 import threading
 import time
@@ -11,10 +12,10 @@ from typing import (
     Any,
     Callable,
     Generic,
+    Protocol,
     TypeVar,
     overload,
     runtime_checkable,
-    Protocol,
 )
 
 from .exceptions import UsageError
@@ -22,9 +23,10 @@ from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
 from .types import GenericTest
 
 if TYPE_CHECKING:
-    from .models import APIOperation, Case
     import requests.auth
 
+    from .models import APIOperation, Case
+
 DEFAULT_REFRESH_INTERVAL = 300
 AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"
 Auth = TypeVar("Auth")

schemathesis/checks.py

@@ -1,19 +1,21 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+
 import json
+from typing import TYPE_CHECKING
 
 from . import failures
-from .exceptions import get_server_error, get_response_parsing_error
+from .exceptions import get_response_parsing_error, get_server_error
 from .specs.openapi.checks import (
     content_type_conformance,
+    negative_data_rejection,
     response_headers_conformance,
     response_schema_conformance,
     status_code_conformance,
 )
 
 if TYPE_CHECKING:
-    from .transports.responses import GenericResponse
     from .models import Case, CheckFunction
+    from .transports.responses import GenericResponse
 
 
 def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
@@ -24,14 +26,14 @@ def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
 
     status_code = response.status_code
     if status_code >= 500:
-        exc_class = get_server_error(status_code)
+        exc_class = get_server_error(case.operation.verbose_name, status_code)
         raise exc_class(failures.ServerError.title, context=failures.ServerError(status_code=status_code))
     if isinstance(case, GraphQLCase):
         try:
             data = get_json(response)
             validate_graphql_response(data)
         except json.JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(exc)
+            exc_class = get_response_parsing_error(case.operation.verbose_name, exc)
             context = failures.JSONDecodeErrorContext.from_exception(exc)
             raise exc_class(context.title, context=context) from exc
     return None
@@ -43,6 +45,7 @@ OPTIONAL_CHECKS = (
     content_type_conformance,
     response_headers_conformance,
     response_schema_conformance,
+    negative_data_rejection,
 )
 ALL_CHECKS: tuple[CheckFunction, ...] = DEFAULT_CHECKS + OPTIONAL_CHECKS
 

schemathesis/cli/__init__.py

@@ -38,6 +38,7 @@ from ..fixups import ALL_FIXUPS
 from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
 from ..internal.datetime import current_datetime
+from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
 from ..loaders import load_app, load_yaml
 from ..models import Case, CheckFunction
@@ -683,10 +684,25 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     "--experimental",
     "experiments",
     help="Enable experimental support for specific features.",
-    type=click.Choice([experimental.OPEN_API_3_1.name, experimental.SCHEMA_ANALYSIS.name]),
+    type=click.Choice(
+        [
+            experimental.OPEN_API_3_1.name,
+            experimental.SCHEMA_ANALYSIS.name,
+            experimental.STATEFUL_TEST_RUNNER.name,
+            experimental.STATEFUL_ONLY.name,
+        ]
+    ),
     callback=callbacks.convert_experimental,
     multiple=True,
 )
+@click.option(
+    "--output-truncate",
+    help="Specifies whether to truncate schemas and responses in error messages.",
+    type=str,
+    default="true",
+    show_default=True,
+    callback=callbacks.convert_boolean_string,
+)
 @click.option(
     "--generation-allow-x00",
     help="Determines whether to allow the generation of `\x00` bytes within strings.",
@@ -776,6 +792,7 @@ def run(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     force_schema_version: str | None = None,
     sanitize_output: bool = True,
+    output_truncate: bool = True,
     contrib_unique_data: bool = False,
     contrib_openapi_formats_uuid: bool = False,
     contrib_openapi_fill_missing_examples: bool = False,
@@ -856,6 +873,8 @@ def run(
         click.secho(DEPRECATED_CASSETTE_PATH_OPTION_WARNING, fg="yellow")
         cassette_path = store_network_log
 
+    output_config = OutputConfig(truncate=output_truncate)
+
     schemathesis_io_hostname = urlparse(schemathesis_io_url).netloc
     token = schemathesis_io_token or service.hosts.get_token(hostname=schemathesis_io_hostname, hosts_file=hosts_file)
     schema_kind = callbacks.parse_schema_kind(schema, app)
@@ -975,6 +994,7 @@ def run(
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
         generation_config=generation_config,
+        output_config=output_config,
         service_client=client,
     )
     execute(
@@ -1001,6 +1021,7 @@ def run(
         location=schema,
         base_url=base_url,
         started_at=started_at,
+        output_config=output_config,
     )
 
 
@@ -1029,6 +1050,7 @@ class LoaderConfig:
     request_cert: RequestCert | None
     wait_for_schema: float | None
     rate_limit: str | None
+    output_config: OutputConfig
     # Network request parameters
     auth: tuple[str, str] | None
     auth_type: str | None
@@ -1072,6 +1094,7 @@ def into_event_stream(
     workers_num: int,
     hypothesis_settings: hypothesis.settings | None,
     generation_config: generation.GenerationConfig,
+    output_config: OutputConfig,
     seed: int | None,
     exit_first: bool,
     max_failures: int | None,
@@ -1105,6 +1128,7 @@ def into_event_stream(
             method=method or None,
             tag=tag or None,
             operation_id=operation_id or None,
+            output_config=output_config,
         )
         schema = load_schema(config)
         yield from runner.from_schema(
@@ -1250,6 +1274,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> dict[str, Any]:
         "force_schema_version": config.force_schema_version,
         "data_generation_methods": config.data_generation_methods,
         "rate_limit": config.rate_limit,
+        "output_config": config.output_config,
     }
     if loader not in (oas_loaders.from_path, oas_loaders.from_dict):
         kwargs["headers"] = config.headers
@@ -1377,6 +1402,7 @@ def execute(
     location: str,
     base_url: str | None,
     started_at: str,
+    output_config: OutputConfig,
 ) -> None:
     """Execute a prepared runner by drawing events from it and passing to a proper handler."""
     handlers: list[EventHandler] = []
@@ -1440,6 +1466,7 @@ def execute(
         verbosity=verbosity,
         code_sample_style=code_sample_style,
         report=report_context,
+        output_config=output_config,
     )
 
     def shutdown() -> None:

schemathesis/cli/callbacks.py

@@ -7,25 +7,24 @@ import re
 import traceback
 from contextlib import contextmanager
 from functools import partial
-from typing import Generator, TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, Generator
 from urllib.parse import urlparse
 
 import click
-
 from click.types import LazyFile  # type: ignore
 
 from .. import exceptions, experimental, throttling
 from ..code_samples import CodeSampleStyle
+from ..constants import FALSE_VALUES, TRUE_VALUES
 from ..exceptions import extract_nth_traceback
 from ..generation import DataGenerationMethod
-from ..constants import TRUE_VALUES, FALSE_VALUES
 from ..internal.validation import file_exists, is_filename, is_illegal_surrogate
 from ..loaders import load_app
 from ..service.hosts import get_temporary_hosts_file
+from ..stateful import Stateful
 from ..transports.headers import has_invalid_characters, is_latin_1_encodable
 from ..types import PathLike
 from .constants import DEFAULT_WORKERS
-from ..stateful import Stateful
 
 if TYPE_CHECKING:
     import hypothesis

schemathesis/cli/cassettes.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import base64
 import json
 import re
@@ -6,7 +7,7 @@ import sys
 import threading
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import IO, Any, Generator, Iterator, cast, TYPE_CHECKING
+from typing import IO, TYPE_CHECKING, Any, Generator, Iterator, cast
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
@@ -16,10 +17,11 @@ from .handlers import EventHandler
 if TYPE_CHECKING:
     import click
     import requests
+
+    from ..generation import DataGenerationMethod
     from ..models import Request, Response
     from ..runner.serialization import SerializedCheck, SerializedInteraction
     from .context import ExecutionContext
-    from ..generation import DataGenerationMethod
 
 # Wait until the worker terminates
 WRITER_WORKER_JOIN_TIMEOUT = 1
@@ -351,9 +353,9 @@ def filter_cassette(
 
 def get_prepared_request(data: dict[str, Any]) -> requests.PreparedRequest:
     """Create a `requests.PreparedRequest` from a serialized one."""
-    from requests.structures import CaseInsensitiveDict
-    from requests.cookies import RequestsCookieJar
     import requests
+    from requests.cookies import RequestsCookieJar
+    from requests.structures import CaseInsensitiveDict
 
     prepared = requests.PreparedRequest()
     prepared.method = data["method"]

schemathesis/cli/constants.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
+
 from enum import IntEnum, unique
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import hypothesis
+
 MIN_WORKERS = 1
 DEFAULT_WORKERS = MIN_WORKERS
 MAX_WORKERS = 64

schemathesis/cli/context.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
+from ..internal.output import OutputConfig
 from ..internal.result import Result
 from ..runner.probes import ProbeRun
 from ..runner.serialization import SerializedTestResult
@@ -16,6 +17,8 @@ from ..service.models import AnalysisResult
 if TYPE_CHECKING:
     import hypothesis
 
+    from ..stateful.sink import StateMachineSink
+
 
 @dataclass
 class ServiceReportContext:
@@ -55,8 +58,10 @@ class ExecutionContext:
     report: ServiceReportContext | FileReportContext | None = None
     probes: list[ProbeRun] | None = None
     analysis: Result[AnalysisResult, Exception] | None = None
+    output_config: OutputConfig = field(default_factory=OutputConfig)
     # Special flag to display a warning about Windows-specific encoding issue
     encountered_windows_encoding_issue: bool = False
+    state_machine_sink: StateMachineSink | None = None
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:

schemathesis/cli/debug.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
+
 import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-
 from .handlers import EventHandler
 
 if TYPE_CHECKING:
     from click.utils import LazyFile
+
     from ..runner import events
     from .context import ExecutionContext
 

schemathesis/cli/handlers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..runner import events

schemathesis/cli/junitxml.py

@@ -7,7 +7,8 @@ from typing import TYPE_CHECKING, cast
 
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
-from ..exceptions import RuntimeErrorType, prepare_response_payload
+from ..exceptions import RuntimeErrorType
+from ..internal.output import prepare_response_payload
 from ..models import Status
 from ..runner import events
 from ..runner.serialization import SerializedCheck, SerializedError
@@ -37,7 +38,7 @@ class JunitXMLHandler(EventHandler):
                     group_by_case(event.result.checks, context.code_sample_style), 1
                 ):
                     checks = sorted(group, key=lambda c: c.name != "not_a_server_error")
-                    test_case.add_failure_info(message=build_failure_message(idx, code_sample, checks))
+                    test_case.add_failure_info(message=build_failure_message(context, idx, code_sample, checks))
             elif event.status == Status.error:
                 test_case.add_error_info(message=build_error_message(context, event.result.errors[-1]))
             elif event.status == Status.skip:
@@ -48,7 +49,7 @@ class JunitXMLHandler(EventHandler):
             to_xml_report_file(file_descriptor=self.file_handle, test_suites=test_suites, prettyprint=True)
 
 
-def build_failure_message(idx: int, code_sample: str, checks: list[SerializedCheck]) -> str:
+def build_failure_message(context: ExecutionContext, idx: int, code_sample: str, checks: list[SerializedCheck]) -> str:
     from ..transports.responses import get_reason
 
     message = ""
@@ -73,7 +74,7 @@ def build_failure_message(idx: int, code_sample: str, checks: list[SerializedChe
                             # Checked that is not None
                             body = cast(bytes, check.response.deserialize_body())
                             payload = body.decode(encoding)
-                            payload = prepare_response_payload(payload)
+                            payload = prepare_response_payload(payload, config=context.output_config)
                             payload = textwrap.indent(f"\n`{payload}`\n", prefix="    ")
                             message += payload
                         except UnicodeDecodeError:

schemathesis/cli/options.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from enum import Enum
 from typing import Any, NoReturn
 

schemathesis/cli/output/default.py

@@ -7,11 +7,11 @@ import textwrap
 import time
 from importlib import metadata
 from queue import Queue
-from typing import Any, Generator, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generator, Literal, cast
 
 import click
 
-from ... import service
+from ... import experimental, service
 from ...constants import (
     DISCORD_LINK,
     FALSE_VALUES,
@@ -24,21 +24,23 @@ from ...constants import (
 )
 from ...exceptions import (
     RuntimeErrorType,
-    format_exception,
-    prepare_response_payload,
     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 SerializedError, SerializedTestResult
-from ...service.models import AnalysisSuccess, UnknownExtension, ErrorState
+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 group_by_case, TEST_CASE_ID_TITLE, split_traceback, get_runtime_error_suggestion
+from ..reporting import TEST_CASE_ID_TITLE, get_runtime_error_suggestion, group_by_case, split_traceback
 
 if TYPE_CHECKING:
     import requests
@@ -68,14 +70,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)
 
@@ -312,7 +314,7 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
                                 # Checked that is not None
                                 body = cast(bytes, check.response.deserialize_body())
                                 payload = body.decode(encoding)
-                                payload = prepare_response_payload(payload)
+                                payload = prepare_response_payload(payload, config=context.output_config)
                                 payload = textwrap.indent(f"\n`{payload}`", prefix="    ")
                                 click.echo(payload)
                             except UnicodeDecodeError:
@@ -433,6 +435,9 @@ def display_statistic(context: ExecutionContext, event: events.Finished) -> None
     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)
 
@@ -551,7 +556,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:
@@ -839,7 +844,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)
 
 
@@ -867,27 +872,54 @@ 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
+        and 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.BeforeAnalysis):
+        elif isinstance(event, events.BeforeAnalysis):
             handle_before_analysis(context, event)
-        if isinstance(event, events.AfterAnalysis):
+        elif isinstance(event, events.AfterAnalysis):
             handle_after_analysis(context, event)
-        if isinstance(event, events.BeforeExecution):
+        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)