schemathesis 3.39.16__py3-none-any.whl → 4.0.0__py3-none-any.whl

schemathesis/specs/openapi/stateful/links.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Any, Callable, Generator, Literal, cast
+
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
+from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi import expressions
+from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+from schemathesis.specs.openapi.references import RECURSION_DEPTH_LIMIT
+
+SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
+ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
+
+
+@dataclass
+class NormalizedParameter:
+    """Processed link parameter with resolved container information."""
+
+    location: ParameterLocation | None
+    name: str
+    expression: str
+    container_name: str
+
+    __slots__ = ("location", "name", "expression", "container_name")
+
+
+@dataclass(repr=False)
+class OpenApiLink:
+    """Represents an OpenAPI link between operations."""
+
+    name: str
+    status_code: str
+    source: APIOperation
+    target: APIOperation
+    parameters: list[NormalizedParameter]
+    body: dict[str, Any] | NotSet
+    merge_body: bool
+
+    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
+
+    def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+        self.name = name
+        self.status_code = status_code
+        self.source = source
+        assert isinstance(source.schema, BaseOpenAPISchema)
+        errors = []
+
+        get_operation: Callable[[str], APIOperation]
+        if "operationId" in definition:
+            operation_reference = definition["operationId"]
+            get_operation = source.schema.get_operation_by_id
+        else:
+            operation_reference = definition["operationRef"]
+            get_operation = source.schema.get_operation_by_reference
+
+        try:
+            self.target = get_operation(operation_reference)
+            target = self.target.label
+        except OperationNotFound:
+            target = operation_reference
+            errors.append(TransitionValidationError(f"Operation '{operation_reference}' not found"))
+
+        extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
+        self.parameters = self._normalize_parameters(definition.get("parameters", {}), errors)
+        self.body = definition.get("requestBody", NOT_SET)
+        self.merge_body = extension.get("merge_body", True) if extension else True
+
+        if errors:
+            raise InvalidTransition(
+                name=self.name,
+                source=self.source.label,
+                target=target,
+                status_code=self.status_code,
+                errors=errors,
+            )
+
+        self._cached_extract = lru_cache(8)(self._extract_impl)
+
+    def _normalize_parameters(
+        self, parameters: dict[str, str], errors: list[TransitionValidationError]
+    ) -> list[NormalizedParameter]:
+        """Process link parameters and resolve their container locations.
+
+        Handles both explicit locations (e.g., "path.id") and implicit ones resolved from target operation.
+        """
+        result = []
+        for parameter, expression in parameters.items():
+            location: ParameterLocation | None
+            try:
+                # The parameter name is prefixed with its location. Example: `path.id`
+                _location, name = tuple(parameter.split("."))
+                location = cast(ParameterLocation, _location)
+            except ValueError:
+                location = None
+                name = parameter
+
+            if isinstance(expression, str):
+                try:
+                    parsed = expressions.parser.parse(expression)
+                    # Find NonBodyRequest nodes that reference source parameters
+                    for node in parsed:
+                        if isinstance(node, expressions.nodes.NonBodyRequest):
+                            # Check if parameter exists in source operation
+                            if not any(
+                                p.name == node.parameter and p.location == node.location
+                                for p in self.source.iter_parameters()
+                            ):
+                                errors.append(
+                                    TransitionValidationError(
+                                        f"Expression `{expression}` references non-existent {node.location} parameter "
+                                        f"`{node.parameter}` in `{self.source.label}`"
+                                    )
+                                )
+                except Exception as exc:
+                    errors.append(TransitionValidationError(str(exc)))
+
+            if hasattr(self, "target"):
+                try:
+                    container_name = self._get_parameter_container(location, name)
+                except TransitionValidationError as exc:
+                    errors.append(exc)
+                    continue
+            else:
+                continue
+            result.append(NormalizedParameter(location, name, expression, container_name))
+        return result
+
+    def _get_parameter_container(self, location: ParameterLocation | None, name: str) -> str:
+        """Resolve parameter container either from explicit location or by looking up in target operation."""
+        if location:
+            return LOCATION_TO_CONTAINER[location]
+
+        for param in self.target.iter_parameters():
+            if param.name == name:
+                return LOCATION_TO_CONTAINER[param.location]
+        raise TransitionValidationError(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
+
+    def extract(self, output: StepOutput) -> Transition:
+        return self._cached_extract(StepOutputWrapper(output))
+
+    def _extract_impl(self, wrapper: StepOutputWrapper) -> Transition:
+        output = wrapper.output
+        return Transition(
+            id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
+            parent_id=output.case.id,
+            parameters=self.extract_parameters(output),
+            request_body=self.extract_body(output),
+        )
+
+    def extract_parameters(self, output: StepOutput) -> dict[str, dict[str, ExtractedParam]]:
+        """Extract parameters using runtime expressions.
+
+        Returns a two-level dictionary: container -> parameter name -> extracted value
+        """
+        extracted: dict[str, dict[str, ExtractedParam]] = {}
+        for parameter in self.parameters:
+            container = extracted.setdefault(parameter.container_name, {})
+            value: Result[Any, Exception]
+            try:
+                value = Ok(expressions.evaluate(parameter.expression, output))
+            except Exception as exc:
+                value = Err(exc)
+            container[parameter.name] = ExtractedParam(definition=parameter.expression, value=value)
+        return extracted
+
+    def extract_body(self, output: StepOutput) -> ExtractedParam | None:
+        if not isinstance(self.body, NotSet):
+            value: Result[Any, Exception]
+            try:
+                value = Ok(expressions.evaluate(self.body, output, evaluate_nested=True))
+            except Exception as exc:
+                value = Err(exc)
+            return ExtractedParam(definition=self.body, value=value)
+        return None
+
+
+@dataclass
+class StepOutputWrapper:
+    """Wrapper for StepOutput that uses only case_id for hash-based caching."""
+
+    output: StepOutput
+    __slots__ = ("output",)
+
+    def __hash__(self) -> int:
+        return hash(self.output.case.id)
+
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, StepOutputWrapper)
+        return self.output.case.id == other.output.case.id
+
+
+def get_all_links(
+    operation: APIOperation,
+) -> Generator[tuple[str, Result[OpenApiLink, InvalidTransition]], None, None]:
+    for status_code, definition in operation.definition.raw["responses"].items():
+        definition = operation.schema.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)  # type: ignore[attr-defined]
+        for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
+            try:
+                link = OpenApiLink(name, status_code, link_definition, operation)
+                yield status_code, Ok(link)
+            except InvalidTransition as exc:
+                yield status_code, Err(exc)

schemathesis/transport/__init__.py

@@ -0,0 +1,142 @@
+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]]
+
+
+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/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,124 @@
+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
+    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)
+    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:
+    """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)
+        sanitize_value(kwargs["headers"], config=config)
+        if kwargs["cookies"]:
+            sanitize_value(kwargs["cookies"], config=config)
+        if kwargs["params"]:
+            sanitize_value(kwargs["params"], config=config)
+
+    return requests.Request(**kwargs).prepare()