schemathesis 3.18.5__py3-none-any.whl → 3.19.1__py3-none-any.whl

schemathesis/__init__.py

@@ -27,7 +27,7 @@ from_uri = openapi.from_uri
 from_wsgi = openapi.from_wsgi
 
 # Public API
-auth = auths.register
+auth = auths.GLOBAL_AUTH_STORAGE
 check = checks.register
 hook = hooks.register
 serializer = serializers.register
@@ -37,5 +37,3 @@ target = targets.register
 register_check = checks.register
 register_target = targets.register
 register_string_format = openapi.format
-
-auth.__dict__["register"] = auths.register

schemathesis/auths.py

@@ -1,12 +1,14 @@
 """Support for custom API authentication mechanisms."""
 import threading
 import time
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Type, TypeVar
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Callable, Generic, List, Optional, Type, TypeVar, Union
 
-import attr
+import requests.auth
 from typing_extensions import Protocol, runtime_checkable
 
 from .exceptions import UsageError
+from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
 from .types import GenericTest
 
 if TYPE_CHECKING:
@@ -17,7 +19,7 @@ AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"
 Auth = TypeVar("Auth")
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class AuthContext:
     """Holds state relevant for the authentication process.
 
@@ -25,15 +27,15 @@ class AuthContext:
     :ivar app: Optional Python application if the WSGI / ASGI integration is used.
     """
 
-    operation: "APIOperation" = attr.ib()  # pragma: no mutate
-    app: Optional[Any] = attr.ib()  # pragma: no mutate
+    operation: "APIOperation"
+    app: Optional[Any]
 
 
 @runtime_checkable
 class AuthProvider(Protocol):
     """Get authentication data for an API and set it on the generated test cases."""
 
-    def get(self, context: AuthContext) -> Auth:  # type: ignore
+    def get(self, context: AuthContext) -> Optional[Auth]:
         """Get the authentication data.
 
         :param AuthContext context: Holds state relevant for the authentication process.
@@ -49,33 +51,47 @@ class AuthProvider(Protocol):
         """
 
 
-@attr.s(slots=True)
+@dataclass
 class CacheEntry(Generic[Auth]):
     """Cached auth data."""
 
-    data: Auth = attr.ib()
-    expires: float = attr.ib()
+    data: Auth
+    expires: float
 
 
-@attr.s(slots=True)
+@dataclass
+class RequestsAuth(Generic[Auth]):
+    """Provider that sets auth data via `requests` auth instance."""
+
+    auth: requests.auth.AuthBase
+
+    def get(self, _: AuthContext) -> Optional[Auth]:
+        return self.auth  # type: ignore[return-value]
+
+    def set(self, case: "Case", _: Auth, __: AuthContext) -> None:
+        case._auth = self.auth
+
+
+@dataclass
 class CachingAuthProvider(Generic[Auth]):
     """Caches the underlying auth provider."""
 
-    provider: AuthProvider = attr.ib()
-    refresh_interval: int = attr.ib(default=DEFAULT_REFRESH_INTERVAL)
-    cache_entry: Optional[CacheEntry[Auth]] = attr.ib(default=None)
+    provider: AuthProvider
+    refresh_interval: int = DEFAULT_REFRESH_INTERVAL
+    cache_entry: Optional[CacheEntry[Auth]] = None
     # The timer exists here to simplify testing
-    timer: Callable[[], float] = attr.ib(default=time.monotonic)
-    _refresh_lock: threading.Lock = attr.ib(factory=threading.Lock)
+    timer: Callable[[], float] = time.monotonic
+    _refresh_lock: threading.Lock = field(default_factory=threading.Lock)
 
-    def get(self, context: AuthContext) -> Auth:
+    def get(self, context: AuthContext) -> Optional[Auth]:
         """Get cached auth value."""
         if self.cache_entry is None or self.timer() >= self.cache_entry.expires:
             with self._refresh_lock:
                 if not (self.cache_entry is None or self.timer() >= self.cache_entry.expires):
                     # Another thread updated the cache
                     return self.cache_entry.data
-                data: Auth = self.provider.get(context)
+                # We know that optional auth is possible only inside a higher-level wrapper
+                data: Auth = self.provider.get(context)  # type: ignore[assignment]
                 self.cache_entry = CacheEntry(data=data, expires=self.timer() + self.refresh_interval)
                 return data
         return self.cache_entry.data
