schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/transport/__init__.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from inspect import iscoroutinefunction
+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."""
+    from schemathesis.transport.asgi import ASGI_TRANSPORT
+    from schemathesis.transport.requests import REQUESTS_TRANSPORT
+    from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+    if app is None:
+        return REQUESTS_TRANSPORT
+    if iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    ):
+        return ASGI_TRANSPORT
+    return WSGI_TRANSPORT
+
+
+S = TypeVar("S", contravariant=True)
+
+
+@dataclass
+class SerializationContext:
+    """Context object passed to serializer functions.
+
+    It provides access to the generated test case and any related metadata.
+    """
+
+    case: Case
+    """The generated test case."""
+
+    __slots__ = ("case",)
+
+
+Serializer = Callable[[SerializationContext, Any], Any]
+
+
+class BaseTransport(Generic[S]):
+    """Base implementation with serializer registration."""
+
+    def __init__(self) -> None:
+        self._serializers: dict[str, Serializer] = {}
+
+    def serialize_case(self, case: Case, **kwargs: Any) -> dict[str, Any]:
+        """Prepare the case for sending."""
+        raise NotImplementedError
+
+    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], Serializer]:
+        """Register a serializer for given media types."""
+
+        def decorator(func: Serializer) -> Serializer:
+            for media_type in media_types:
+                self._serializers[media_type] = func
+            return func
+
+        return decorator
+
+    def unregister_serializer(self, *media_types: str) -> None:
+        for media_type in media_types:
+            self._serializers.pop(media_type, None)
+
+    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] | None:
+        return next(self.get_matching_media_types(media_type), None)
+
+    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
+            yield from iter(self._serializers.items())
+        else:
+            main, sub = media_types.parse(media_type)
+            checks = [
+                media_types.is_json,
+                media_types.is_xml,
+                media_types.is_plain_text,
+                media_types.is_yaml,
+            ]
+            for registered_media_type, serializer in self._serializers.items():
+                # Try known variations for popular media types and fallback to comparison
+                if any(check(media_type) and check(registered_media_type) for check in checks):
+                    yield media_type, serializer
+                else:
+                    target_main, target_sub = media_types.parse(registered_media_type)
+                    if main in ("*", target_main) and sub in ("*", target_sub):
+                        yield registered_media_type, serializer
+
+    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]]
+
+
+class SerializerRegistry:
+    """Registry for serializers with aliasing support."""
+
+    def __call__(self, *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.
+
+        Example:
+            ```python
+            @schemathesis.serializer("text/csv")
+            def csv_serializer(ctx, value):
+                # Convert value to CSV bytes
+                return csv_bytes
+            ```
+
+        """
+
+        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
+
+    def alias(self, target: str | list[str], source: str) -> None:
+        """Reuse an existing serializer for additional media types.
+
+        Register alias(es) for a built-in or previously registered serializer without
+        duplicating implementation.
+
+        Args:
+            target: Media type(s) to register as aliases
+            source: Existing media type whose serializer to reuse
+
+        Raises:
+            ValueError: If source media type has no registered serializer
+            ValueError: If target is empty
+
+        Example:
+            ```python
+            # Reuse built-in YAML serializer for custom media type
+            schemathesis.serializer.alias("application/custom+yaml", "application/yaml")
+
+            # Reuse built-in JSON serializer for vendor-specific type
+            schemathesis.serializer.alias("application/vnd.api+json", "application/json")
+
+            # Register multiple aliases at once
+            schemathesis.serializer.alias(
+                ["application/x-json", "text/json"],
+                "application/json"
+            )
+            ```
+
+        """
+        from schemathesis.transport.asgi import ASGI_TRANSPORT
+        from schemathesis.transport.requests import REQUESTS_TRANSPORT
+        from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+        if not source:
+            raise ValueError("Source media type cannot be empty")
+
+        targets = [target] if isinstance(target, str) else target
+
+        if not targets or any(not t for t in targets):
+            raise ValueError("Target media type cannot be empty")
+
+        # Get serializer from source (use requests transport as reference)
+        pair = REQUESTS_TRANSPORT.get_first_matching_media_type(source)
+        if pair is None:
+            raise ValueError(f"No serializer found for media type: {source}")
+
+        _, serializer_func = pair
+
+        # Register for all targets across all transports
+        for t in targets:
+            REQUESTS_TRANSPORT._serializers[t] = serializer_func
+            ASGI_TRANSPORT._serializers[t] = serializer_func
+            WSGI_TRANSPORT._serializers[t] = serializer_func
+
+
+serializer = SerializerRegistry()
+serializer.__doc__ = """Registry for serializers with decorator and aliasing support.
+
+Use as a decorator to register custom serializers:
+
+    @schemathesis.serializer("text/csv")
+    def csv_serializer(ctx, value):
+        # Convert value to CSV bytes
+        return csv_bytes
+
+Or use the alias method to reuse built-in serializers:
+
+    schemathesis.serializer.alias("application/custom+yaml", "application/yaml")
+"""

