schemathesis 3.30.4__tar.gz → 3.31.0__tar.gz

{schemathesis-3.30.4 → schemathesis-3.31.0}/.pre-commit-config.yaml

@@ -30,7 +30,7 @@ repos:
       - id: relint
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.10.0
+    rev: v1.10.1
     hooks:
       - id: mypy
         exclude: ^(docs/|test/|test-corpus/|example/|benches/).*$
@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.10
+    rev: v0.5.0
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.10
+    rev: v0.5.0
     hooks:
       - id: ruff
 

{schemathesis-3.30.4 → schemathesis-3.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.30.4
+Version: 3.31.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html
@@ -31,6 +31,7 @@ Requires-Python: >=3.8
 Requires-Dist: backoff<3.0,>=2.1.2
 Requires-Dist: click<9.0,>=7.0
 Requires-Dist: colorama<1.0,>=0.4
+Requires-Dist: harfile<1.0,>=0.3.0
 Requires-Dist: httpx<1.0,>=0.22.0
 Requires-Dist: hypothesis-graphql<1,>=0.11.0
 Requires-Dist: hypothesis-jsonschema<0.24,>=0.23.1

{schemathesis-3.30.4 → schemathesis-3.31.0}/docs/changelog.rst

@@ -1,9 +1,26 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.30.4...HEAD>` - TBD
+:version:`Unreleased <v3.31.0...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.31.0:
+
+:version:`3.31.0 <v3.30.4...v3.31.0>` - 2024-06-30
+--------------------------------------------------
+
+**Added**
+
+- Storing cassettes in the HAR format via the ``--cassette-format=har`` CLI option. :issue:`2299`
+- Support for cassettes in the new-style stateful test runner.
+- ``--generation-with-security-parameters=false`` CLI option to disable generation of security parameters (like tokens) in test cases.
+
+**Fixed**
+
+- Incorrect test case ids stored in VCR cassettes. :issue:`2302`
+- Incorrect reference resolution scope for security schemes if the API operation has a different scope than the global security schemes. :issue:`2300`
+- Properly display unresolvable reference if it comes from a missing file.
+
 .. _v3.30.4:
 
 :version:`3.30.4 <v3.30.3...v3.30.4>` - 2024-06-28

{schemathesis-3.30.4 → schemathesis-3.31.0}/docs/cli.rst

@@ -291,8 +291,43 @@ Schemathesis allows you to do this with the ``--cassette-path`` command-line opt
 
     $ st run --cassette-path cassette.yaml http://127.0.0.1/schema.yaml
 
-This command will create a new YAML file that will network interactions in `VCR format <https://relishapp.com/vcr/vcr/v/5-1-0/docs/cassettes/cassette-format>`_.
-It might look like this:
+Schemathesis supports `VCR <https://relishapp.com/vcr/vcr/v/5-1-0/docs/cassettes/cassette-format>`_ and `HAR <http://www.softwareishard.com/blog/har-12-spec/>`_ formats and stores all network interactions in a YAML file.
+
+HAR format
+~~~~~~~~~~
+
+HTTP Archive (HAR) is a JSON-based format used for tracking HTTP requests and responses. Schemathesis uses a simplified version of this format that does not include page-related information:
+
+.. code:: json
+
+    {
+        "log": {
+            "version": "1.2",
+            "creator": {
+                "name": "harfile",
+                "version": "0.2.0"
+            },
+            "browser": {
+                "name": "",
+                "version": ""
+            },
+            "entries": [
+                {
+                    "startedDateTime": "2024-06-29T20:10:29.254107+02:00",
+                    "time": 0.88,
+                    "request": {"method": "GET", "url": "http://127.0.0.1:8081/api/basic", "httpVersion": "HTTP/1.1", "cookies": [], "headers": [{"name": "User-Agent", "value": "schemathesis/3.30.4"}, {"name": "Accept-Encoding", "value": "gzip, deflate"}, {"name": "Accept", "value": "*/*"}, {"name": "Connection", "value": "keep-alive"}, {"name": "Authorization", "value": "[Filtered]"}, {"name": "X-Schemathesis-TestCaseId", "value": "ScU88H"}], "queryString": [], "headersSize": 164, "bodySize": 0},
+                    "response": {"status": 401, "statusText": "Unauthorized", "httpVersion": "HTTP/1.1", "cookies": [], "headers": [{"name": "Content-Type", "value": "application/json; charset=utf-8"}, {"name": "Content-Length", "value": "26"}, {"name": "Date", "value": "Sat, 29 Jun 2024 18:10:29 GMT"}, {"name": "Server", "value": "Python/3.11 aiohttp/3.9.3"}], "content": {"size": 26, "mimeType": "application/json; charset=utf-8", "text": "{\"detail\": \"Unauthorized\"}"}, "redirectURL": "", "headersSize": 139, "bodySize": 26},
+                    "timings": {"send": 0, "wait": 0, "receive": 0.88, "blocked": 0, "dns": 0, "connect": 0, "ssl": 0},
+                    "cache": {}
+                },
+                {
+
+To view the content of a HAR file, you can use this `HAR viewer <http://www.softwareishard.com/har/viewer/>`_.
+
+VCR format
+~~~~~~~~~~
+
+The content of a VCR cassette looks like this:
 
 .. code:: yaml
 

{schemathesis-3.30.4 → schemathesis-3.31.0}/docs/recipes.rst

@@ -79,3 +79,44 @@ Different API operations may need different timeouts during testing. You could a
         case.call_and_validate(timeout=timeout)
 
 In the example above, the default timeout is 10 seconds, but for `GET /users` it will be 5 seconds.
+
+Generating only required parameters
+-----------------------------------
+
+Sometimes you don't need to generate all parameters for your API, and want to limit Schemathesis to only required ones.
+You can do it with the following hook:
+
+.. code-block:: python
+
+    import schemathesis
+
+
+    @schemathesis.hook
+    def before_init_operation(context, operation):
+        for parameter in operation.iter_parameters():
+            schema = parameter.definition.get("schema", {})
+            traverse_schema(schema, drop_optional_properties)
+        for alternative in operation.body:
+            schema = alternative.definition.get("schema", {})
+            traverse_schema(schema, drop_optional_properties)
+
+
+    def traverse_schema(schema, callback):
+        if isinstance(schema, dict):
+            schema = callback(schema)
+            for key, sub_item in schema.items():
+                schema[key] = traverse_schema(sub_item, callback)
+        elif isinstance(schema, list):
+            schema = [traverse_schema(sub_item, callback) for sub_item in schema]
+        return schema
+
+
+    def drop_optional_properties(schema):
+        required = schema.get("required", [])
+        properties = schema.get("properties", {})
+        for name in list(properties):
+            if name not in required:
+                del properties[name]
+        return schema
+
+This hook will remove all optional properties from the parsed API operations.

{schemathesis-3.30.4 → schemathesis-3.31.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.30.4"
+version = "3.31.0"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]
@@ -34,6 +34,7 @@ dependencies = [
     "backoff>=2.1.2,<3.0",
     "click>=7.0,<9.0",
     "colorama>=0.4,<1.0",
+    "harfile>=0.3.0,<1.0",
     "httpx>=0.22.0,<1.0",
     "hypothesis>=6.103.4,<7; python_version > '3.8'",
     "hypothesis[zoneinfo]>=6.103.4,<7; python_version == '3.8'",

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/cli/__init__.py

@@ -522,6 +522,13 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     type=click.File("w", encoding="utf-8"),
     is_eager=True,
 )
+@click.option(
+    "--cassette-format",
+    help="Format of the saved cassettes.",
+    type=click.Choice([item.name.lower() for item in cassettes.CassetteFormat]),
+    default=cassettes.CassetteFormat.VCR.name.lower(),
+    callback=callbacks.convert_cassette_format,
+)
 @click.option(
     "--cassette-preserve-exact-body-bytes",
     help="Retains exact byte sequence of payloads in cassettes, encoded as base64.",
@@ -718,6 +725,14 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     default="utf-8",
     callback=callbacks.validate_generation_codec,
 )
+@click.option(
+    "--generation-with-security-parameters",
+    help="Whether to generate security parameters.",
+    type=str,
+    default="true",
+    show_default=True,
+    callback=callbacks.convert_boolean_string,
+)
 @click.option(
     "--schemathesis-io-token",
     help="Schemathesis.io authentication token.",
@@ -783,6 +798,7 @@ def run(
     show_trace: bool = False,
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default(),
     cassette_path: click.utils.LazyFile | None = None,
+    cassette_format: cassettes.CassetteFormat = cassettes.CassetteFormat.VCR,
     cassette_preserve_exact_body_bytes: bool = False,
     store_network_log: click.utils.LazyFile | None = None,
     wait_for_schema: float | None = None,
@@ -810,6 +826,7 @@ def run(
     no_color: bool = False,
     report_value: str | None = None,
     generation_allow_x00: bool = True,
+    generation_with_security_parameters: bool = True,
     generation_codec: str = "utf-8",
     schemathesis_io_token: str | None = None,
     schemathesis_io_url: str = service.DEFAULT_URL,
@@ -849,7 +866,11 @@ def run(
 
     override = CaseOverride(query=set_query, headers=set_header, cookies=set_cookie, path_parameters=set_path)
 
-    generation_config = generation.GenerationConfig(allow_x00=generation_allow_x00, codec=generation_codec)
+    generation_config = generation.GenerationConfig(
+        allow_x00=generation_allow_x00,
+        codec=generation_codec,
+        with_security_parameters=generation_with_security_parameters,
+    )
 
     report: ReportToService | click.utils.LazyFile | None
     if report_value is None:
@@ -1006,6 +1027,7 @@ def run(
         wait_for_schema=wait_for_schema,
         validate_schema=validate_schema,
         cassette_path=cassette_path,
+        cassette_format=cassette_format,
         cassette_preserve_exact_body_bytes=cassette_preserve_exact_body_bytes,
         junit_xml=junit_xml,
         verbosity=verbosity,
@@ -1387,6 +1409,7 @@ def execute(
     wait_for_schema: float | None,
     validate_schema: bool,
     cassette_path: click.utils.LazyFile | None,
+    cassette_format: cassettes.CassetteFormat,
     cassette_preserve_exact_body_bytes: bool,
     junit_xml: click.utils.LazyFile | None,
     verbosity: int,
@@ -1449,7 +1472,9 @@ def execute(
         # This handler should be first to have logs writing completed when the output handler will display statistic
         _open_file(cassette_path)
         handlers.append(
-            cassettes.CassetteWriter(cassette_path, preserve_exact_body_bytes=cassette_preserve_exact_body_bytes)
+            cassettes.CassetteWriter(
+                cassette_path, format=cassette_format, preserve_exact_body_bytes=cassette_preserve_exact_body_bytes
+            )
         )
     handlers.append(get_output_handler(workers_num))
     if sanitize_output:

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/cli/callbacks.py

@@ -24,6 +24,7 @@ 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 .cassettes import CassetteFormat
 from .constants import DEFAULT_WORKERS
 
 if TYPE_CHECKING:
@@ -344,6 +345,10 @@ def convert_code_sample_style(ctx: click.core.Context, param: click.core.Paramet
     return CodeSampleStyle.from_str(value)
 
 
+def convert_cassette_format(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CassetteFormat:
+    return CassetteFormat.from_str(value)
+
+
 def convert_data_generation_method(
     ctx: click.core.Context, param: click.core.Parameter, value: str
 ) -> list[DataGenerationMethod]:

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/cli/cassettes.py

@@ -1,13 +1,18 @@
 from __future__ import annotations
 
 import base64
+import enum
 import json
 import re
 import sys
 import threading
 from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
 from queue import Queue
-from typing import IO, TYPE_CHECKING, Any, Generator, Iterator, cast
+from typing import IO, TYPE_CHECKING, Any, Callable, Generator, Iterator, cast
+from urllib.parse import parse_qsl, urlparse
+
+import harfile
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
@@ -27,6 +32,23 @@ if TYPE_CHECKING:
 WRITER_WORKER_JOIN_TIMEOUT = 1
 
 
+class CassetteFormat(str, enum.Enum):
+    """Type of the cassette."""
+
+    VCR = "vcr"
+    HAR = "har"
+
+    @classmethod
+    def from_str(cls, value: str) -> CassetteFormat:
+        try:
+            return cls[value.upper()]
+        except KeyError:
+            available_formats = ", ".join(cls)
+            raise ValueError(
+                f"Invalid value for cassette format: {value}. Available formats: {available_formats}"
+            ) from None
+
+
 @dataclass
 class CassetteWriter(EventHandler):
     """Write interactions in a YAML cassette.
@@ -36,26 +58,30 @@ class CassetteWriter(EventHandler):
     """
 
     file_handle: click.utils.LazyFile
+    format: CassetteFormat
     preserve_exact_body_bytes: bool
     queue: Queue = field(default_factory=Queue)
     worker: threading.Thread = field(init=False)
 
     def __post_init__(self) -> None:
-        self.worker = threading.Thread(
-            target=worker,
-            kwargs={
-                "file_handle": self.file_handle,
-                "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
-                "queue": self.queue,
-            },
-        )
+        kwargs = {
+            "file_handle": self.file_handle,
+            "queue": self.queue,
+            "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
+        }
+        writer: Callable
+        if self.format == CassetteFormat.HAR:
+            writer = har_writer
+        else:
+            writer = vcr_writer
+        self.worker = threading.Thread(name="SchemathesisCassetteWriter", target=writer, kwargs=kwargs)
         self.worker.start()
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.Initialized):
             # In the beginning we write metadata and start `http_interactions` list
             self.queue.put(Initialize())
-        if isinstance(event, events.AfterExecution):
+        elif isinstance(event, events.AfterExecution):
             # Seed is always present at this point, the original Optional[int] type is there because `TestResult`
             # instance is created before `seed` is generated on the hypothesis side
             seed = cast(int, event.result.seed)
@@ -71,7 +97,19 @@ class CassetteWriter(EventHandler):
                     interactions=event.result.interactions,
                 )
             )
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.AfterStatefulExecution):
+            seed = cast(int, event.result.seed)
+            self.queue.put(
+                Process(
+                    seed=seed,
+                    # Correlation ID is not used in stateful testing
+                    correlation_id="",
+                    thread_id=event.thread_id,
+                    data_generation_method=event.data_generation_method[0],
+                    interactions=event.result.interactions,
+                )
+            )
+        elif isinstance(event, events.Finished):
             self.shutdown()
 
     def shutdown(self) -> None:
@@ -112,7 +150,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
     """Write YAML to a file in an incremental manner.
 
     This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
@@ -278,6 +316,106 @@ def write_double_quoted(stream: IO, text: str) -> None:
     stream.write('"')
 
 
+def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+    if preserve_exact_body_bytes:
+
+        def get_body(body: str) -> str:
+            return body
+    else:
+
+        def get_body(body: str) -> str:
+            return base64.b64decode(body).decode("utf-8", errors="replace")
+
+    with harfile.open(file_handle) as har:
+        while True:
+            item = queue.get()
+            if isinstance(item, Process):
+                for interaction in item.interactions:
+                    time = round(interaction.response.elapsed * 1000, 2)
+                    content_type = interaction.response.headers.get("Content-Type", [""])[0]
+                    content = harfile.Content(
+                        size=interaction.response.body_size or 0,
+                        mimeType=content_type,
+                        text=get_body(interaction.response.body) if interaction.response.body is not None else None,
+                        encoding="base64"
+                        if interaction.response.body is not None and preserve_exact_body_bytes
+                        else None,
+                    )
+                    http_version = f"HTTP/{interaction.response.http_version}"
+                    query_params = urlparse(interaction.request.uri).query
+                    if interaction.request.body is not None:
+                        post_data = harfile.PostData(
+                            mimeType=content_type,
+                            text=get_body(interaction.request.body),
+                        )
+                    else:
+                        post_data = None
+                    har.add_entry(
+                        startedDateTime=interaction.recorded_at,
+                        time=time,
+                        request=harfile.Request(
+                            method=interaction.request.method.upper(),
+                            url=interaction.request.uri,
+                            httpVersion=http_version,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.request.headers.items()
+                            ],
+                            queryString=[
+                                harfile.Record(name=name, value=value)
+                                for name, value in parse_qsl(query_params, keep_blank_values=True)
+                            ],
+                            cookies=_extract_cookies(interaction.request.headers.get("Cookie", [])),
+                            headersSize=_headers_size(interaction.request.headers),
+                            bodySize=interaction.request.body_size or 0,
+                            postData=post_data,
+                        ),
+                        response=harfile.Response(
+                            status=interaction.response.status_code,
+                            httpVersion=http_version,
+                            statusText=interaction.response.message,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.response.headers.items()
+                            ],
+                            cookies=_extract_cookies(interaction.response.headers.get("Set-Cookie", [])),
+                            content=content,
+                            headersSize=_headers_size(interaction.response.headers),
+                            bodySize=interaction.response.body_size or 0,
+                            redirectURL=interaction.response.headers.get("Location", [""])[0],
+                        ),
+                        timings=harfile.Timings(send=0, wait=0, receive=time, blocked=0, dns=0, connect=0, ssl=0),
+                    )
+            elif isinstance(item, Finalize):
+                break
+
+
+def _headers_size(headers: dict[str, list[str]]) -> int:
+    size = 0
+    for name, values in headers.items():
+        # 4 is for ": " and "\r\n"
+        size += len(name) + 4 + len(values[0])
+    return size
+
+
+def _extract_cookies(headers: list[str]) -> list[harfile.Cookie]:
+    return [cookie for items in headers for item in items for cookie in _cookie_to_har(item)]
+
+
+def _cookie_to_har(cookie: str) -> Iterator[harfile.Cookie]:
+    parsed = SimpleCookie(cookie)
+    for name, data in parsed.items():
+        yield harfile.Cookie(
+            name=name,
+            value=data.value,
+            path=data["path"] or None,
+            domain=data["domain"] or None,
+            expires=data["expires"] or None,
+            httpOnly=data["httponly"] or None,
+            secure=data["secure"] or None,
+        )
+
+
 @dataclass
 class Replayed:
     interaction: dict[str, Any]

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/exceptions.py

@@ -222,9 +222,11 @@ class OperationSchemaError(Exception):
     def from_reference_resolution_error(
         cls, error: RefResolutionError, path: str | None, method: str | None, full_path: str | None
     ) -> OperationSchemaError:
+        notes = getattr(error, "__notes__", [])
+        # Some exceptions don't have the actual reference in them, hence we add it manually via notes
+        pointer = f"'{notes[0]}'"
         message = "Unresolvable JSON pointer in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
-        pointer = str(error).split(": ", 1)[-1]
         message += f"\n\nError details:\n    JSON pointer: {pointer}"
         message += "\n    This typically means that the schema is referencing a component that doesn't exist."
         message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/generation/__init__.py

@@ -77,5 +77,7 @@ class GenerationConfig:
     allow_x00: bool = True
     # Generate strings using the given codec
     codec: str | None = "utf-8"
+    # Whether to generate security parameters
+    with_security_parameters: bool = True
     # Header generation configuration
     headers: HeaderConfig = field(default_factory=HeaderConfig)

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/models.py

@@ -492,6 +492,7 @@ class Case:
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
             generation_time=self.generation_time,
+            id=self.id,
         )
 
 
@@ -831,6 +832,7 @@ class Request:
     method: str
     uri: str
     body: str | None
+    body_size: int | None
     headers: Headers
 
     @classmethod
@@ -861,6 +863,7 @@ class Request:
             method=method,
             headers={key: [value] for (key, value) in prepared.headers.items()},
             body=serialize_payload(body) if body is not None else body,
+            body_size=len(body) if body is not None else None,
         )
 
     def deserialize_body(self) -> bytes | None:
@@ -880,6 +883,7 @@ class Response:
     message: str
     headers: dict[str, list[str]]
     body: str | None
+    body_size: int | None
     encoding: str | None
     http_version: str
     elapsed: float
@@ -906,6 +910,7 @@ class Response:
             status_code=response.status_code,
             message=response.reason,
             body=body,
+            body_size=len(response.content) if body is not None else None,
             encoding=response.encoding,
             headers=headers,
             http_version=http_version,
@@ -933,6 +938,7 @@ class Response:
             status_code=response.status_code,
             message=message,
             body=body,
+            body_size=len(data) if body is not None else None,
             encoding=encoding,
             headers=headers,
             http_version="1.1",
@@ -949,6 +955,9 @@ class Response:
         return deserialize_payload(self.body)
 
 
+TIMEZONE = datetime.datetime.now(datetime.timezone.utc).astimezone().tzinfo
+
+
 @dataclass
 class Interaction:
     """A single interaction with the target app."""
@@ -958,7 +967,7 @@ class Interaction:
     checks: list[Check]
     status: Status
     data_generation_method: DataGenerationMethod
-    recorded_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat())
+    recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
     def from_requests(cls, case: Case, response: requests.Response, status: Status, checks: list[Check]) -> Interaction:

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/runner/events.py

@@ -303,6 +303,8 @@ class AfterStatefulExecution(ExecutionEvent):
 
     status: Status
     result: SerializedTestResult
+    data_generation_method: list[DataGenerationMethod]
+    thread_id: int = field(default_factory=threading.get_ident)
 
 
 @dataclass

{schemathesis-3.30.4 → schemathesis-3.31.0}/src/schemathesis/runner/impl/core.py

@@ -236,12 +236,54 @@ class BaseRunner:
             state_machine = self.schema.as_state_machine()
             runner = state_machine.runner(config=config)
             status = Status.success
+
+            def from_step_status(step_status: stateful_events.StepStatus) -> Status:
+                return {
+                    stateful_events.StepStatus.SUCCESS: Status.success,
+                    stateful_events.StepStatus.FAILURE: Status.failure,
+                    stateful_events.StepStatus.ERROR: Status.error,
+                    stateful_events.StepStatus.INTERRUPTED: Status.error,
+                }[step_status]
+
+            if self.store_interactions:
+                if isinstance(state_machine.schema.transport, RequestsTransport):
+
+                    def on_step_finished(event: stateful_events.StepFinished) -> None:
+                        if event.response is not None:
+                            response = cast(requests.Response, event.response)
+                            result.store_requests_response(
+                                status=from_step_status(event.status),
+                                case=event.case,
+                                response=response,
+                                checks=event.checks,
+                            )
+
+                else:
+
+                    def on_step_finished(event: stateful_events.StepFinished) -> None:
+                        if event.response is not None:
+                            response = cast(WSGIResponse, event.response)
+                            result.store_wsgi_response(
+                                status=from_step_status(event.status),
+                                case=event.case,
+                                response=response,
+                                headers=self.headers or {},
+                                elapsed=response.elapsed.total_seconds(),
+                                checks=event.checks,
+                            )
+            else:
+
+                def on_step_finished(event: stateful_events.StepFinished) -> None:
+                    return None
+
             for stateful_event in runner.execute():
                 if isinstance(stateful_event, stateful_events.SuiteFinished):
                     if stateful_event.failures and status != Status.error:
                         status = Status.failure
                     for failure in stateful_event.failures:
                         result.checks.append(failure)
+                elif isinstance(stateful_event, stateful_events.StepFinished):
+                    on_step_finished(stateful_event)
                 elif isinstance(stateful_event, stateful_events.Errored):
                     status = Status.error
                 yield events.StatefulEvent(data=stateful_event)
@@ -249,6 +291,7 @@ class BaseRunner:
             yield events.AfterStatefulExecution(
                 status=status,
                 result=SerializedTestResult.from_test_result(result),
+                data_generation_method=self.schema.data_generation_methods,
             )
 
     def _run_tests(