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

schemathesis/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import datetime
 import inspect
 import textwrap
@@ -6,9 +7,8 @@ from collections import Counter
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum
-from functools import partial, lru_cache
+from functools import lru_cache, partial
 from itertools import chain
-from logging import LogRecord
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -16,60 +16,71 @@ from typing import (
     Generator,
     Generic,
     Iterator,
+    Literal,
     NoReturn,
-    Optional,
     Sequence,
     Type,
     TypeVar,
     cast,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
-
-from urllib3.exceptions import ReadTimeoutError
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
-from . import failures, serializers
+from . import serializers
 from ._dependency_versions import IS_WERKZEUG_ABOVE_3
-from .auths import AuthStorage
+from ._override import CaseOverride
 from .code_samples import CodeSampleStyle
-from .generation import DataGenerationMethod, GenerationConfig
 from .constants import (
-    DEFAULT_RESPONSE_TIMEOUT,
+    NOT_SET,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SERIALIZERS_SUGGESTION_MESSAGE,
     USER_AGENT,
-    NOT_SET,
 )
 from .exceptions import (
-    maybe_set_assertion_message,
     CheckFailed,
-    FailureContext,
     OperationSchemaError,
     SerializationNotPossible,
+    SkipTest,
+    UsageError,
     deduplicate_failed_checks,
     get_grouped_exception,
-    get_timeout_error,
-    prepare_response_payload,
-    SkipTest,
+    maybe_set_assertion_message,
 )
-from .internal.deprecation import deprecated_property
-from .internal.copy import fast_deepcopy
+from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.checks import CheckContext
+from .internal.copy import fast_deepcopy
+from .internal.deprecation import deprecated_function, deprecated_property
+from .internal.diff import diff
+from .internal.output import prepare_response_payload
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
-from .serializers import Serializer, SerializerContext
-from .transports import serialize_payload
+from .transports import ASGITransport, RequestsTransport, WSGITransport, deserialize_payload, serialize_payload
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
-from .generation import generate_random_case_id
 
 if TYPE_CHECKING:
-    import werkzeug
     import unittest
-    from requests.structures import CaseInsensitiveDict
-    from hypothesis import strategies as st
+    from logging import LogRecord
+
     import requests.auth
-    from .transports.responses import GenericResponse, WSGIResponse
+    import werkzeug
+    from hypothesis import strategies as st
+    from requests.structures import CaseInsensitiveDict
+
+    from .auths import AuthStorage
+    from .failures import FailureContext
+    from .internal.checks import CheckFunction
     from .schemas import BaseSchema
+    from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
+    from .transports.responses import GenericResponse, WSGIResponse
+
+
+@dataclass
+class TransitionId:
+    name: str
+    status_code: str
+
+    __slots__ = ("name", "status_code")
 
 
 @dataclass
@@ -79,14 +90,22 @@ class CaseSource:
     case: Case
     response: GenericResponse
     elapsed: float
+    overrides_all_parameters: bool
+    transition_id: TransitionId
 
     def partial_deepcopy(self) -> CaseSource:
-        return self.__class__(case=self.case.partial_deepcopy(), response=self.response, elapsed=self.elapsed)
+        return self.__class__(
+            case=self.case.partial_deepcopy(),
+            response=self.response,
+            elapsed=self.elapsed,
+            overrides_all_parameters=self.overrides_all_parameters,
+            transition_id=self.transition_id,
+        )
 
 
 def cant_serialize(media_type: str) -> NoReturn:  # type: ignore
     """Reject the current example if we don't know how to send this data to the application."""
-    from hypothesis import note, event, reject
+    from hypothesis import event, note, reject
 
     event_text = f"Can't serialize data to `{media_type}`."
     note(f"{event_text} {SERIALIZERS_SUGGESTION_MESSAGE}")
@@ -120,11 +139,51 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
+class TestPhase(str, Enum):
+    __test__ = False
+
+    EXPLICIT = "explicit"
+    COVERAGE = "coverage"
+    GENERATE = "generate"
+
+
+@dataclass
+class GenerationMetadata:
+    """Stores various information about how data is generated."""
+
+    query: DataGenerationMethod | None
+    path_parameters: DataGenerationMethod | None
+    headers: DataGenerationMethod | None
+    cookies: DataGenerationMethod | None
+    body: DataGenerationMethod | None
+    phase: TestPhase
+    # Temporary attributes to carry info specific to the coverage phase
+    description: str | None
+    location: str | None
+    parameter: str | None
+    parameter_location: str | None
+
+    __slots__ = (
+        "query",
+        "path_parameters",
+        "headers",
+        "cookies",
+        "body",
+        "phase",
+        "description",
+        "location",
+        "parameter",
+        "parameter_location",
+    )
+
+
 @dataclass(repr=False)
 class Case:
     """A single test case parameters."""
 
     operation: APIOperation
+    # Time spent on generation of this test case
+    generation_time: float
     # Unique test case identifier
     id: str = field(default_factory=generate_random_case_id, compare=False)
     path_parameters: PathParameters | None = None
@@ -138,9 +197,33 @@ class Case:
     media_type: str | None = None
     source: CaseSource | None = None
 
+    meta: GenerationMetadata | None = None
+
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None
+    _has_explicit_auth: bool = False
+    _explicit_method: str | None = None
+
+    def __post_init__(self) -> None:
+        self._original_path_parameters = self.path_parameters.copy() if self.path_parameters else None
+        self._original_headers = self.headers.copy() if self.headers else None
+        self._original_cookies = self.cookies.copy() if self.cookies else None
+        self._original_query = self.query.copy() if self.query else None
+
+    def _has_generated_component(self, name: str) -> bool:
+        assert name in ["path_parameters", "headers", "cookies", "query"]
+        if self.meta is None:
+            return False
+        return getattr(self.meta, name) is not None
+
+    def _get_diff(self, component: Literal["path_parameters", "headers", "query", "cookies"]) -> dict[str, Any]:
+        original = getattr(self, f"_original_{component}")
+        current = getattr(self, component)
+        if not (current and original):
+            return {}
+        original_value = original if self._has_generated_component(component) else {}
+        return diff(original_value, current)
 
     def __repr__(self) -> str:
         parts = [f"{self.__class__.__name__}("]
@@ -158,7 +241,18 @@ class Case:
     def __hash__(self) -> int:
         return hash(self.as_curl_command({SCHEMATHESIS_TEST_CASE_HEADER: "0"}))
 
-    @deprecated_property(removed_in="4.0", replacement="operation")
+    @property
+    def _override(self) -> CaseOverride:
+        return CaseOverride(
+            path_parameters=self._get_diff("path_parameters"),
+            headers=self._get_diff("headers"),
+            query=self._get_diff("query"),
+            cookies=self._get_diff("cookies"),
+        )
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    @deprecated_property(removed_in="4.0", replacement="`operation`")
     def endpoint(self) -> APIOperation:
         return self.operation
 
@@ -172,7 +266,7 @@ class Case:
 
     @property
     def method(self) -> str:
-        return self.operation.method.upper()
+        return self._explicit_method.upper() if self._explicit_method else self.operation.method.upper()
 
     @property
     def base_url(self) -> str | None:
@@ -182,8 +276,21 @@ class Case:
     def app(self) -> Any:
         return self.operation.app
 
-    def set_source(self, response: GenericResponse, case: Case, elapsed: float) -> None:
-        self.source = CaseSource(case=case, response=response, elapsed=elapsed)
+    def set_source(
+        self,
+        response: GenericResponse,
+        case: Case,
+        elapsed: float,
+        overrides_all_parameters: bool,
+        transition_id: TransitionId,
+    ) -> None:
+        self.source = CaseSource(
+            case=case,
+            response=response,
+            elapsed=elapsed,
+            overrides_all_parameters=overrides_all_parameters,
+            transition_id=transition_id,
+        )
 
     @property
     def formatted_path(self) -> str:
@@ -208,7 +315,7 @@ class Case:
 
     def prepare_code_sample_data(self, headers: dict[str, Any] | None) -> PreparedRequestData:
         base_url = self.get_full_base_url()
-        kwargs = self.as_requests_kwargs(base_url, headers=headers)
+        kwargs = RequestsTransport().serialize_case(self, base_url=base_url, headers=headers)
         return prepare_request_data(kwargs)
 
     def get_code_to_reproduce(
@@ -271,53 +378,31 @@ 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))
             return cls()
         return None
 