schemathesis/transport/asgi.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core.transport import Response
+from schemathesis.generation.case import Case
+from schemathesis.python import asgi
+from schemathesis.transport.prepare import normalize_base_url
+from schemathesis.transport.requests import REQUESTS_TRANSPORT, RequestsTransport
+
+if TYPE_CHECKING:
+    import requests
+
+
+class ASGITransport(RequestsTransport):
+    def send(self, case: Case, *, session: requests.Session | None = None, **kwargs: Any) -> Response:
+        if kwargs.get("base_url") is None:
+            kwargs["base_url"] = normalize_base_url(case.operation.base_url)
+        application = kwargs.pop("app", case.operation.app)
+
+        with asgi.get_client(application) as client:
+            return super().send(case, session=client, **kwargs)
+
+
+ASGI_TRANSPORT = ASGITransport()
+ASGI_TRANSPORT._copy_serializers_from(REQUESTS_TRANSPORT)

schemathesis/transport/prepare.py

@@ -0,0 +1,126 @@
+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.parameters import ParameterLocation
+from schemathesis.core.transport import USER_AGENT
+from schemathesis.generation.meta import CoveragePhaseData, CoverageScenario
+
+if TYPE_CHECKING:
+    from requests import PreparedRequest
+    from requests.structures import CaseInsensitiveDict
+
+    from schemathesis.generation.case import Case
+
+
+@lru_cache()
+def get_default_headers() -> CaseInsensitiveDict:
+    from requests.utils import default_headers
+
+    headers = default_headers()
+    headers["User-Agent"] = USER_AGENT
+    return headers
+
+
+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:
+        default_headers.update(headers)
+    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.scenario == CoverageScenario.MISSING_PARAMETER
+        and case.meta.phase.data.parameter_location == ParameterLocation.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:
+    """Prepare URL based on case type."""
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+    base_url = base_url or case.operation.base_url
+    assert base_url is not None
+    path = prepare_path(case.path, case.path_parameters)
+
+    if isinstance(case.operation.schema, GraphQLSchema):
+        parts = list(urlsplit(base_url))
+        parts[2] = path
+        return urlunsplit(parts)
+    else:
+        path = path.lstrip("/")
+        if not base_url.endswith("/"):
+            base_url += "/"
+        return unquote(urljoin(base_url, quote(path)))
+
+
+def prepare_body(case: Case) -> list | dict[str, Any] | str | int | float | bool | bytes | NotSet:
+    """Prepare body based on case type."""
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+    if isinstance(case.operation.schema, GraphQLSchema):
+        return case.body if isinstance(case.body, (NotSet, bytes)) else {"query": case.body}
+    return case.body
+
+
+def normalize_base_url(base_url: str | None) -> str | None:
+    """Normalize base URL by ensuring proper hostname for local URLs.
+
+    If URL has no hostname (typical for WSGI apps), adds "localhost" as default hostname.
+    """
+    if base_url is None:
+        return None
+    parts = urlsplit(base_url)
+    if not parts.hostname:
+        path = cast(str, parts.path or "")
+        return urlunsplit(("http", "localhost", path or "", "", ""))
+    return base_url
+
+
+def prepare_path(path: str, parameters: dict[str, Any] | None) -> str:
+    try:
+        return path.format(**parameters or {})
+    except KeyError as exc:
+        # This may happen when a path template has a placeholder for variable "X", but parameter "X" is not defined
+        # in the parameters list.
+        # When `exc` is formatted, it is the missing key name in quotes. E.g. 'id'
+        raise InvalidSchema(f"Path parameter {exc} is not defined") from exc
+    except (IndexError, ValueError) as exc:
+        # A single unmatched `}` inside the path template may cause this
+        raise InvalidSchema(f"Malformed path template: `{path}`\n\n  {exc}") from exc
+
+
+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 config.enabled:
+        kwargs["url"] = sanitize_url(kwargs["url"], config=config)
+        kwargs["headers"] = dict(kwargs["headers"])
+        sanitize_value(kwargs["headers"], config=config)
+        if kwargs["cookies"]:
+            kwargs["cookies"] = dict(kwargs["cookies"])
+            sanitize_value(kwargs["cookies"], config=config)
+        if kwargs["params"]:
+            kwargs["params"] = dict(kwargs["params"])
+            sanitize_value(kwargs["params"], config=config)
+
+    return requests.Request(**kwargs).prepare()