@@ -88,20 +104,176 @@ class CachingAuthProvider(Generic[Auth]):
         self.provider.set(case, data, context)
 
 
-@attr.s(slots=True)
+class FilterableRegisterAuth(Protocol):
+    """Protocol that adds filters to the return value of `register`."""
+
+    def __call__(self, provider_class: Type[AuthProvider]) -> Type[AuthProvider]:
+        pass
+
+    def apply_to(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableRegisterAuth":
+        pass
+
+    def skip_for(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableRegisterAuth":
+        pass
+
+
+class FilterableApplyAuth(Protocol):
+    """Protocol that adds filters to the return value of `apply`."""
+
+    def __call__(self, test: GenericTest) -> GenericTest:
+        pass
+
+    def apply_to(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableApplyAuth":
+        pass
+
+    def skip_for(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableApplyAuth":
+        pass
+
+
+class FilterableRequestsAuth(Protocol):
+    """Protocol that adds filters to the return value of `set_from_requests`."""
+
+    def apply_to(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableRequestsAuth":
+        pass
+
+    def skip_for(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> "FilterableRequestsAuth":
+        pass
+
+
+@dataclass
+class SelectiveAuthProvider(Generic[Auth]):
+    """Applies auth depending on the configured filters."""
+
+    provider: AuthProvider
+    filter_set: FilterSet
+
+    def get(self, context: AuthContext) -> Optional[Auth]:
+        if self.filter_set.match(context):
+            return self.provider.get(context)
+        return None
+
+    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
+        self.provider.set(case, data, context)
+
+
+@dataclass
 class AuthStorage(Generic[Auth]):
     """Store and manage API authentication."""
 
-    provider: Optional[AuthProvider] = attr.ib(default=None)
+    providers: List[AuthProvider] = field(default_factory=list)
 
     @property
     def is_defined(self) -> bool:
         """Whether there is an auth provider set."""
-        return self.provider is not None
+        return bool(self.providers)
+
+    def __call__(
+        self,
+        provider_class: Optional[Type[AuthProvider]] = None,
+        *,
+        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
+    ) -> Union[FilterableRegisterAuth, FilterableApplyAuth]:
+        if provider_class is not None:
+            return self.apply(provider_class, refresh_interval=refresh_interval)
+        return self.register(refresh_interval=refresh_interval)
+
+    def set_from_requests(self, auth: requests.auth.AuthBase) -> FilterableRequestsAuth:
+        """Use `requests` auth instance as an auth provider."""
+        filter_set = FilterSet()
+        self.providers.append(SelectiveAuthProvider(provider=RequestsAuth(auth), filter_set=filter_set))
+
+        class _FilterableRequestsAuth:
+            pass
+
+        attach_filter_chain(_FilterableRequestsAuth, "apply_to", filter_set.include)
+        attach_filter_chain(_FilterableRequestsAuth, "skip_for", filter_set.exclude)
+
+        return _FilterableRequestsAuth  # type: ignore[return-value]
+
+    def _set_provider(
+        self,
+        *,
+        provider_class: Type[AuthProvider],
+        refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL,
+        filter_set: FilterSet,
+    ) -> None:
+        if not issubclass(provider_class, AuthProvider):
+            raise TypeError(
+                f"`{provider_class.__name__}` is not a valid auth provider. "
+                f"Check `schemathesis.auths.AuthProvider` documentation for examples."
+            )
+        provider: AuthProvider
+        # Apply caching if desired
+        if refresh_interval is not None:
+            provider = CachingAuthProvider(provider_class(), refresh_interval=refresh_interval)
+        else:
+            provider = provider_class()
+        # Store filters if any
+        if not filter_set.is_empty():
+            provider = SelectiveAuthProvider(provider, filter_set)
+        self.providers.append(provider)
 
-    def register(
-        self, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL
-    ) -> Callable[[Type[AuthProvider]], Type[AuthProvider]]:
+    def register(self, *, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL) -> FilterableRegisterAuth:
         """Register a new auth provider.
 
         .. code-block:: python
@@ -121,32 +293,27 @@ class AuthStorage(Generic[Auth]):
                     # Modify `case` the way you need
                     case.headers = {"Authorization": f"Bearer {data}"}
         """
+        filter_set = FilterSet()
 
         def wrapper(provider_class: Type[AuthProvider]) -> Type[AuthProvider]:
-            if not issubclass(provider_class, AuthProvider):
-                raise TypeError(
-                    f"`{provider_class.__name__}` is not a valid auth provider. "
-                    f"Check `schemathesis.auths.AuthProvider` documentation for examples."
-                )
-            # Apply caching if desired
-            if refresh_interval is not None:
-                self.provider = CachingAuthProvider(provider_class(), refresh_interval=refresh_interval)
-            else:
-                self.provider = provider_class()
+            self._set_provider(provider_class=provider_class, refresh_interval=refresh_interval, filter_set=filter_set)
             return provider_class
 
-        return wrapper
+        attach_filter_chain(wrapper, "apply_to", filter_set.include)
+        attach_filter_chain(wrapper, "skip_for", filter_set.exclude)
+
+        return wrapper  # type: ignore[return-value]
 
     def unregister(self) -> None:
         """Unregister the currently registered auth provider.
 
         No-op if there is no auth provider registered.
         """
-        self.provider = None
+        self.providers = []
 
     def apply(
         self, provider_class: Type[AuthProvider], *, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL
-    ) -> Callable[[GenericTest], GenericTest]:
+    ) -> FilterableApplyAuth:
         """Register auth provider only on one test function.
 
         :param Type[AuthProvider] provider_class: Authentication provider class.
@@ -158,19 +325,25 @@ class AuthStorage(Generic[Auth]):
                 ...
 
 
-            @schema.auth.apply(Auth)
+            @schema.auth(Auth)
             @schema.parametrize()
             def test_api(case):
                 ...
 
         """
+        filter_set = FilterSet()
 
         def wrapper(test: GenericTest) -> GenericTest:
             auth_storage = self.add_auth_storage(test)
-            auth_storage.register(refresh_interval=refresh_interval)(provider_class)
+            auth_storage._set_provider(
+                provider_class=provider_class, refresh_interval=refresh_interval, filter_set=filter_set
+            )
             return test
 
-        return wrapper
+        attach_filter_chain(wrapper, "apply_to", filter_set.include)
+        attach_filter_chain(wrapper, "skip_for", filter_set.exclude)
+
+        return wrapper  # type: ignore[return-value]
 
     @classmethod
     def add_auth_storage(cls, test: GenericTest) -> "AuthStorage":
@@ -183,11 +356,13 @@ class AuthStorage(Generic[Auth]):
 
     def set(self, case: "Case", context: AuthContext) -> None:
         """Set authentication data on a generated test case."""
-        if self.provider is not None:
-            data: Auth = self.provider.get(context)
-            self.provider.set(case, data, context)
-        else:
+        if not self.is_defined:
             raise UsageError("No auth provider is defined.")
+        for provider in self.providers:
+            data: Optional[Auth] = provider.get(context)
+            if data is not None:
+                provider.set(case, data, context)
+                break
 
 
 def set_on_case(case: "Case", context: AuthContext, auth_storage: Optional[AuthStorage]) -> None:

schemathesis/cli/__init__.py

@@ -4,12 +4,12 @@ import os
 import sys
 import traceback
 from collections import defaultdict
+from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
 from typing import Any, Callable, Dict, Generator, Iterable, List, NoReturn, Optional, Tuple, Union, cast
 from urllib.parse import urlparse
 
-import attr
 import click
 import hypothesis
 import requests
@@ -448,6 +448,13 @@ REPORT_TO_SERVICE = object()
     multiple=True,
     type=click.Choice(list(ALL_FIXUPS) + ["all"]),
 )
+@click.option(
+    "--rate-limit",
+    help="The maximum rate of requests to send to the tested API in the format of `<limit>/<duration>`. "
+    "Example - `100/m` for 100 requests per minute.",
+    type=str,
+    callback=callbacks.validate_rate_limit,
+)
 @click.option(
     "--stateful",
     help="Utilize stateful testing capabilities.",
@@ -480,7 +487,7 @@ REPORT_TO_SERVICE = object()
 @click.option(
     "--contrib-openapi-formats-uuid",
     "contrib_openapi_formats_uuid",
-    help="Forces Schemathesis to generate unique test cases.",
+    help="Enable support for the `uuid` string format.",
     is_flag=True,
     default=False,
     show_default=True,
@@ -619,6 +626,7 @@ def run(
     store_network_log: Optional[click.utils.LazyFile] = None,
     wait_for_schema: Optional[float] = None,
     fixups: Tuple[str] = (),  # type: ignore
+    rate_limit: Optional[str] = None,
     stateful: Optional[Stateful] = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     force_schema_version: Optional[str] = None,
@@ -755,6 +763,7 @@ def run(
         max_response_time=max_response_time,
         targets=selected_targets,
         workers_num=workers_num,
+        rate_limit=rate_limit,
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
@@ -763,6 +772,7 @@ def run(
         event_stream,
         hypothesis_settings=hypothesis_settings,
         workers_num=workers_num,
+        rate_limit=rate_limit,
         show_errors_tracebacks=show_errors_tracebacks,
         validate_schema=validate_schema,
         cassette_path=cassette_path,
@@ -789,32 +799,33 @@ def prepare_request_cert(cert: Optional[str], key: Optional[str]) -> Optional[Re
     return cert
 
 
-@attr.s(slots=True)
+@dataclass
 class LoaderConfig:
     """Container for API loader parameters.
 
     The main goal is to avoid too many parameters in function signatures.
     """
 
-    schema_location: str = attr.ib()  # pragma: no mutate
-    app: Any = attr.ib()  # pragma: no mutate
-    base_url: Optional[str] = attr.ib()  # pragma: no mutate
-    validate_schema: bool = attr.ib()  # pragma: no mutate
-    skip_deprecated_operations: bool = attr.ib()  # pragma: no mutate
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = attr.ib()  # pragma: no mutate
-    force_schema_version: Optional[str] = attr.ib()  # pragma: no mutate
-    request_tls_verify: Union[bool, str] = attr.ib()  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib()  # pragma: no mutate
-    wait_for_schema: Optional[float] = attr.ib()  # pragma: no mutate
+    schema_location: str
+    app: Any
+    base_url: Optional[str]
+    validate_schema: bool
+    skip_deprecated_operations: bool
+    data_generation_methods: Tuple[DataGenerationMethod, ...]
+    force_schema_version: Optional[str]
+    request_tls_verify: Union[bool, str]
+    request_cert: Optional[RequestCert]
+    wait_for_schema: Optional[float]
+    rate_limit: Optional[str]
     # Network request parameters
-    auth: Optional[Tuple[str, str]] = attr.ib()  # pragma: no mutate
-    auth_type: Optional[str] = attr.ib()  # pragma: no mutate
-    headers: Optional[Dict[str, str]] = attr.ib()  # pragma: no mutate
+    auth: Optional[Tuple[str, str]]
+    auth_type: Optional[str]
+    headers: Optional[Dict[str, str]]
     # Schema filters
-    endpoint: Optional[Filter] = attr.ib()  # pragma: no mutate
-    method: Optional[Filter] = attr.ib()  # pragma: no mutate
-    tag: Optional[Filter] = attr.ib()  # pragma: no mutate
-    operation_id: Optional[Filter] = attr.ib()  # pragma: no mutate
+    endpoint: Optional[Filter]
+    method: Optional[Filter]
+    tag: Optional[Filter]
+    operation_id: Optional[Filter]
 
 
 def into_event_stream(
@@ -849,6 +860,7 @@ def into_event_stream(
     seed: Optional[int],
     exit_first: bool,
     max_failures: Optional[int],
+    rate_limit: Optional[str],
     dry_run: bool,
     store_interactions: bool,
     stateful: Optional[Stateful],
@@ -868,6 +880,7 @@ def into_event_stream(
             request_tls_verify=request_tls_verify,
             request_cert=request_cert,
             wait_for_schema=wait_for_schema,
+            rate_limit=rate_limit,
             auth=auth,
             auth_type=auth_type,
             headers=headers,
@@ -968,6 +981,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> Dict[str, Any]:
         "validate_schema": config.validate_schema,
         "force_schema_version": config.force_schema_version,
         "data_generation_methods": config.data_generation_methods,
+        "rate_limit": config.rate_limit,
     }
     if loader is not oas_loaders.from_path:
         kwargs["headers"] = config.headers
@@ -986,6 +1000,7 @@ def get_graphql_loader_kwargs(
         "app": config.app,
         "base_url": config.base_url,
         "data_generation_methods": config.data_generation_methods,
+        "rate_limit": config.rate_limit,
     }
     if loader is not gql_loaders.from_path:
         kwargs["headers"] = config.headers
@@ -1046,6 +1061,7 @@ def execute(
     *,
     hypothesis_settings: hypothesis.settings,
     workers_num: int,
+    rate_limit: Optional[str],
     show_errors_tracebacks: bool,
     validate_schema: bool,
     cassette_path: Optional[click.utils.LazyFile],
@@ -1111,6 +1127,7 @@ def execute(
     execution_context = ExecutionContext(
         hypothesis_settings=hypothesis_settings,
         workers_num=workers_num,
+        rate_limit=rate_limit,
         show_errors_tracebacks=show_errors_tracebacks,
         validate_schema=validate_schema,
         cassette_path=cassette_path.name if cassette_path is not None else None,

schemathesis/cli/callbacks.py

@@ -10,7 +10,7 @@ import hypothesis
 from click.types import LazyFile  # type: ignore
 from requests import PreparedRequest, RequestException
 
-from .. import utils
+from .. import exceptions, throttling, utils
 from ..constants import CodeSampleStyle, DataGenerationMethod
 from ..service.hosts import get_temporary_hosts_file
 from ..stateful import Stateful
@@ -92,6 +92,18 @@ def validate_base_url(ctx: click.core.Context, param: click.core.Parameter, raw_
     return raw_value
 
 
+def validate_rate_limit(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
+) -> Optional[str]:
+    if raw_value is None:
+        return raw_value
+    try:
+        throttling.parse_units(raw_value)
+        return raw_value
+    except exceptions.UsageError as exc:
+        raise click.UsageError(exc.args[0]) from exc
+
+
 APPLICATION_FORMAT_MESSAGE = (
     "Can not import application from the given module!\n"
     "The `--app` option value should be in format:\n\n    path:variable\n\n"

schemathesis/cli/cassettes.py

@@ -3,10 +3,10 @@ import json
 import re
 import sys
 import threading
+from dataclasses import dataclass, field
 from queue import Queue
 from typing import IO, Any, Dict, Generator, Iterator, List, Optional, cast
 
-import attr
 import click
 import requests
 from requests.cookies import RequestsCookieJar
@@ -25,7 +25,7 @@ from .handlers import EventHandler
 WRITER_WORKER_JOIN_TIMEOUT = 1
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class CassetteWriter(EventHandler):
     """Write interactions in a YAML cassette.
 
@@ -33,12 +33,12 @@ class CassetteWriter(EventHandler):
     the end of the test run.
     """
 
-    file_handle: click.utils.LazyFile = attr.ib()  # pragma: no mutate
-    preserve_exact_body_bytes: bool = attr.ib()  # pragma: no mutate
-    queue: Queue = attr.ib(factory=Queue)  # pragma: no mutate
-    worker: threading.Thread = attr.ib(init=False)  # pragma: no mutate
+    file_handle: click.utils.LazyFile
+    preserve_exact_body_bytes: bool
+    queue: Queue = field(default_factory=Queue)
+    worker: threading.Thread = field(init=False)
 
-    def __attrs_post_init__(self) -> None:
+    def __post_init__(self) -> None:
         self.worker = threading.Thread(
             target=worker,
             kwargs={
@@ -80,23 +80,23 @@ class CassetteWriter(EventHandler):
         self.worker.join(WRITER_WORKER_JOIN_TIMEOUT)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int = attr.ib()  # pragma: no mutate
-    correlation_id: str = attr.ib()  # pragma: no mutate
-    thread_id: int = attr.ib()  # pragma: no mutate
-    data_generation_method: constants.DataGenerationMethod = attr.ib()  # pragma: no mutate
-    interactions: List[SerializedInteraction] = attr.ib()  # pragma: no mutate
+    seed: int
+    correlation_id: str
+    thread_id: int
+    data_generation_method: constants.DataGenerationMethod
+    interactions: List[SerializedInteraction]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Finalize:
     """The work is done and there will be no more messages to process."""
 
@@ -274,10 +274,10 @@ def write_double_quoted(stream: IO, text: str) -> None:
     stream.write('"')
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Replayed:
-    interaction: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    response: requests.Response = attr.ib()  # pragma: no mutate
+    interaction: Dict[str, Any]
+    response: requests.Response
 
 
 def replay(