+    def _get_body(self) -> Body | NotSet:
+        return self.body
+
+    @deprecated_function(removed_in="4.0", replacement="Case.as_transport_kwargs")
     def as_requests_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
         """Convert the case into a dictionary acceptable by requests."""
-        final_headers = self._get_headers(headers)
-        if self.media_type and self.media_type != "multipart/form-data" and not isinstance(self.body, NotSet):
-            # `requests` will handle multipart form headers with the proper `boundary` value.
-            if "content-type" not in {header.lower() for header in final_headers}:
-                final_headers["Content-Type"] = self.media_type
-        base_url = self._get_base_url(base_url)
-        formatted_path = self.formatted_path.lstrip("/")
-        if not base_url.endswith("/"):
-            base_url += "/"
-        url = unquote(urljoin(base_url, quote(formatted_path)))
-        extra: dict[str, Any]
-        serializer = self._get_serializer()
-        if serializer is not None and not isinstance(self.body, NotSet):
-            context = SerializerContext(case=self)
-            extra = serializer.as_requests(context, self.body)
-        else:
-            extra = {}
-        if self._auth is not None:
-            extra["auth"] = self._auth
-        additional_headers = extra.pop("headers", None)
-        if additional_headers:
-            # Additional headers, needed for the serializer
-            for key, value in additional_headers.items():
-                final_headers.setdefault(key, value)
-        return {
-            "method": self.method,
-            "url": url,
-            "cookies": self.cookies,
-            "headers": final_headers,
-            "params": self.query,
-            **extra,
-        }
+        return RequestsTransport().serialize_case(self, base_url=base_url, headers=headers)
+
+    def as_transport_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
+        """Convert the test case into a dictionary acceptable by the underlying transport call."""
+        return self.operation.schema.transport.serialize_case(self, base_url=base_url, headers=headers)
 
     def call(
         self,
@@ -327,83 +412,21 @@ class Case:
         params: dict[str, Any] | None = None,
         cookies: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> requests.Response:
-        import requests
-
-        """Make a network call with `requests`."""
+    ) -> GenericResponse:
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self)
-        data = self.as_requests_kwargs(base_url, headers)
-        data.update(kwargs)
-        if params is not None:
-            _merge_dict_to(data, "params", params)
-        if cookies is not None:
-            _merge_dict_to(data, "cookies", cookies)
-        data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
-        if session is None:
-            validate_vanilla_requests_kwargs(data)
-            session = requests.Session()
-            close_session = True
-        else:
-            close_session = False
-        verify = data.get("verify", True)
-        try:
-            with self.operation.schema.ratelimit():
-                response = session.request(**data)  # type: ignore
-        except (requests.Timeout, requests.ConnectionError) as exc:
-            if isinstance(exc, requests.ConnectionError):
-                if not isinstance(exc.args[0], ReadTimeoutError):
-                    raise
-                req = requests.Request(
-                    method=data["method"].upper(),
-                    url=data["url"],
-                    headers=data["headers"],
-                    files=data.get("files"),
-                    data=data.get("data") or {},
-                    json=data.get("json"),
-                    params=data.get("params") or {},
-                    auth=data.get("auth"),
-                    cookies=data["cookies"],
-                    hooks=data.get("hooks"),
-                )
-                request = session.prepare_request(req)
-            else:
-                request = cast(requests.PreparedRequest, exc.request)
-            timeout = 1000 * data["timeout"]  # It is defined and not empty, since the exception happened
-            code_message = self._get_code_message(self.operation.schema.code_sample_style, request, verify=verify)
-            message = f"The server failed to respond within the specified limit of {timeout:.2f}ms"
-            raise get_timeout_error(timeout)(
-                f"\n\n1. {failures.RequestTimeout.title}\n\n{message}\n\n{code_message}",
-                context=failures.RequestTimeout(message=message, timeout=timeout),
-            ) from None
-        response.verify = verify  # type: ignore[attr-defined]
+        response = self.operation.schema.transport.send(
+            self, session=session, base_url=base_url, headers=headers, params=params, cookies=cookies, **kwargs
+        )
         dispatch("after_call", hook_context, self, response)
