schemathesis 3.29.1__py3-none-any.whl → 3.30.0__py3-none-any.whl

schemathesis/exceptions.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import enum
 import json
 import re
@@ -14,11 +15,13 @@ from .failures import FailureContext
 
 if TYPE_CHECKING:
     import hypothesis.errors
-    from jsonschema import RefResolutionError, ValidationError, SchemaError as JsonSchemaError
-    from .transports.responses import GenericResponse
     from graphql.error import GraphQLFormattedError
+    from jsonschema import RefResolutionError, ValidationError
+    from jsonschema import SchemaError as JsonSchemaError
     from requests import RequestException
 
+    from .transports.responses import GenericResponse
+
 
 class CheckFailed(AssertionError):
     """Custom error type to distinguish from arbitrary AssertionError that may happen in the dependent libraries."""
@@ -97,52 +100,60 @@ def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> type[Chec
     return _get_hashed_exception("GroupedException", f"{prefix}{message}")
 
 
-def get_server_error(status_code: int) -> type[CheckFailed]:
+def get_server_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for the Internal Server Error cases."""
-    name = f"ServerError{status_code}"
+    name = f"ServerError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_status_code_error(status_code: int) -> type[CheckFailed]:
+def get_status_code_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for an unexpected status code."""
-    name = f"StatusCodeError{status_code}"
+    name = f"StatusCodeError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_response_type_error(expected: str, received: str) -> type[CheckFailed]:
+def get_response_type_error(prefix: str, expected: str, received: str) -> type[CheckFailed]:
     """Return new exception for an unexpected response type."""
-    name = f"SchemaValidationError{expected}_{received}"
+    name = f"SchemaValidationError{prefix}{expected}_{received}"
     return get_exception(name)
 
 
-def get_malformed_media_type_error(media_type: str) -> type[CheckFailed]:
-    name = f"MalformedMediaType{media_type}"
+def get_malformed_media_type_error(prefix: str, media_type: str) -> type[CheckFailed]:
+    name = f"MalformedMediaType{prefix}{media_type}"
     return get_exception(name)
 
 
-def get_missing_content_type_error() -> type[CheckFailed]:
+def get_missing_content_type_error(prefix: str) -> type[CheckFailed]:
     """Return new exception for a missing Content-Type header."""
-    return get_exception("MissingContentTypeError")
+    return get_exception(f"MissingContentTypeError{prefix}")
 
 
-def get_schema_validation_error(exception: ValidationError) -> type[CheckFailed]:
+def get_schema_validation_error(prefix: str, exception: ValidationError) -> type[CheckFailed]:
     """Return new exception for schema validation error."""
-    return _get_hashed_exception("SchemaValidationError", str(exception))
+    return _get_hashed_exception(f"SchemaValidationError{prefix}", str(exception))
 
 
-def get_response_parsing_error(exception: JSONDecodeError) -> type[CheckFailed]:
+def get_response_parsing_error(prefix: str, exception: JSONDecodeError) -> type[CheckFailed]:
     """Return new exception for response parsing error."""
-    return _get_hashed_exception("ResponseParsingError", str(exception))
+    return _get_hashed_exception(f"ResponseParsingError{prefix}", str(exception))
 
 
-def get_headers_error(message: str) -> type[CheckFailed]:
+def get_headers_error(prefix: str, message: str) -> type[CheckFailed]:
     """Return new exception for missing headers."""
-    return _get_hashed_exception("MissingHeadersError", message)
+    return _get_hashed_exception(f"MissingHeadersError{prefix}", message)
+
+
+def get_negative_rejection_error(prefix: str, status: int) -> type[CheckFailed]:
+    return _get_hashed_exception(f"AcceptedNegativeDataError{prefix}", str(status))
+
+
+def get_use_after_free_error(free: str) -> type[CheckFailed]:
+    return _get_hashed_exception("UseAfterFreeError", free)
 
 
-def get_timeout_error(deadline: float | int) -> type[CheckFailed]:
+def get_timeout_error(prefix: str, deadline: float | int) -> type[CheckFailed]:
     """Request took too long."""
-    return _get_hashed_exception("TimeoutError", str(deadline))
+    return _get_hashed_exception(f"TimeoutError{prefix}", str(deadline))
 
 
 def get_unexpected_graphql_response_error(type_: type) -> type[CheckFailed]:
@@ -158,7 +169,7 @@ def get_grouped_graphql_error(errors: list[GraphQLFormattedError]) -> type[Check
         if "locations" in error:
             message += ";locations:"
             for location in sorted(error["locations"]):
-                message += f"({location['line'],location['column']})"
+                message += f"({location['line'], location['column']})"
         if "path" in error:
             message += ";path:"
             for chunk in error["path"]:
@@ -541,7 +552,7 @@ def remove_ssl_line_number(text: str) -> str:
 
 
 def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
-    from requests.exceptions import SSLError, ConnectionError, ChunkedEncodingError
+    from requests.exceptions import ChunkedEncodingError, ConnectionError, SSLError
     from urllib3.exceptions import MaxRetryError
 
     if isinstance(exc, SSLError):
@@ -552,11 +563,14 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
         message = "Connection failed"
         inner = exc.args[0]
         if isinstance(inner, MaxRetryError) and inner.reason is not None:
-            arg = str(inner.reason.args[0])
-            if ":" not in arg:
-                reason = arg
+            arg = inner.reason.args[0]
+            if isinstance(arg, str):
+                if ":" not in arg:
+                    reason = arg
+                else:
+                    _, reason = arg.split(":", maxsplit=1)
             else:
-                _, reason = arg.split(":", maxsplit=1)
+                reason = f"Max retries exceeded with url: {inner.url}"
             extra = [reason.strip()]
         else:
             extra = [" ".join(map(str, inner.args))]

schemathesis/experimental/__init__.py

@@ -79,3 +79,17 @@ SCHEMA_ANALYSIS = GLOBAL_EXPERIMENTS.create_experiment(
     description="Analyzing API schemas via Schemathesis.io",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/2056",
 )
+STATEFUL_TEST_RUNNER = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-test-runner",
+    verbose_name="New Stateful Test Runner",
+    env_var="STATEFUL_TEST_RUNNER",
+    description="State machine-based runner for stateful tests in CLI",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)
+STATEFUL_ONLY = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-only",
+    verbose_name="Stateful Only",
+    env_var="STATEFUL_ONLY",
+    description="Run only stateful tests",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)

