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

schemathesis/specs/graphql/schemas.py

@@ -115,6 +115,15 @@ class GraphQLSchema(BaseSchema):
                 return map
         raise KeyError(key)
 
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        if label.startswith(("Query.", "Mutation.")):
+            ty, field = label.split(".", maxsplit=1)
+            try:
+                return self[ty][field]
+            except KeyError:
+                return None
+        return None
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raw_schema = self.raw_schema["__schema"]
         type_names = [type_def["name"] for type_def in raw_schema.get("types", [])]
@@ -223,7 +232,7 @@ class GraphQLSchema(BaseSchema):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         return graphql_cases(
@@ -321,7 +330,7 @@ def graphql_cases(
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
-    generation_mode: GenerationMode = GenerationMode.default(),
+    generation_mode: GenerationMode = GenerationMode.POSITIVE,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
@@ -336,7 +345,7 @@ def graphql_cases(
         RootType.QUERY: gql_st.queries,
         RootType.MUTATION: gql_st.mutations,
     }[definition.root_type]
-    hook_context = HookContext(operation)
+    hook_context = HookContext(operation=operation)
     custom_scalars = {**get_extra_scalar_strategies(), **CUSTOM_SCALARS}
     generation = operation.schema.config.generation_for(operation=operation, phase="fuzzing")
     strategy = strategy_factory(

schemathesis/specs/openapi/_hypothesis.py

@@ -52,7 +52,7 @@ def openapi_cases(
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
-    generation_mode: GenerationMode = GenerationMode.default(),
+    generation_mode: GenerationMode = GenerationMode.POSITIVE,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
@@ -80,18 +80,14 @@ def openapi_cases(
     phase_name = "stateful" if __is_stateful_phase else phase.value
     generation_config = operation.schema.config.generation_for(operation=operation, phase=phase_name)
 
-    context = HookContext(operation)
+    ctx = HookContext(operation=operation)
 
     path_parameters_ = generate_parameter(
-        "path", path_parameters, operation, draw, context, hooks, generation_mode, generation_config
+        "path", path_parameters, operation, draw, ctx, hooks, generation_mode, generation_config
     )
-    headers_ = generate_parameter(
-        "header", headers, operation, draw, context, hooks, generation_mode, generation_config
-    )
-    cookies_ = generate_parameter(
-        "cookie", cookies, operation, draw, context, hooks, generation_mode, generation_config
-    )
-    query_ = generate_parameter("query", query, operation, draw, context, hooks, generation_mode, generation_config)
+    headers_ = generate_parameter("header", headers, operation, draw, ctx, hooks, generation_mode, generation_config)
+    cookies_ = generate_parameter("cookie", cookies, operation, draw, ctx, hooks, generation_mode, generation_config)
+    query_ = generate_parameter("query", query, operation, draw, ctx, hooks, generation_mode, generation_config)
 
     if body is NOT_SET:
         if operation.body:
@@ -108,7 +104,7 @@ def openapi_cases(
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
             strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
-            strategy = apply_hooks(operation, context, hooks, strategy, "body")
+            strategy = apply_hooks(operation, ctx, hooks, strategy, "body")
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
                 operation.schema.transport.get_matching_media_types(parameter.media_type), key=lambda x: x[0]
@@ -219,7 +215,7 @@ def get_parameters_value(
     location: str,
     draw: Callable,
     operation: APIOperation,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     strategy_factory: StrategyFactory,
     generation_config: GenerationConfig,
@@ -231,10 +227,10 @@ def get_parameters_value(
     """
     if isinstance(value, NotSet) or not value:
         strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config)
-        strategy = apply_hooks(operation, context, hooks, strategy, location)
+        strategy = apply_hooks(operation, ctx, hooks, strategy, location)
         return draw(strategy)
     strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config, exclude=value.keys())
-    strategy = apply_hooks(operation, context, hooks, strategy, location)
+    strategy = apply_hooks(operation, ctx, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
         copied = deepclone(value)
@@ -272,7 +268,7 @@ def generate_parameter(
     explicit: NotSet | dict[str, Any],
     operation: APIOperation,
     draw: Callable,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     generator: GenerationMode,
     generation_config: GenerationConfig,
@@ -291,9 +287,7 @@ def generate_parameter(
         generator = GenerationMode.POSITIVE
     else:
         strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generator]
-    value = get_parameters_value(
-        explicit, location, draw, operation, context, hooks, strategy_factory, generation_config
-    )
+    value = get_parameters_value(explicit, location, draw, operation, ctx, hooks, strategy_factory, generation_config)
     used_generator: GenerationMode | None = generator
     if value == explicit:
         # When we pass `explicit`, then its parts are excluded from generation of the final value
@@ -494,11 +488,11 @@ def quote_all(parameters: dict[str, Any]) -> dict[str, Any]:
 
 def apply_hooks(
     operation: APIOperation,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     strategy: st.SearchStrategy,
     location: str,
 ) -> st.SearchStrategy:
     """Apply all hooks related to the given location."""
     container = LOCATION_TO_CONTAINER[location]
-    return apply_to_all_dispatchers(operation, context, hooks, strategy, container)
+    return apply_to_all_dispatchers(operation, ctx, hooks, strategy, container)

schemathesis/specs/openapi/checks.py

@@ -352,12 +352,12 @@ def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool |
     if response.status_code == 404 or response.status_code >= 500:
         return None
 
-    for related_case in ctx.find_related(case_id=case.id):
-        parent = ctx.find_parent(case_id=related_case.id)
+    for related_case in ctx._find_related(case_id=case.id):
+        parent = ctx._find_parent(case_id=related_case.id)
         if not parent:
             continue
 
-        parent_response = ctx.find_response(case_id=parent.id)
+        parent_response = ctx._find_response(case_id=parent.id)
 
         if (
             related_case.operation.method.lower() == "delete"
@@ -395,10 +395,10 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
     if not (400 <= response.status_code < 500):
         return None
 
-    parent = ctx.find_parent(case_id=case.id)
+    parent = ctx._find_parent(case_id=case.id)
     if parent is None:
         return None
-    parent_response = ctx.find_response(case_id=parent.id)
+    parent_response = ctx._find_response(case_id=parent.id)
     if parent_response is None:
         return None
 
@@ -424,8 +424,8 @@ def ensure_resource_availability(ctx: CheckContext, response: Response, case: Ca
         return None
 
     # Look for any successful DELETE operations on this resource
-    for related_case in ctx.find_related(case_id=case.id):
-        related_response = ctx.find_response(case_id=related_case.id)
+    for related_case in ctx._find_related(case_id=case.id):
+        related_response = ctx._find_response(case_id=related_case.id)
         if (
             related_case.operation.method.upper() == "DELETE"
             and related_response is not None
@@ -478,25 +478,25 @@ def ignored_auth(ctx: CheckContext, response: Response, case: Case) -> bool | No
             # Auth is explicitly set, it is expected to be valid
             # Check if invalid auth will give an error
             no_auth_case = remove_auth(case, security_parameters)
-            kwargs = ctx.transport_kwargs or {}
+            kwargs = ctx._transport_kwargs or {}
             kwargs.copy()
             if "headers" in kwargs:
                 headers = kwargs["headers"].copy()
                 _remove_auth_from_explicit_headers(headers, security_parameters)
                 kwargs["headers"] = headers
             kwargs.pop("session", None)
-            ctx.record_case(parent_id=case.id, case=no_auth_case)
+            ctx._record_case(parent_id=case.id, case=no_auth_case)
             no_auth_response = case.operation.schema.transport.send(no_auth_case, **kwargs)
-            ctx.record_response(case_id=no_auth_case.id, response=no_auth_response)
+            ctx._record_response(case_id=no_auth_case.id, response=no_auth_response)
             if no_auth_response.status_code != 401:
                 _raise_no_auth_error(no_auth_response, no_auth_case, "that requires authentication")
             # Try to set invalid auth and check if it succeeds
             for parameter in security_parameters:
                 invalid_auth_case = remove_auth(case, security_parameters)
                 _set_auth_for_case(invalid_auth_case, parameter)
-                ctx.record_case(parent_id=case.id, case=invalid_auth_case)
+                ctx._record_case(parent_id=case.id, case=invalid_auth_case)
                 invalid_auth_response = case.operation.schema.transport.send(invalid_auth_case, **kwargs)
-                ctx.record_response(case_id=invalid_auth_case.id, response=invalid_auth_response)
+                ctx._record_response(case_id=invalid_auth_case.id, response=invalid_auth_response)
                 if invalid_auth_response.status_code != 401:
                     _raise_no_auth_error(invalid_auth_response, invalid_auth_case, "with any auth")
         elif auth == AuthKind.GENERATED:
@@ -540,7 +540,7 @@ def _contains_auth(
     from requests.cookies import RequestsCookieJar
 
     # If auth comes from explicit `auth` option or a custom auth, it is always explicit
-    if ctx.auth is not None or case._has_explicit_auth:
+    if ctx._auth is not None or case._has_explicit_auth:
         return AuthKind.EXPLICIT
     parsed = urlparse(request.url)
     query = parse_qs(parsed.query)  # type: ignore
@@ -563,19 +563,19 @@ def _contains_auth(
     for parameter in security_parameters:
         name = parameter["name"]
         if has_header(parameter):
-            if (ctx.headers is not None and name in ctx.headers) or (ctx.override and name in ctx.override.headers):
+            if (ctx._headers is not None and name in ctx._headers) or (ctx._override and name in ctx._override.headers):
                 return AuthKind.EXPLICIT
             return AuthKind.GENERATED
         if has_cookie(parameter):
-            if ctx.headers is not None and "Cookie" in ctx.headers:
-                cookies = cast(RequestsCookieJar, ctx.headers["Cookie"])  # type: ignore
+            if ctx._headers is not None and "Cookie" in ctx._headers:
+                cookies = cast(RequestsCookieJar, ctx._headers["Cookie"])  # type: ignore
                 if name in cookies:
                     return AuthKind.EXPLICIT
-            if ctx.override and name in ctx.override.cookies:
+            if ctx._override and name in ctx._override.cookies:
                 return AuthKind.EXPLICIT
             return AuthKind.GENERATED
         if has_query(parameter):
-            if ctx.override and name in ctx.override.query:
+            if ctx._override and name in ctx._override.query:
                 return AuthKind.EXPLICIT
             return AuthKind.GENERATED
 
@@ -628,6 +628,9 @@ def _set_auth_for_case(case: Case, parameter: SecurityParameter) -> None:
     ):
         if parameter["in"] == location:
             container = getattr(case, attr_name, {})
+            # Could happen in the negative testing mode
+            if not isinstance(container, dict):
+                container = {}
             container[name] = "SCHEMATHESIS-INVALID-VALUE"
             setattr(case, attr_name, container)
 

schemathesis/specs/openapi/formats.py

@@ -15,10 +15,37 @@ STRING_FORMATS: dict[str, st.SearchStrategy] = {}
 
 
 def register_string_format(name: str, strategy: st.SearchStrategy) -> None:
-    """Register a new strategy for generating data for specific string "format".
+    r"""Register a custom Hypothesis strategy for generating string format data.
+
+    Args:
+        name: String format name that matches the "format" keyword in your API schema
+        strategy: Hypothesis strategy to generate values for this format
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register phone number format
+        phone_strategy = st.from_regex(r"\+1-\d{3}-\d{3}-\d{4}")
+        schemathesis.openapi.format("phone", phone_strategy)
+
+        # Register email with specific domain
+        email_strategy = st.from_regex(r"[a-z]+@company\.com")
+        schemathesis.openapi.format("company-email", email_strategy)
+        ```
+
+    Schema usage:
+        ```yaml
+        properties:
+          phone:
+            type: string
+            format: phone          # Uses your phone_strategy
+          contact_email:
+            type: string
+            format: company-email  # Uses your email_strategy
+        ```
 
-    :param str name: Format name. It should correspond the one used in the API schema as the "format" keyword value.
-    :param strategy: Hypothesis strategy you'd like to use to generate values for this format.
     """
     from hypothesis.strategies import SearchStrategy
 

schemathesis/specs/openapi/media_types.py

@@ -15,7 +15,50 @@ MEDIA_TYPES: dict[str, st.SearchStrategy[bytes]] = {}
 
 
 def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliases: Collection[str] = ()) -> None:
-    """Register a strategy for the given media type."""
+    r"""Register a custom Hypothesis strategy for generating media type content.
+
+    Args:
+        name: Media type name that matches your OpenAPI requestBody content type
+        strategy: Hypothesis strategy that generates bytes for this media type
+        aliases: Additional media type names that use the same strategy
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register PDF file strategy
+        pdf_strategy = st.sampled_from([
+            b"%PDF-1.4\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF",
+            b"%PDF-1.5\n%\xe2\xe3\xcf\xd3\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF"
+        ])
+        schemathesis.openapi.media_type("application/pdf", pdf_strategy)
+
+        # Dynamic content generation
+        @st.composite
+        def xml_content(draw):
+            tag = draw(st.text(min_size=3, max_size=10))
+            content = draw(st.text(min_size=1, max_size=50))
+            return f"<?xml version='1.0'?><{tag}>{content}</{tag}>".encode()
+
+        schemathesis.openapi.media_type("application/xml", xml_content())
+        ```
+
+    Schema usage:
+        ```yaml
+        requestBody:
+          content:
+            application/pdf:        # Uses your PDF strategy
+              schema:
+                type: string
+                format: binary
+            application/xml:        # Uses your XML strategy
+              schema:
+                type: string
+                format: binary
+        ```
+
+    """
 
     @REQUESTS_TRANSPORT.serializer(name, *aliases)
     @ASGI_TRANSPORT.serializer(name, *aliases)

schemathesis/specs/openapi/schemas.py

@@ -120,13 +120,18 @@ class BaseOpenAPISchema(BaseSchema):
         if map is not None:
             return map
         path_item = self.raw_schema.get("paths", {})[path]
-        scope, path_item = self._resolve_path_item(path_item)
+        with in_scope(self.resolver, self.location or ""):
+            scope, path_item = self._resolve_path_item(path_item)
         self.dispatch_hook("before_process_path", HookContext(), path, path_item)
         map = APIOperationMap(self, {})
         map._data = MethodMap(map, scope, path, CaseInsensitiveDict(path_item))
         cache.insert_map(path, map)
         return map
 
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        method, path = label.split(" ", maxsplit=1)
+        return self[path][method]
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         matches = get_close_matches(item, list(self))
         self._on_missing_operation(item, exc, matches)
@@ -536,7 +541,7 @@ class BaseOpenAPISchema(BaseSchema):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         return openapi_cases(
@@ -658,6 +663,7 @@ class BaseOpenAPISchema(BaseSchema):
         return jsonschema.Draft4Validator
 
     def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
+        __tracebackhide__ = True
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
         status_code = str(response.status_code)
         if status_code in responses:

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__()
 

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,5 +1,6 @@
 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
 
@@ -8,6 +9,7 @@ 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
@@ -16,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:

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
@@ -135,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)
 
 
@@ -188,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):
@@ -204,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
@@ -216,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)}