schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/specs/openapi/stateful/__init__.py

@@ -14,6 +14,7 @@ from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
+from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi.stateful.control import TransitionController
@@ -32,7 +33,7 @@ class OpenAPIStateMachine(APIStateMachine):
     _transitions: ApiTransitions
 
     def __init__(self) -> None:
-        self.recorder = ScenarioRecorder(label="Stateful tests")
+        self.recorder = ScenarioRecorder(label=STATEFUL_TESTS_LABEL)
         self.control = TransitionController(self._transitions)
         super().__init__()
 
@@ -162,22 +163,25 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                         f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
                     )
                     assert name not in rules, name
+                    config = schema.config.generation_for(operation=target, phase="stateful")
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
                             target=catch_all,
                             input=bundles[bundle_name].flatmap(
-                                into_step_input(target=target, link=link, modes=schema.generation_config.modes)
+                                into_step_input(target=target, link=link, modes=config.modes)
                             ),
                         )
                     )
             if target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
                 name = _normalize_name(f"RANDOM -> {target.label}")
-                if len(schema.generation_config.modes) == 1:
-                    case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
+                config = schema.config.generation_for(operation=target, phase="stateful")
+                if len(config.modes) == 1:
+                    case_strategy = target.as_strategy(generation_mode=config.modes[0], __is_stateful_phase=True)
                 else:
                     _strategies = {
-                        method: target.as_strategy(generation_mode=method) for method in schema.generation_config.modes
+                        method: target.as_strategy(generation_mode=method, __is_stateful_phase=True)
+                        for method in config.modes
                     }
 
                     @st.composite  # type: ignore[misc]
@@ -262,7 +266,9 @@ def into_step_input(
                 and not link.merge_body
             ):
                 kwargs["body"] = transition.request_body.value.ok()
-            cases = strategies.combine([target.as_strategy(generation_mode=mode, **kwargs) for mode in modes])
+            cases = strategies.combine(
+                [target.as_strategy(generation_mode=mode, __is_stateful_phase=True, **kwargs) for mode in modes]
+            )
             case = draw(cases)
             if (
                 transition.request_body is not None

schemathesis/transport/__init__.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from inspect import iscoroutinefunction
-from typing import Any, Callable, Generic, Iterator, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Generic, Iterator, TypeVar, Union
 
 from schemathesis.core import media_types
 from schemathesis.core.errors import SerializationNotPossible
 
+if TYPE_CHECKING:
+    from schemathesis.core.transport import Response
+    from schemathesis.generation.case import Case
+
 
 def get(app: Any) -> BaseTransport:
     """Get transport to send the data to the application."""
@@ -23,41 +27,43 @@ def get(app: Any) -> BaseTransport:
     return WSGI_TRANSPORT
 
 
-C = TypeVar("C", contravariant=True)
-R = TypeVar("R", covariant=True)
 S = TypeVar("S", contravariant=True)
 
 
 @dataclass
-class SerializationContext(Generic[C]):
-    """Generic context for serialization process."""
+class SerializationContext:
+    """Context object passed to serializer functions.
+
+    It provides access to the generated test case and any related metadata.
+    """
 
-    case: C
+    case: Case
+    """The generated test case."""
 
     __slots__ = ("case",)
 
 
-Serializer = Callable[[SerializationContext[C], Any], Any]
+Serializer = Callable[[SerializationContext, Any], Any]
 
 
-class BaseTransport(Generic[C, R, S]):
+class BaseTransport(Generic[S]):
     """Base implementation with serializer registration."""
 
     def __init__(self) -> None:
-        self._serializers: dict[str, Serializer[C]] = {}
+        self._serializers: dict[str, Serializer] = {}
 
-    def serialize_case(self, case: C, **kwargs: Any) -> dict[str, Any]:
+    def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
         """Prepare the case for sending."""
         raise NotImplementedError
 
-    def send(self, case: C, *, session: S | None = None, **kwargs: Any) -> R:
+    def send(self, case: Case, *, session: S | None = None, **kwargs: Any) -> Response:
         """Send the case using this transport."""
         raise NotImplementedError
 
-    def serializer(self, *media_types: str) -> Callable[[Serializer[C]], Serializer[C]]:
+    def serializer(self, *media_types: str) -> Callable[[Serializer], Serializer]:
         """Register a serializer for given media types."""
 
-        def decorator(func: Serializer[C]) -> Serializer[C]:
+        def decorator(func: Serializer) -> Serializer:
             for media_type in media_types:
                 self._serializers[media_type] = func
             return func
@@ -71,10 +77,10 @@ class BaseTransport(Generic[C, R, S]):
     def _copy_serializers_from(self, transport: BaseTransport) -> None:
         self._serializers.update(transport._serializers)
 
-    def get_first_matching_media_type(self, media_type: str) -> tuple[str, Serializer[C]] | None:
+    def get_first_matching_media_type(self, media_type: str) -> tuple[str, Serializer] | None:
         return next(self.get_matching_media_types(media_type), None)
 
-    def get_matching_media_types(self, media_type: str) -> Iterator[tuple[str, Serializer[C]]]:
+    def get_matching_media_types(self, media_type: str) -> Iterator[tuple[str, Serializer]]:
         """Get all registered media types matching the given media type."""
         if media_type == "*/*":
             # Shortcut to avoid comparing all values
@@ -96,9 +102,41 @@ class BaseTransport(Generic[C, R, S]):
                     if main in ("*", target_main) and sub in ("*", target_sub):
                         yield registered_media_type, serializer
 
-    def _get_serializer(self, input_media_type: str) -> Serializer[C]:
+    def _get_serializer(self, input_media_type: str) -> Serializer:
         pair = self.get_first_matching_media_type(input_media_type)
         if pair is None:
             # This media type is set manually. Otherwise, it should have been rejected during the data generation
             raise SerializationNotPossible.for_media_type(input_media_type)
         return pair[1]
+
+
+_Serializer = Callable[[SerializationContext, Any], Union[bytes, None]]
+
+
+def serializer(*media_types: str) -> Callable[[_Serializer], None]:
+    """Register a serializer for specified media types on HTTP, ASGI, and WSGI transports.
+
+    Args:
+        *media_types: One or more MIME types (e.g., "application/json") this serializer handles.
+
+    Returns:
+        A decorator that wraps a function taking `(ctx: SerializationContext, value: Any)` and returning `bytes` for serialized body and `None` for omitting request body.
+
+    """
+
+    def register(func: _Serializer) -> None:
+        from schemathesis.transport.asgi import ASGI_TRANSPORT
+        from schemathesis.transport.requests import REQUESTS_TRANSPORT
+        from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+        @ASGI_TRANSPORT.serializer(*media_types)
+        @REQUESTS_TRANSPORT.serializer(*media_types)
+        @WSGI_TRANSPORT.serializer(*media_types)
+        def inner(ctx: SerializationContext, value: Any) -> dict[str, bytes]:
+            result = {}
+            serialized = func(ctx, value)
+            if serialized is not None:
+                result["data"] = serialized
+            return result
+
+    return register

schemathesis/transport/prepare.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Mapping, cast
 from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
+from schemathesis.config import SanitizationConfig
 from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER, NotSet
 from schemathesis.core.errors import InvalidSchema
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
 from schemathesis.core.transport import USER_AGENT
+from schemathesis.generation.meta import CoveragePhaseData
 
 if TYPE_CHECKING:
     from requests import PreparedRequest
@@ -15,15 +18,37 @@ if TYPE_CHECKING:
     from schemathesis.generation.case import Case
 
 
-def prepare_headers(case: Case, headers: dict[str, str] | None = None) -> CaseInsensitiveDict:
-    from requests.structures import CaseInsensitiveDict
+@lru_cache()
+def get_default_headers() -> CaseInsensitiveDict:
+    from requests.utils import default_headers
+
+    headers = default_headers()
+    headers["User-Agent"] = USER_AGENT
+    return headers
+
 
-    final_headers = case.headers.copy() if case.headers is not None else CaseInsensitiveDict()
+def prepare_headers(case: Case, headers: dict[str, str] | None = None) -> CaseInsensitiveDict:
+    default_headers = get_default_headers().copy()
+    if case.headers:
+        default_headers.update(case.headers)
+    default_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, case.id)
     if headers:
-        final_headers.update(headers)
-    final_headers.setdefault("User-Agent", USER_AGENT)
-    final_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, case.id)
-    return final_headers
+        default_headers.update(headers)
+    for header in get_exclude_headers(case):
+        default_headers.pop(header, None)
+    return default_headers
+
+
+def get_exclude_headers(case: Case) -> list[str]:
+    if (
+        case.meta is not None
+        and isinstance(case.meta.phase.data, CoveragePhaseData)
+        and case.meta.phase.data.description.startswith("Missing")
+        and case.meta.phase.data.description.endswith("at header")
+        and case.meta.phase.data.parameter is not None
+    ):
+        return [case.meta.phase.data.parameter]
+    return []
 
 
 def prepare_url(case: Case, base_url: str | None) -> str:
@@ -81,19 +106,19 @@ def prepare_path(path: str, parameters: dict[str, Any] | None) -> str:
         raise InvalidSchema(f"Malformed path template: `{path}`\n\n  {exc}") from exc
 
 
-def prepare_request(case: Case, headers: Mapping[str, Any] | None, sanitize: bool) -> PreparedRequest:
+def prepare_request(case: Case, headers: Mapping[str, Any] | None, *, config: SanitizationConfig) -> PreparedRequest:
     import requests
 
     from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
     base_url = normalize_base_url(case.operation.base_url)
     kwargs = REQUESTS_TRANSPORT.serialize_case(case, base_url=base_url, headers=headers)
-    if sanitize:
-        kwargs["url"] = sanitize_url(kwargs["url"])
-        sanitize_value(kwargs["headers"])
+    if config.enabled:
+        kwargs["url"] = sanitize_url(kwargs["url"], config=config)
+        sanitize_value(kwargs["headers"], config=config)
         if kwargs["cookies"]:
-            sanitize_value(kwargs["cookies"])
+            sanitize_value(kwargs["cookies"], config=config)
         if kwargs["params"]:
-            sanitize_value(kwargs["params"])
+            sanitize_value(kwargs["params"], config=config)
 
     return requests.Request(**kwargs).prepare()

schemathesis/transport/requests.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     from schemathesis.generation.case import Case
 
 
-class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
+class RequestsTransport(BaseTransport["requests.Session"]):
     def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
         base_url = kwargs.get("base_url")
         headers = kwargs.get("headers")
@@ -92,6 +92,7 @@ class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
         if session is None:
             validate_vanilla_requests_kwargs(data)
             session = requests.Session()
+            session.headers = {}
             close_session = True
         else:
             close_session = False
@@ -99,7 +100,9 @@ class RequestsTransport(BaseTransport["Case", Response, "requests.Session"]):
         verify = data.get("verify", True)
 
         try:
-            with ratelimit(case.operation.schema.rate_limiter, case.operation.schema.base_url):
+            config = case.operation.schema.config
+            rate_limit = config.rate_limit_for(operation=case.operation)
+            with ratelimit(rate_limit, config.base_url):
                 response = session.request(**data)  # type: ignore
             return Response.from_requests(response, verify=verify)
         finally:
@@ -133,14 +136,14 @@ REQUESTS_TRANSPORT = RequestsTransport()
 
 
 @REQUESTS_TRANSPORT.serializer("application/json", "text/json")
-def json_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def json_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_json(value)
 
 
 @REQUESTS_TRANSPORT.serializer(
     "text/yaml", "text/x-yaml", "text/vnd.yaml", "text/yml", "application/yaml", "application/x-yaml"
 )
-def yaml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def yaml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_yaml(value)
 
 
@@ -186,7 +189,7 @@ def _encode_multipart(value: Any, boundary: str) -> bytes:
 
 
 @REQUESTS_TRANSPORT.serializer("multipart/form-data", "multipart/mixed")
-def multipart_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         return {"data": value}
     if isinstance(value, dict):
@@ -202,7 +205,7 @@ def multipart_serializer(ctx: SerializationContext[Case], value: Any) -> dict[st
 
 
 @REQUESTS_TRANSPORT.serializer("application/xml", "text/xml")
-def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     media_type = ctx.case.media_type
 
     assert media_type is not None
@@ -214,17 +217,17 @@ def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any
 
 
 @REQUESTS_TRANSPORT.serializer("application/x-www-form-urlencoded")
-def urlencoded_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def urlencoded_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": value}
 
 
 @REQUESTS_TRANSPORT.serializer("text/plain")
-def text_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def text_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         return {"data": value}
     return {"data": str(value).encode("utf8")}
 
 
 @REQUESTS_TRANSPORT.serializer("application/octet-stream")
-def binary_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def binary_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": serialize_binary(value)}

schemathesis/transport/wsgi.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
     import werkzeug
 
 
-class WSGITransport(BaseTransport["Case", Response, "werkzeug.Client"]):
+class WSGITransport(BaseTransport["werkzeug.Client"]):
     def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
         headers = kwargs.get("headers")
         params = kwargs.get("params")
@@ -75,10 +75,9 @@ class WSGITransport(BaseTransport["Case", Response, "werkzeug.Client"]):
         client = session or wsgi.get_client(application)
         cookies = {**(case.cookies or {}), **(cookies or {})}
 
-        with (
-            cookie_handler(client, cookies),
-            ratelimit(case.operation.schema.rate_limiter, case.operation.schema.base_url),
-        ):
+        config = case.operation.schema.config
+        rate_limit = config.rate_limit_for(operation=case.operation)
+        with cookie_handler(client, cookies), ratelimit(rate_limit, config.base_url):
             start = time.monotonic()
             response = client.open(**data)
             elapsed = time.monotonic() - start
@@ -120,24 +119,24 @@ WSGI_TRANSPORT = WSGITransport()
 
 
 @WSGI_TRANSPORT.serializer("application/json", "text/json")
-def json_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def json_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_json(value)
 
 
 @WSGI_TRANSPORT.serializer(
     "text/yaml", "text/x-yaml", "text/vnd.yaml", "text/yml", "application/yaml", "application/x-yaml"
 )
-def yaml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def yaml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return serialize_yaml(value)
 
 
 @WSGI_TRANSPORT.serializer("multipart/form-data", "multipart/mixed")
-def multipart_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": value}
 
 
 @WSGI_TRANSPORT.serializer("application/xml", "text/xml")
-def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     media_type = ctx.case.media_type
 
     assert media_type is not None
@@ -149,17 +148,17 @@ def xml_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any
 
 
 @WSGI_TRANSPORT.serializer("application/x-www-form-urlencoded")
-def urlencoded_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def urlencoded_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": value}
 
 
 @WSGI_TRANSPORT.serializer("text/plain")
-def text_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def text_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     if isinstance(value, bytes):
         return {"data": value}
     return {"data": str(value)}
 
 
 @WSGI_TRANSPORT.serializer("application/octet-stream")
-def binary_serializer(ctx: SerializationContext[Case], value: Any) -> dict[str, Any]:
+def binary_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
     return {"data": serialize_binary(value)}