schemathesis/transport/requests.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import binascii
+import inspect
+import os
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, MutableMapping
+from urllib.parse import urlparse
+
+from schemathesis.core import NotSet
+from schemathesis.core.rate_limit import ratelimit
+from schemathesis.core.transforms import merge_at
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT, Response
+from schemathesis.generation.overrides import Override
+from schemathesis.transport import BaseTransport, SerializationContext
+from schemathesis.transport.prepare import get_exclude_headers, prepare_body, prepare_headers, prepare_url
+from schemathesis.transport.serialization import Binary, serialize_binary, serialize_json, serialize_xml, serialize_yaml
+
+if TYPE_CHECKING:
+    import requests
+
+    from schemathesis.generation.case import Case
+
+
+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")
+        params = kwargs.get("params")
+        cookies = kwargs.get("cookies")
+
+        final_headers = prepare_headers(case, headers)
+
+        media_type = case.media_type
+
+        # Set content type header if needed
+        if media_type and media_type != "multipart/form-data" and not isinstance(case.body, NotSet):
+            if "content-type" not in final_headers:
+                final_headers["Content-Type"] = media_type
+
+        url = prepare_url(case, base_url)
+
+        # Handle serialization
+        if not isinstance(case.body, NotSet) and media_type is not None:
+            serializer = self._get_serializer(media_type)
+            context = SerializationContext(case=case)
+            extra = serializer(context, prepare_body(case))
+        else:
+            extra = {}
+
+        if case._auth is not None:
+            extra["auth"] = case._auth
+
+        # Additional headers from serializer
+        additional_headers = extra.pop("headers", None)
+        if additional_headers:
+            for key, value in additional_headers.items():
+                final_headers.setdefault(key, value)
+
+        params = case.query
+
+        # Replace empty dictionaries with empty strings, so the parameters actually present in the query string
+        if any(value == {} for value in (params or {}).values()):
+            params = dict(params)
+            for key, value in params.items():
+                if value == {}:
+                    params[key] = ""
+
+        data = {
+            "method": case.method,
+            "url": url,
+            "cookies": case.cookies,
+            "headers": final_headers,
+            "params": params,
+            **extra,
+        }
+
+        if params is not None:
+            merge_at(data, "params", params)
+        if cookies is not None:
+            merge_at(data, "cookies", cookies)
+
+        excluded_headers = get_exclude_headers(case)
+        for name in excluded_headers:
+            data["headers"].pop(name, None)
+
+        return data
+
+    def send(self, case: Case, *, session: requests.Session | None = None, **kwargs: Any) -> Response:
+        import requests
+
+        config = case.operation.schema.config
+
+        max_redirects = kwargs.pop("max_redirects", None) or config.max_redirects_for(operation=case.operation)
+        timeout = config.request_timeout_for(operation=case.operation)
+        verify = config.tls_verify_for(operation=case.operation)
+        cert = config.request_cert_for(operation=case.operation)
+
+        if session is not None and session.headers:
+            # These headers are explicitly provided via config or CLI args.
+            # They have lower priority than ones provided via `kwargs`
+            headers = kwargs.setdefault("headers", {}) or {}
+            for name, value in session.headers.items():
+                headers.setdefault(name, value)
+            kwargs["headers"] = headers
+
+        data = self.serialize_case(case, **kwargs)
+
+        if verify is not None:
+            data.setdefault("verify", verify)
+        if timeout is not None:
+            data.setdefault("timeout", timeout)
+        if cert is not None:
+            data.setdefault("cert", cert)
+
+        kwargs.pop("base_url", None)
+        for key, value in kwargs.items():
+            if key not in ("headers", "cookies", "params") or key not in data:
+                data[key] = value
+        data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT)
+
+        current_session_headers: MutableMapping[str, Any] = {}
+        current_session_auth = None
+
+        if session is None:
+            validate_vanilla_requests_kwargs(data)
+            session = requests.Session()
+            close_session = True
+        else:
+            current_session_headers = session.headers
+            if isinstance(session.auth, tuple):
+                excluded_headers = get_exclude_headers(case)
+                if "Authorization" in excluded_headers:
+                    current_session_auth = session.auth
+                    session.auth = None
+            close_session = False
+        if max_redirects is not None:
+            session.max_redirects = max_redirects
+        session.headers = {}
+
+        verify = data.get("verify", True)
+
+        try:
+            rate_limit = config.rate_limit_for(operation=case.operation)
+            with ratelimit(rate_limit, config.base_url):
+                response = session.request(**data)
+            return Response.from_requests(
+                response,
+                verify=verify,
+                _override=Override(
+                    query=kwargs.get("params") or {},
+                    headers=kwargs.get("headers") or {},
+                    cookies=kwargs.get("cookies") or {},
+                    path_parameters={},
+                    body={},
+                ),
+            )
+        finally:
+            session.headers = current_session_headers
+            if current_session_auth is not None:
+                session.auth = current_session_auth
+            if close_session:
+                session.close()
+
+
+def validate_vanilla_requests_kwargs(data: dict[str, Any]) -> None:
+    """Check arguments for `requests.Session.request`.
+
+    Some arguments can be valid for cases like ASGI integration, but at the same time they won't work for the regular
+    `requests` calls. In such cases we need to avoid an obscure error message, that comes from `requests`.
+    """
+    url = data["url"]
+    if not urlparse(url).netloc:
+        stack = inspect.stack()
+        method_name = "call"
+        for frame in stack[1:]:
+            if frame.function == "call_and_validate":
+                method_name = "call_and_validate"
+                break
+        raise RuntimeError(
+            "The `base_url` argument is required when specifying a schema via a file, so Schemathesis knows where to send the data. \n"
+            f"Pass `base_url` either to the `schemathesis.openapi.from_*` loader or to the `Case.{method_name}`.\n"
+            f"If you use the ASGI integration, please supply your test client "
+            f"as the `session` argument to `call`.\nURL: {url}"
+        )
+
+
+REQUESTS_TRANSPORT = RequestsTransport()
+
+
+@REQUESTS_TRANSPORT.serializer("application/json", "text/json")
+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, value: Any) -> dict[str, Any]:
+    return serialize_yaml(value)
+
+
+def _should_coerce_to_bytes(item: Any) -> bool:
+    """Whether the item should be converted to bytes."""
+    # These types are OK in forms, others should be coerced to bytes
+    return isinstance(item, Binary) or not isinstance(item, (bytes, str, int))
+
+
+def _prepare_form_data(data: dict[str, Any]) -> dict[str, Any]:
+    """Make the generated data suitable for sending as multipart.
+
+    If the schema is loose, Schemathesis can generate data that can't be sent as multipart. In these cases,
+    we convert it to bytes and send it as-is, ignoring any conversion errors.
+
+    NOTE. This behavior might change in the future.
+    """
+    for name, value in data.items():
+        if isinstance(value, list):
+            data[name] = [serialize_binary(item) if _should_coerce_to_bytes(item) else item for item in value]
+        elif _should_coerce_to_bytes(value):
+            data[name] = serialize_binary(value)
+    return data
+
+
+def choose_boundary() -> str:
+    """Random boundary name."""
+    return binascii.hexlify(os.urandom(16)).decode("ascii")
+
+
+def _encode_multipart(value: Any, boundary: str) -> bytes:
+    """Encode any value as multipart.
+
+    NOTE. It doesn't aim to be 100% correct multipart payload, but rather a way to send data which is not intended to
+    be used as multipart, in cases when the API schema dictates so.
+    """
+    # For such cases we stringify the value and wrap it to a randomly-generated boundary
+    body = BytesIO()
+    body.write(f"--{boundary}\r\n".encode())
+    body.write(str(value).encode())
+    body.write(f"--{boundary}--\r\n".encode("latin-1"))
+    return body.getvalue()
+
+
+@REQUESTS_TRANSPORT.serializer("multipart/form-data", "multipart/mixed")
+def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+    if isinstance(value, bytes):
+        return {"data": value}
+    if isinstance(value, dict):
+        multipart = _prepare_form_data(value)
+        files, data = ctx.case.operation.prepare_multipart(multipart)
+        return {"files": files, "data": data}
+    # Uncommon schema. For example - `{"type": "string"}`
+    boundary = choose_boundary()
+    raw_data = _encode_multipart(value, boundary)
+    content_type = f"multipart/form-data; boundary={boundary}"
+    return {"data": raw_data, "headers": {"Content-Type": content_type}}
+
+
+@REQUESTS_TRANSPORT.serializer("application/xml", "text/xml")
+def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+    return serialize_xml(ctx.case, value)
+
+
+@REQUESTS_TRANSPORT.serializer("application/x-www-form-urlencoded")
+def urlencoded_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+    return {"data": value}
+
+
+@REQUESTS_TRANSPORT.serializer("text/plain")
+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, value: Any) -> dict[str, Any]:
+    return {"data": serialize_binary(value)}