-        if close_session:
-            session.close()
         return response
 
+    @deprecated_function(removed_in="4.0", replacement="Case.as_transport_kwargs")
     def as_werkzeug_kwargs(self, headers: dict[str, str] | None = None) -> dict[str, Any]:
         """Convert the case into a dictionary acceptable by werkzeug.Client."""
-        final_headers = self._get_headers(headers)
-        if self.media_type and not isinstance(self.body, NotSet):
-            # If we need to send a payload, then the Content-Type header should be set
-            final_headers["Content-Type"] = self.media_type
-        extra: dict[str, Any]
-        serializer = self._get_serializer()
-        if serializer is not None and not isinstance(self.body, NotSet):
-            context = SerializerContext(case=self)
-            extra = serializer.as_werkzeug(context, self.body)
-        else:
-            extra = {}
-        return {
-            "method": self.method,
-            "path": self.operation.schema.get_full_path(self.formatted_path),
-            # Convert to a regular dictionary, as we use `CaseInsensitiveDict` which is not supported by Werkzeug
-            "headers": dict(final_headers),
-            "query_string": self.query,
-            **extra,
-        }
+        return WSGITransport(self.app).serialize_case(self, headers=headers)
 
+    @deprecated_function(removed_in="4.0", replacement="Case.call")
     def call_wsgi(
         self,
         app: Any = None,
@@ -411,10 +434,6 @@ class Case:
         query_string: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> WSGIResponse:
-        from .transports.responses import WSGIResponse
-        import werkzeug
-        import requests
-
         application = app or self.app
         if application is None:
             raise RuntimeError(
@@ -423,17 +442,11 @@ class Case:
             )
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self)
-        data = self.as_werkzeug_kwargs(headers)
-        if query_string is not None:
-            _merge_dict_to(data, "query_string", query_string)
-        client = werkzeug.Client(application, WSGIResponse)
-        with cookie_handler(client, self.cookies), self.operation.schema.ratelimit():
-            response = client.open(**data, **kwargs)
-        requests_kwargs = self.as_requests_kwargs(base_url=self.get_full_base_url(), headers=headers)
-        response.request = requests.Request(**requests_kwargs).prepare()
+        response = WSGITransport(application).send(self, headers=headers, params=query_string, **kwargs)
         dispatch("after_call", hook_context, self, response)
         return response
 
