schemathesis 3.26.2__py3-none-any.whl → 3.27.1__py3-none-any.whl

schemathesis/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import datetime
 import inspect
 import textwrap
@@ -6,7 +7,7 @@ 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 (
@@ -25,51 +26,48 @@ from typing import (
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
-from urllib3.exceptions import ReadTimeoutError
-
-from . import failures, serializers
+from . import serializers
 from ._dependency_versions import IS_WERKZEUG_ABOVE_3
 from .auths import AuthStorage
 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,
     deduplicate_failed_checks,
     get_grouped_exception,
-    get_timeout_error,
+    maybe_set_assertion_message,
     prepare_response_payload,
-    SkipTest,
 )
-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.copy import fast_deepcopy
+from .internal.deprecation import deprecated_property, deprecated_function
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
-from .serializers import Serializer, SerializerContext
-from .transports import serialize_payload
+from .serializers import Serializer
+from .transports import ASGITransport, RequestsTransport, WSGITransport, 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
+
     import requests.auth
-    from .transports.responses import GenericResponse, WSGIResponse
+    import werkzeug
+    from hypothesis import strategies as st
+    from requests.structures import CaseInsensitiveDict
+
     from .schemas import BaseSchema
     from .stateful import Stateful, StatefulTest
+    from .transports.responses import GenericResponse, WSGIResponse
 
 
 @dataclass
@@ -86,7 +84,7 @@ class CaseSource:
 
 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}")
@@ -210,7 +208,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(
@@ -286,40 +284,17 @@ class Case:
             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,
@@ -329,83 +304,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,
@@ -413,10 +326,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(
@@ -425,17 +334,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,
@@ -443,19 +346,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,
@@ -560,12 +461,19 @@ class Case:
         self.validate_response(response, checks, code_sample_style=code_sample_style)
         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)
@@ -922,7 +830,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)

schemathesis/runner/impl/core.py

@@ -21,6 +21,8 @@ from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
 from requests.auth import HTTPDigestAuth, _basic_auth_str
 