schemathesis/extra/_aiohttp.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import asyncio
 
 from aiohttp import web

schemathesis/extra/_server.py

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

schemathesis/extra/pytest_plugin.py

@@ -3,19 +3,18 @@ from __future__ import annotations
 import unittest
 from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Generator, Type, TypeVar, cast
+from typing import Any, Callable, Generator, Type, cast
 
 import pytest
 from _pytest import fixtures, nodes
 from _pytest.config import hookimpl
 from _pytest.fixtures import FuncFixtureInfo
-from _pytest.nodes import Node
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
 from hypothesis import reporting
 from hypothesis.errors import InvalidArgument, Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
-from .._dependency_versions import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_8, IS_PYTEST_ABOVE_54
+from .._dependency_versions import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_8
 from .._override import get_override_from_mark
 from ..constants import (
     GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE,
@@ -43,14 +42,6 @@ from ..utils import (
     validate_given_args,
 )
 
-T = TypeVar("T", bound=Node)
-
-
-def create(cls: type[T], *args: Any, **kwargs: Any) -> T:
-    if IS_PYTEST_ABOVE_54:
-        return cls.from_parent(*args, **kwargs)  # type: ignore
-    return cls(*args, **kwargs)
-
 
 class SchemathesisFunction(Function):
     def __init__(
@@ -155,7 +146,9 @@ class SchemathesisCase(PyCollector):
                 name += f"[{error.full_path}]"
 
         cls = self._get_class_parent()
-        definition: FunctionDefinition = create(FunctionDefinition, name=self.name, parent=self.parent, callobj=funcobj)
+        definition: FunctionDefinition = FunctionDefinition.from_parent(
+            name=self.name, parent=self.parent, callobj=funcobj
+        )
         fixturemanager = self.session._fixturemanager
         fixtureinfo = fixturemanager.getfixtureinfo(definition, funcobj, cls)
 
@@ -166,8 +159,7 @@ class SchemathesisCase(PyCollector):
             funcobj = partial(funcobj, self.parent.obj)
 
         if not metafunc._calls:
-            yield create(
-                SchemathesisFunction,
+            yield SchemathesisFunction.from_parent(
                 name=name,
                 parent=self.parent,
                 callobj=funcobj,
@@ -181,10 +173,9 @@ class SchemathesisCase(PyCollector):
             fixtureinfo.prune_dependency_tree()
             for callspec in metafunc._calls:
                 subname = f"{name}[{callspec.id}]"
-                yield create(
-                    SchemathesisFunction,
+                yield SchemathesisFunction.from_parent(
+                    self.parent,
                     name=subname,
-                    parent=self.parent,
                     callspec=callspec,
                     callobj=funcobj,
                     fixtureinfo=fixtureinfo,
@@ -236,7 +227,7 @@ def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -
     """Switch to a different collector if the test is parametrized marked by schemathesis."""
     outcome = yield
     if is_schemathesis_test(obj):
-        outcome.force_result(create(SchemathesisCase, parent=collector, test_function=obj, name=name))
+        outcome.force_result(SchemathesisCase.from_parent(collector, test_function=obj, name=name))
     else:
         outcome.get_result()
 
@@ -261,7 +252,7 @@ def skip_unnecessary_hypothesis_output() -> Generator:
         yield
 
 
-@hookimpl(hookwrapper=True)
+@hookimpl(wrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.
 
@@ -278,10 +269,9 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
 
     __tracebackhide__ = True
     if isinstance(pyfuncitem, SchemathesisFunction):
-        with skip_unnecessary_hypothesis_output():
-            outcome = yield
         try:
-            outcome.get_result()
+            with skip_unnecessary_hypothesis_output():
+                yield
         except InvalidArgument as exc:
             if "Inconsistent args" in str(exc) and "@example()" in str(exc):
                 raise UsageError(GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE) from None
@@ -316,5 +306,4 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
     else:
-        outcome = yield
-        outcome.get_result()
+        yield

schemathesis/failures.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 import textwrap
 from dataclasses import dataclass
 from json import JSONDecodeError
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from graphql.error import GraphQLFormattedError
@@ -46,11 +47,19 @@ class ValidationErrorContext(FailureContext):
 
         schema = textwrap.indent(truncated_json(exc.schema, max_lines=20), prefix="    ")
         value = textwrap.indent(truncated_json(exc.instance, max_lines=20), prefix="    ")
-        message = f"{exc.message}\n\nSchema:\n\n{schema}\n\nValue:\n\n{value}"
+        schema_path = list(exc.absolute_schema_path)
+        if len(schema_path) > 1:
+            # Exclude the last segment, which is already in the schema
+            schema_title = "Schema at "
+            for segment in schema_path[:-1]:
+                schema_title += f"/{segment}"
+        else:
+            schema_title = "Schema"
+        message = f"{exc.message}\n\n{schema_title}:\n\n{schema}\n\nValue:\n\n{value}"
         return cls(
             message=message,
             validation_message=exc.message,
-            schema_path=list(exc.absolute_schema_path),
+            schema_path=schema_path,
             schema=exc.schema,
             instance_path=list(exc.absolute_path),
             instance=exc.instance,
@@ -117,6 +126,26 @@ class UndefinedContentType(FailureContext):
     type: str = "undefined_content_type"
 
 
+@dataclass(repr=False)
+class AcceptedNegativeData(FailureContext):
+    """Response with negative data was accepted."""
+
+    message: str
+    title: str = "Accepted negative data"
+    type: str = "accepted_negative_data"
+
+
+@dataclass(repr=False)
+class UseAfterFree(FailureContext):
+    """Resource was used after a successful DELETE operation on it."""
+
+    message: str
+    free: str
+    usage: str
+    title: str = "Use after free"
+    type: str = "use_after_free"
+
+
 @dataclass(repr=False)
 class UndefinedStatusCode(FailureContext):
     """Response has a status code that is not defined in the schema."""

schemathesis/filters.py

@@ -1,11 +1,12 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
 
 from __future__ import annotations
+
 import re
 from dataclasses import dataclass, field
 from functools import partial
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Callable, List, Union, Protocol
+from typing import TYPE_CHECKING, Callable, List, Protocol, Union
 
 from .exceptions import UsageError
 

schemathesis/fixups/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Iterable
 
 from . import fast_api, utf8_bom

schemathesis/fixups/fast_api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
+
 from typing import Any
 
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 from ..internal.jsonschema import traverse_schema
 
 

schemathesis/fixups/utf8_bom.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING
 
 from ..constants import BOM_MARK
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 
 if TYPE_CHECKING:
     from ..models import Case

schemathesis/generation/__init__.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 import random
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Union, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterable, Union
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy

schemathesis/hooks.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import inspect
 from collections import defaultdict
 from copy import deepcopy
@@ -7,11 +8,12 @@ from enum import Enum, unique
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
 
-from .types import GenericTest
 from .internal.deprecation import deprecated_property
+from .types import GenericTest
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
+
     from .models import APIOperation, Case
     from .schemas import BaseSchema
     from .transports.responses import GenericResponse

schemathesis/internal/copy.py

@@ -2,12 +2,28 @@ from typing import Any
 
 
 def fast_deepcopy(value: Any) -> Any:
-    """A specialized version of `deepcopy` that copies only `dict` and `list`.
+    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
 
     It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
     """
     if isinstance(value, dict):
-        return {key: fast_deepcopy(v) for key, v in value.items()}
+        return {
+            k1: (
+                {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+                if isinstance(v1, dict)
+                else [fast_deepcopy(v2) for v2 in v1]
+                if isinstance(v1, list)
+                else v1
+            )
+            for k1, v1 in value.items()
+        }
     if isinstance(value, list):
-        return [fast_deepcopy(v) for v in value]
+        return [
+            {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+            if isinstance(v1, dict)
+            else [fast_deepcopy(v2) for v2 in v1]
+            if isinstance(v1, list)
+            else v1
+            for v1 in value
+        ]
     return value

schemathesis/internal/deprecation.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import Callable, Any
+from typing import Any, Callable
 
 
 def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:

schemathesis/internal/jsonschema.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import overload, Dict, Union, Any, List, Callable
+
+from typing import Any, Callable, Dict, List, Union, overload
 
 JsonValue = Union[Dict[str, Any], List, str, float, int]
 

schemathesis/internal/result.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Generic, Union
+from typing import Generic, TypeVar, Union
 
 T = TypeVar("T")
 E = TypeVar("E", bound=Exception)

schemathesis/internal/transformation.py

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

schemathesis/lazy.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from inspect import signature
 from typing import Any, Callable, Generator
@@ -13,12 +14,12 @@ from pyrate_limiter import Limiter
 from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures, get_interesting_origin
-from ._override import check_no_override_mark, CaseOverride, set_override_mark, get_override_from_mark
+from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .generation import DataGenerationMethodInput, GenerationConfig
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
+from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.result import Ok
 from .models import APIOperation

schemathesis/loaders.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
+
 import re
 import sys
 from functools import lru_cache
-from typing import Callable, TypeVar, TYPE_CHECKING, TextIO, Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, TextIO, TypeVar
 
 from .exceptions import SchemaError, SchemaErrorType, extract_requests_exception_details
 
 if TYPE_CHECKING:
-    from .transports.responses import GenericResponse
     import yaml
 
+    from .transports.responses import GenericResponse
+
 R = TypeVar("R", bound="GenericResponse")
 
 

schemathesis/models.py

@@ -42,6 +42,7 @@ from .exceptions import (
     OperationSchemaError,
     SerializationNotPossible,
     SkipTest,
+    UsageError,
     deduplicate_failed_checks,
     get_grouped_exception,
     maybe_set_assertion_message,
@@ -54,7 +55,7 @@ from .internal.deprecation import deprecated_function, deprecated_property
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
 from .serializers import Serializer
-from .transports import ASGITransport, RequestsTransport, WSGITransport, serialize_payload, deserialize_payload
+from .transports import ASGITransport, RequestsTransport, WSGITransport, deserialize_payload, serialize_payload
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
 
 if TYPE_CHECKING:
@@ -271,13 +272,14 @@ class Case:
         final_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, self.id)
         return final_headers
 
-    def _get_serializer(self) -> Serializer | None:
+    def _get_serializer(self, media_type: str | None = None) -> Serializer | None:
         """Get a serializer for the payload, if there is any."""
-        if self.media_type is not None:
-            media_type = serializers.get_first_matching_media_type(self.media_type)
+        input_media_type = media_type or self.media_type
+        if input_media_type is not None:
+            media_type = serializers.get_first_matching_media_type(input_media_type)
             if media_type is None:
                 # This media type is set manually. Otherwise, it should have been rejected during the data generation
-                raise SerializationNotPossible.for_media_type(self.media_type)
+                raise SerializationNotPossible.for_media_type(input_media_type)
             # SAFETY: It is safe to assume that serializer will be found, because `media_type` returned above
             # is registered. This intentionally ignores cases with concurrent serializers registry modification.
             cls = cast(Type[serializers.Serializer], serializers.get(media_type))
@@ -694,6 +696,19 @@ class APIOperation(Generic[P, C]):
     def get_request_payload_content_types(self) -> list[str]:
         return self.schema.get_request_payload_content_types(self)
 
+    def _get_default_media_type(self) -> str:
+        # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
+        media_types = self.get_request_payload_content_types()
+        if len(media_types) == 1:
+            # The only available option
+            return media_types[0]
+        media_types_repr = ", ".join(media_types)
+        raise UsageError(
+            "Can not detect appropriate media type. "
+            "You can either specify one of the defined media types "
+            f"or pass any other media type available for serialization. Defined media types: {media_types_repr}"
+        )
+
     def partial_deepcopy(self) -> APIOperation:
         return self.__class__(
             path=self.path,  # string, immutable

schemathesis/parameters.py

@@ -4,6 +4,7 @@ These are basic entities that describe what data could be sent to the API.
 """
 
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar
 

schemathesis/runner/__init__.py

@@ -28,10 +28,10 @@ if TYPE_CHECKING:
 
     from ..models import CheckFunction
     from ..schemas import BaseSchema
+    from ..service.client import ServiceClient
     from ..stateful import Stateful
     from . import events
     from .impl import BaseRunner
-    from ..service.client import ServiceClient
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")

schemathesis/runner/events.py

@@ -1,21 +1,22 @@
 from __future__ import annotations
+
 import enum
 import threading
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
+from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
 from ..internal.result import Result
-from ..generation import DataGenerationMethod
-from ..exceptions import SchemaError, SchemaErrorType, format_exception, RuntimeErrorType
 from .serialization import SerializedError, SerializedTestResult
 
-
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema
     from ..service.models import AnalysisResult
+    from ..stateful import events
     from . import probes
 
 
@@ -287,6 +288,22 @@ class InternalError(ExecutionEvent):
         )
 
 
+@dataclass
+class StatefulEvent(ExecutionEvent):
+    """Represents an event originating from the state machine runner."""
+
+    data: events.StatefulEvent
+
+    __slots__ = ("data",)
+
+
+@dataclass
+class AfterStatefulExecution(ExecutionEvent):
+    """Happens after the stateful test run."""
+
+    result: SerializedTestResult
+
+
 @dataclass
 class Finished(ExecutionEvent):
     """The final event of the run.