+    @deprecated_function(removed_in="4.0", replacement="Case.call")
     def call_asgi(
         self,
         app: Any = None,
@@ -441,19 +454,17 @@ class Case:
         headers: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
-        from starlette_testclient import TestClient as ASGIClient
-
         application = app or self.app
         if application is None:
             raise RuntimeError(
                 "ASGI application instance is required. "
                 "Please, set `app` argument in the schema constructor or pass it to `call_asgi`"
             )
-        if base_url is None:
-            base_url = self.get_full_base_url()
-
-        with ASGIClient(application) as client:
-            return self.call(base_url=base_url, session=client, headers=headers, **kwargs)
+        hook_context = HookContext(operation=self.operation)
+        dispatch("before_call", hook_context, self)
+        response = ASGITransport(application).send(self, base_url=base_url, headers=headers, **kwargs)
+        dispatch("after_call", hook_context, self, response)
+        return response
 
     def validate_response(
         self,
@@ -462,6 +473,8 @@ class Case:
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -475,17 +488,35 @@ class Case:
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
         from .checks import ALL_CHECKS
+        from .internal.checks import wrap_check
         from .transports.responses import get_payload, get_reason
 
-        checks = checks or ALL_CHECKS
+        if checks:
+            _checks = tuple(wrap_check(check) for check in checks)
+        else:
+            _checks = checks
+        if additional_checks:
+            _additional_checks = tuple(wrap_check(check) for check in additional_checks)
+        else:
+            _additional_checks = additional_checks
+
+        checks = _checks or ALL_CHECKS
         checks = tuple(check for check in checks if check not in excluded_checks)
-        additional_checks = tuple(check for check in additional_checks if check not in excluded_checks)
+        additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
+        ctx = CheckContext(
+            override=self._override,
+            auth=None,
+            headers=CaseInsensitiveDict(headers) if headers else None,
+            transport_kwargs=transport_kwargs,
+        )
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
             try:
-                check(response, copied_case)
+                check(ctx, response, copied_case)
             except AssertionError as exc:
                 maybe_set_assertion_message(exc, check.__name__)
                 failed_checks.append(exc)
@@ -515,7 +546,7 @@ class Case:
             if not payload:
                 formatted += "\n\n    <EMPTY>"
             else:
-                payload = prepare_response_payload(payload)
+                payload = prepare_response_payload(payload, config=self.operation.schema.output_config)
                 payload = textwrap.indent(f"\n`{payload}`", prefix="    ")
                 formatted += f"\n{payload}"
             code_sample_style = (
@@ -550,20 +581,37 @@ class Case:
         session: requests.Session | None = None,
         headers: dict[str, Any] | None = None,
         checks: tuple[CheckFunction, ...] = (),
+        additional_checks: tuple[CheckFunction, ...] = (),
+        excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
         **kwargs: Any,
     ) -> requests.Response:
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
-        self.validate_response(response, checks, code_sample_style=code_sample_style)
+        self.validate_response(
+            response,
+            checks,
+            code_sample_style=code_sample_style,
+            headers=headers,
+            additional_checks=additional_checks,
+            excluded_checks=excluded_checks,
+            transport_kwargs=kwargs,
+        )
         return response
 
+    def _get_url(self, base_url: str | None) -> str:
+        base_url = self._get_base_url(base_url)
+        formatted_path = self.formatted_path.lstrip("/")
+        if not base_url.endswith("/"):
+            base_url += "/"
+        return unquote(urljoin(base_url, quote(formatted_path)))
+
     def get_full_url(self) -> str:
         """Make a full URL to the current API operation, including query parameters."""
         import requests
 
         base_url = self.base_url or "http://127.0.0.1"
-        kwargs = self.as_requests_kwargs(base_url)
+        kwargs = RequestsTransport().serialize_case(self, base_url=base_url)
         request = requests.Request(**kwargs)
         prepared = requests.Session().prepare_request(request)  # type: ignore
         return cast(str, prepared.url)
@@ -579,28 +627,12 @@ class Case:
             cookies=fast_deepcopy(self.cookies),
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
-        )
-
-
-def _merge_dict_to(data: dict[str, Any], data_key: str, new: dict[str, Any]) -> None:
-    original = data[data_key] or {}
-    for key, value in new.items():
-        original[key] = value
-    data[data_key] = original
-
-
-def validate_vanilla_requests_kwargs(data: dict[str, Any]) -> None:
-    """Check arguments for `requests.Session.request`.
-
-    Some arguments can be valid for cases like ASGI integration, but at the same time they won't work for the regular
-    `requests` calls. In such cases we need to avoid an obscure error message, that comes from `requests`.
-    """
-    url = data["url"]
-    if not urlparse(url).netloc:
-        raise RuntimeError(
-            "The URL should be absolute, so Schemathesis knows where to send the data. \n"
-            f"If you use the ASGI integration, please supply your test client "
-            f"as the `session` argument to `call`.\nURL: {url}"
+            meta=self.meta,
+            generation_time=self.generation_time,
+            id=self.id,
+            _auth=self._auth,
+            _has_explicit_auth=self._has_explicit_auth,
+            _explicit_method=self._explicit_method,
         )
 
 
@@ -628,7 +660,7 @@ D = TypeVar("D", bound=dict)
 
 
 @dataclass
-class OperationDefinition(Generic[P, D]):
+class OperationDefinition(Generic[D]):
     """A wrapper to store not resolved API operation definitions.
 
     To prevent recursion errors we need to store definitions without resolving references. But operation definitions
@@ -639,16 +671,10 @@ class OperationDefinition(Generic[P, D]):
     raw: D
     resolved: D
     scope: str
-    parameters: Sequence[P]
-
-    def __contains__(self, item: str | int) -> bool:
-        return item in self.resolved
 
-    def __getitem__(self, item: str | int) -> None | bool | float | str | list | dict[str, Any]:
-        return self.resolved[item]
+    __slots__ = ("raw", "resolved", "scope")
 
-    def get(self, item: str | int, default: Any = None) -> None | bool | float | str | list | dict[str, Any]:
-        return self.resolved.get(item, default)
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
 
 C = TypeVar("C", bound=Case)
@@ -770,9 +796,11 @@ class APIOperation(Generic[P, C]):
     def get_security_requirements(self) -> list[str]:
         return self.schema.get_security_requirements(self)
 
-    def get_strategies_from_examples(self) -> list[st.SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[st.SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return self.schema.get_strategies_from_examples(self)
+        return self.schema.get_strategies_from_examples(self, as_strategy_kwargs=as_strategy_kwargs)
 
     def get_stateful_tests(self, response: GenericResponse, stateful: Stateful | None) -> Sequence[StatefulTest]:
         return self.schema.get_stateful_tests(response, self, stateful)
@@ -791,6 +819,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
@@ -911,6 +952,7 @@ class Request:
     method: str
     uri: str
     body: str | None
+    body_size: int | None
     headers: Headers
 
     @classmethod
@@ -919,7 +961,7 @@ class Request:
         import requests
 
         base_url = case.get_full_base_url()
-        kwargs = case.as_requests_kwargs(base_url)
+        kwargs = RequestsTransport().serialize_case(case, base_url=base_url)
         request = requests.Request(**kwargs)
         prepared = session.prepare_request(request)  # type: ignore
         return cls.from_prepared_request(prepared)
@@ -941,8 +983,17 @@ 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:
+        """Deserialize the request body.
+
+        `Request` should be serializable to JSON, therefore body is encoded as base64 string
+        to support arbitrary binary data.
+        """
+        return deserialize_payload(self.body)
+
 
 @dataclass(repr=False)
 class Response:
@@ -952,6 +1003,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
@@ -960,9 +1012,12 @@ class Response:
     @classmethod
     def from_requests(cls, response: requests.Response) -> Response:
         """Create a response from requests.Response."""
-        headers = {name: response.raw.headers.getlist(name) for name in response.raw.headers.keys()}
+        raw = response.raw
+        raw_headers = raw.headers if raw is not None else {}
+        headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
         # Similar to http.client:319 (HTTP version detection in stdlib's `http` package)
-        http_version = "1.0" if response.raw.version == 10 else "1.1"
+        version = raw.version if raw is not None else 10
+        http_version = "1.0" if version == 10 else "1.1"
 
         def is_empty(_response: requests.Response) -> bool:
             # Assume the response is empty if:
@@ -975,6 +1030,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,
@@ -1002,6 +1058,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",
@@ -1009,35 +1066,76 @@ class Response:
             verify=True,
         )
 
+    def deserialize_body(self) -> bytes | None:
+        """Deserialize the response body.
+
+        `Response` should be serializable to JSON, therefore body is encoded as base64 string
+        to support arbitrary binary data.
+        """
+        return deserialize_payload(self.body)
+
+
+TIMEZONE = datetime.datetime.now(datetime.timezone.utc).astimezone().tzinfo
+
 
 @dataclass
 class Interaction:
     """A single interaction with the target app."""
 
     request: Request
-    response: Response
+    response: Response | None
     checks: list[Check]
     status: Status
     data_generation_method: DataGenerationMethod
-    recorded_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat())
+    phase: TestPhase | None
+    # `description` & `location` are related to metadata about this interaction
+    # NOTE: It will be better to keep it in a separate attribute
+    description: str | None
+    location: str | None
+    parameter: str | None
+    parameter_location: str | None
+    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:
+    def from_requests(
+        cls,
+        case: Case,
+        response: requests.Response | None,
+        status: Status,
+        checks: list[Check],
+        headers: dict[str, Any] | None,
+        session: requests.Session | None,
+    ) -> Interaction:
+        if response is not None:
+            prepared = response.request
+            request = Request.from_prepared_request(prepared)
+        else:
+            import requests
+
+            if session is None:
+                session = requests.Session()
+                session.headers.update(headers or {})
+            request = Request.from_case(case, session)
         return cls(
-            request=Request.from_prepared_request(response.request),
-            response=Response.from_requests(response),
+            request=request,
+            response=Response.from_requests(response) if response is not None else None,
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
+            phase=case.meta.phase if case.meta is not None else None,
+            description=case.meta.description if case.meta is not None else None,
+            location=case.meta.location if case.meta is not None else None,
+            parameter=case.meta.parameter if case.meta is not None else None,
+            parameter_location=case.meta.parameter_location if case.meta is not None else None,
         )
 
     @classmethod
     def from_wsgi(
         cls,
         case: Case,
-        response: WSGIResponse,
+        response: WSGIResponse | None,
         headers: dict[str, Any],
-        elapsed: float,
+        elapsed: float | None,
         status: Status,
         checks: list[Check],
     ) -> Interaction:
@@ -1047,10 +1145,15 @@ class Interaction:
         session.headers.update(headers)
         return cls(
             request=Request.from_case(case, session),
-            response=Response.from_wsgi(response, elapsed),
+            response=Response.from_wsgi(response, elapsed) if response is not None and elapsed is not None else None,
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
+            phase=case.meta.phase if case.meta is not None else None,
+            description=case.meta.description if case.meta is not None else None,
+            location=case.meta.location if case.meta is not None else None,
+            parameter=case.meta.parameter if case.meta is not None else None,
+            parameter_location=case.meta.parameter_location if case.meta is not None else None,
         )
 
 
@@ -1076,6 +1179,8 @@ class TestResult:
     # DEPRECATED: Seed is the same per test run
     seed: int | None = None
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     def mark_errored(self) -> None:
         self.is_errored = True
 
@@ -1136,16 +1241,22 @@ class TestResult:
         self.errors.append(exception)
 
     def store_requests_response(
-        self, case: Case, response: requests.Response, status: Status, checks: list[Check]
+        self,
+        case: Case,
+        response: requests.Response | None,
+        status: Status,
+        checks: list[Check],
+        headers: dict[str, Any] | None,
+        session: requests.Session | None,
     ) -> None:
-        self.interactions.append(Interaction.from_requests(case, response, status, checks))
+        self.interactions.append(Interaction.from_requests(case, response, status, checks, headers, session))
 
     def store_wsgi_response(
         self,
         case: Case,
-        response: WSGIResponse,
+        response: WSGIResponse | None,
         headers: dict[str, Any],
-        elapsed: float,
+        elapsed: float | None,
         status: Status,
         checks: list[Check],
     ) -> None:
@@ -1163,6 +1274,8 @@ class TestResultSet:
     generic_errors: list[OperationSchemaError] = field(default_factory=list)
     warnings: list[str] = field(default_factory=list)
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     def __iter__(self) -> Iterator[TestResult]:
         return iter(self.results)
 
@@ -1226,6 +1339,3 @@ class TestResultSet:
     def add_warning(self, warning: str) -> None:
         """Add a new warning to the warnings list."""
         self.warnings.append(warning)
-
-
-CheckFunction = Callable[["GenericResponse", Case], Optional[bool]]