+from schemathesis.transports import RequestsTransport
+
 from ... import failures, hooks
 from ..._compat import MultipleFailures
 from ..._hypothesis import (
@@ -297,10 +299,7 @@ def run_probes(schema: BaseSchema, config: probes.ProbeConfig) -> list[probes.Pr
         if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
             from ...specs.openapi._hypothesis import HEADER_FORMAT, header_values
 
-            formats.register(
-                HEADER_FORMAT,
-                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
-            )
+            formats.register(HEADER_FORMAT, header_values(blacklist_characters="\n\r\x00"))
     return results
 
 
@@ -849,7 +848,7 @@ def _network_test(
         response = case.call(**kwargs)
     except CheckFailed as exc:
         check_name = "request_timeout"
-        requests_kwargs = case.as_requests_kwargs(base_url=case.get_full_base_url(), headers=headers)
+        requests_kwargs = RequestsTransport().serialize_case(case, base_url=case.get_full_base_url(), headers=headers)
         request = requests.Request(**requests_kwargs).prepare()
         elapsed = cast(float, timeout)  # It is defined and not empty, since the exception happened
         check_result = result.add_failure(
@@ -939,14 +938,14 @@ def _wsgi_test(
     feedback: Feedback,
     max_response_time: int | None,
 ) -> WSGIResponse:
+    from ...transports.responses import WSGIResponse
+
     with catching_logs(LogCaptureHandler(), level=logging.DEBUG) as recorded:
-        start = time.monotonic()
         hook_context = HookContext(operation=case.operation)
-        kwargs = {"headers": headers}
+        kwargs: dict[str, Any] = {"headers": headers}
         hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
-        response = case.call_wsgi(**kwargs)
-        elapsed = time.monotonic() - start
-    context = TargetContext(case=case, response=response, response_time=elapsed)
+        response = cast(WSGIResponse, case.call(**kwargs))
+    context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
     run_targets(targets, context)
     result.logs.extend(recorded.records)
     status = Status.success
@@ -967,7 +966,7 @@ def _wsgi_test(
     finally:
         feedback.add_test_case(case, response)
         if store_interactions:
-            result.store_wsgi_response(case, response, headers, elapsed, status, check_results)
+            result.store_wsgi_response(case, response, headers, response.elapsed.total_seconds(), status, check_results)
     return response
 
 
@@ -1037,7 +1036,7 @@ def _asgi_test(
     hook_context = HookContext(operation=case.operation)
     kwargs: dict[str, Any] = {"headers": headers}
     hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
-    response = case.call_asgi(**kwargs)
+    response = case.call(**kwargs)
     context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
     run_targets(targets, context)
     status = Status.success

schemathesis/runner/serialization.py

@@ -4,28 +4,30 @@ They all consist of primitive types and don't have references to schemas, app, e
 """
 
 from __future__ import annotations
+
 import logging
 import re
+import textwrap
 from dataclasses import dataclass, field
-from typing import Any, TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
 
-from ..transports import serialize_payload
 from ..code_samples import get_excluded_headers
 from ..exceptions import (
+    BodyInGetRequestError,
+    DeadlineExceeded,
     FailureContext,
     InternalError,
-    make_unique_by_key,
-    format_exception,
-    extract_requests_exception_details,
-    RuntimeErrorType,
-    DeadlineExceeded,
-    OperationSchemaError,
-    BodyInGetRequestError,
     InvalidRegularExpression,
+    OperationSchemaError,
+    RuntimeErrorType,
     SerializationError,
     UnboundPrefixError,
+    extract_requests_exception_details,
+    format_exception,
+    make_unique_by_key,
 )
 from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
+from ..transports import serialize_payload
 
 if TYPE_CHECKING:
     import hypothesis.errors
@@ -108,6 +110,7 @@ class SerializedCheck:
     @classmethod
     def from_check(cls, check: Check) -> SerializedCheck:
         import requests
+
         from ..transports.responses import WSGIResponse
 
         if check.response is not None:
@@ -140,6 +143,25 @@ class SerializedCheck:
             history=history,
         )
 
+    @property
+    def title(self) -> str:
+        if self.context is not None:
+            return self.context.title
+        return f"Custom check failed: `{self.name}`"
+
+    @property
+    def formatted_message(self) -> str | None:
+        if self.context is not None:
+            if self.context.message:
+                message = self.context.message
+            else:
+                message = None
+        else:
+            message = self.message
+        if message is not None:
+            message = textwrap.indent(message, prefix="    ")
+        return message
+
 
 def _get_headers(headers: dict[str, Any] | CaseInsensitiveDict) -> dict[str, str]:
     return {key: value[0] for key, value in headers.items() if key not in get_excluded_headers()}
@@ -203,8 +225,8 @@ class SerializedError:
 
     @classmethod
     def from_exception(cls, exception: Exception) -> SerializedError:
-        import requests
         import hypothesis.errors
+        import requests
         from hypothesis import HealthCheck
 
         title = "Runtime Error"

schemathesis/schemas.py

@@ -8,11 +8,13 @@ They give only static definitions of paths.
 """
 
 from __future__ import annotations
+
 from collections.abc import Mapping, MutableMapping
 from contextlib import nullcontext
 from dataclasses import dataclass, field
 from functools import lru_cache
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     ContextManager,
@@ -22,7 +24,6 @@ from typing import (
     NoReturn,
     Sequence,
     TypeVar,
-    TYPE_CHECKING,
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
@@ -30,23 +31,23 @@ import hypothesis
 from hypothesis.strategies import SearchStrategy
 from pyrate_limiter import Limiter
 
-from .constants import NOT_SET
+from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 from ._hypothesis import create_test
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
+from .constants import NOT_SET
+from .exceptions import OperationSchemaError, UsageError
 from .generation import (
     DEFAULT_DATA_GENERATION_METHODS,
     DataGenerationMethod,
     DataGenerationMethodInput,
     GenerationConfig,
 )
-from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
-from .exceptions import OperationSchemaError, UsageError
 from .hooks import HookContext, HookDispatcher, HookScope, dispatch
-from .internal.result import Result, Ok
+from .internal.result import Ok, Result
 from .models import APIOperation, Case
-from .stateful.state_machine import APIStateMachine
 from .stateful import Stateful, StatefulTest
+from .stateful.state_machine import APIStateMachine
 from .types import (
     Body,
     Cookies,
@@ -58,9 +59,10 @@ from .types import (
     PathParameters,
     Query,
 )
-from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy, combine_strategies
+from .utils import PARAMETRIZE_MARKER, GivenInput, combine_strategies, given_proxy
 
 if TYPE_CHECKING:
+    from .transports import Transport
     from .transports.responses import GenericResponse
 
 
@@ -75,6 +77,7 @@ def get_full_path(base_path: str, path: str) -> str:
 @dataclass(eq=False)
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
+    transport: Transport
     location: str | None = None
     base_url: str | None = None
     method: Filter | None = None
@@ -346,6 +349,7 @@ class BaseSchema(Mapping):
             code_sample_style=code_sample_style,  # type: ignore
             rate_limiter=rate_limiter,  # type: ignore
             sanitize_output=sanitize_output,  # type: ignore
+            transport=self.transport,
         )
 
     def get_local_hook_dispatcher(self) -> HookDispatcher | None:

schemathesis/specs/graphql/loaders.py

@@ -234,6 +234,7 @@ def from_dict(
     :return: GraphQLSchema
     """
     from .schemas import GraphQLSchema
+    from ... import transports
 
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
     hook_context = HookContext()
@@ -252,6 +253,7 @@ def from_dict(
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
+        transport=transports.get(app),
     )  # type: ignore
     dispatch("after_load_schema", hook_context, instance)
     return instance

schemathesis/specs/graphql/schemas.py

@@ -20,7 +20,6 @@ from typing import (
 from urllib.parse import urlsplit, urlunsplit
 
 import graphql
-import requests
 from graphql import GraphQLNamedType
 from hypothesis import strategies as st
 from hypothesis.strategies import SearchStrategy
@@ -60,39 +59,15 @@ class RootType(enum.Enum):
 
 @dataclass(repr=False)
 class GraphQLCase(Case):
-    def as_requests_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
-        final_headers = self._get_headers(headers)
+    def _get_url(self, base_url: str | None) -> str:
         base_url = self._get_base_url(base_url)
         # Replace the path, in case if the user provided any path parameters via hooks
         parts = list(urlsplit(base_url))
         parts[2] = self.formatted_path
-        kwargs: dict[str, Any] = {
-            "method": self.method,
-            "url": urlunsplit(parts),
-            "headers": final_headers,
-            "cookies": self.cookies,
-            "params": self.query,
-        }
-        # There is no direct way to have bytes here, but it is a useful pattern to support.
-        # It also unifies GraphQLCase with its Open API counterpart where bytes may come from external examples
-        if isinstance(self.body, bytes):
-            kwargs["data"] = self.body
-            # Assume that the payload is JSON, not raw GraphQL queries
-            kwargs["headers"].setdefault("Content-Type", "application/json")
-        else:
-            kwargs["json"] = {"query": self.body}
-        return kwargs
-
-    def as_werkzeug_kwargs(self, headers: dict[str, str] | None = None) -> dict[str, Any]:
-        final_headers = self._get_headers(headers)
-        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,
-            "json": {"query": self.body},
-        }
+        return urlunsplit(parts)
+
+    def _get_body(self) -> Body | NotSet:
+        return self.body if isinstance(self.body, (NotSet, bytes)) else {"query": self.body}
 
     def validate_response(
         self,
@@ -107,15 +82,6 @@ class GraphQLCase(Case):
         checks = tuple(check for check in checks if check not in excluded_checks)
         return super().validate_response(response, checks, code_sample_style=code_sample_style)
 
-    def call_asgi(
-        self,
-        app: Any = None,
-        base_url: str | None = None,
-        headers: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> requests.Response:
-        return super().call_asgi(app=app, base_url=base_url, headers=headers, **kwargs)
-
 
 C = TypeVar("C", bound=Case)
 
@@ -287,7 +253,7 @@ class GraphQLSchema(BaseSchema):
             cookies=cookies,
             query=query,
             body=body,
-            media_type=media_type,
+            media_type=media_type or "application/json",
             generation_time=0.0,
         )
 
@@ -373,6 +339,7 @@ def get_case_strategy(
         operation=operation,
         data_generation_method=data_generation_method,
         generation_time=time.monotonic() - start,
+        media_type="application/json",
     )  # type: ignore
     context = auths.AuthContext(
         operation=operation,