schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/stateful/validation.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..exceptions import CheckFailed, get_grouped_exception
+from ..internal.checks import CheckContext
+
+if TYPE_CHECKING:
+    from ..failures import FailureContext
+    from ..internal.checks import CheckFunction
+    from ..models import Case
+    from ..transports.responses import GenericResponse
+    from .context import RunnerContext
+
+
+def validate_response(
+    *,
+    response: GenericResponse,
+    case: Case,
+    runner_ctx: RunnerContext,
+    check_ctx: CheckContext,
+    checks: tuple[CheckFunction, ...],
+    additional_checks: tuple[CheckFunction, ...] = (),
+    max_response_time: int | None = None,
+) -> None:
+    """Validate the response against the provided checks."""
+    from .._compat import MultipleFailures
+    from ..checks import _make_max_response_time_failure_message
+    from ..failures import ResponseTimeExceeded
+    from ..models import Check, Status
+
+    exceptions: list[CheckFailed | AssertionError] = []
+    check_results = runner_ctx.checks_for_step
+
+    def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
+        exceptions.append(exc)
+        if runner_ctx.is_seen_in_suite(exc):
+            return
+        failed_check = Check(
+            name=name,
+            value=Status.failure,
+            response=response,
+            elapsed=response.elapsed.total_seconds(),
+            example=copied_case,
+            message=message,
+            context=context,
+            request=None,
+        )
+        runner_ctx.add_failed_check(failed_check)
+        check_results.append(failed_check)
+        runner_ctx.mark_as_seen_in_suite(exc)
+
+    def _on_passed(_name: str, _case: Case) -> None:
+        passed_check = Check(
+            name=_name,
+            value=Status.success,
+            response=response,
+            elapsed=response.elapsed.total_seconds(),
+            example=_case,
+            request=None,
+        )
+        check_results.append(passed_check)
+
+    for check in tuple(checks) + tuple(additional_checks):
+        name = check.__name__
+        copied_case = case.partial_deepcopy()
+        try:
+            skip_check = check(check_ctx, response, copied_case)
+            if not skip_check:
+                _on_passed(name, copied_case)
+        except CheckFailed as exc:
+            if runner_ctx.is_seen_in_run(exc):
+                continue
+            _on_failure(exc, str(exc), exc.context)
+        except AssertionError as exc:
+            if runner_ctx.is_seen_in_run(exc):
+                continue
+            _on_failure(exc, str(exc) or f"Custom check failed: `{name}`", None)
+        except MultipleFailures as exc:
+            for subexc in exc.exceptions:
+                if runner_ctx.is_seen_in_run(subexc):
+                    continue
+                _on_failure(subexc, str(subexc), subexc.context)
+
+    if max_response_time:
+        elapsed_time = response.elapsed.total_seconds() * 1000
+        if elapsed_time > max_response_time:
+            message = _make_max_response_time_failure_message(elapsed_time, max_response_time)
+            context = ResponseTimeExceeded(message=message, elapsed=elapsed_time, deadline=max_response_time)
+            try:
+                raise AssertionError(message)
+            except AssertionError as _exc:
+                if not runner_ctx.is_seen_in_run(_exc):
+                    _on_failure(_exc, message, context)
+        else:
+            _on_passed("max_response_time", case)
+
+    # Raise a grouped exception so Hypothesis can properly deduplicate it against the other failures
+    if exceptions:
+        raise get_grouped_exception(case.operation.verbose_name, *exceptions)(causes=tuple(exceptions))

schemathesis/targets.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from dataclasses import dataclass
+
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
@@ -31,6 +32,37 @@ OPTIONAL_TARGETS = (response_time,)
 ALL_TARGETS: tuple[Target, ...] = DEFAULT_TARGETS + OPTIONAL_TARGETS
 
 
+@dataclass
+class TargetMetricCollector:
+    """Collect multiple observations for target metrics."""
+
+    targets: list[Target]
+    observations: dict[str, list[int | float]] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.observations = {target.__name__: [] for target in self.targets}
+
+    def reset(self) -> None:
+        """Reset all collected observations."""
+        for target in self.targets:
+            self.observations[target.__name__].clear()
+
+    def store(self, case: Case, response: GenericResponse) -> None:
+        """Calculate target metrics & store them."""
+        context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
+        for target in self.targets:
+            self.observations[target.__name__].append(target(context))
+
+    def maximize(self) -> None:
+        """Give feedback to the Hypothesis engine, so it maximizes the aggregated metrics."""
+        import hypothesis
+
+        for target in self.targets:
+            # Currently aggregation is just a sum
+            metric = sum(self.observations[target.__name__])
+            hypothesis.target(metric, label=target.__name__)
+
+
 def register(target: Target) -> Target:
     """Register a new testing target for schemathesis CLI.
 

schemathesis/throttling.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
+from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 from .exceptions import UsageError
 
-
 if TYPE_CHECKING:
-    from pyrate_limiter import Limiter
+    from pyrate_limiter import Duration, Limiter
 
 
 def parse_units(rate: str) -> tuple[int, int]:
@@ -33,9 +34,28 @@ def invalid_rate(value: str) -> UsageError:
     )
 
 
+def _get_max_delay(value: int, unit: Duration) -> int:
+    from pyrate_limiter import Duration
+
+    if unit == Duration.SECOND:
+        multiplier = 1
+    elif unit == Duration.MINUTE:
+        multiplier = 60
+    elif unit == Duration.HOUR:
+        multiplier = 60 * 60
+    else:
+        multiplier = 60 * 60 * 24
+    # Delay is in milliseconds + `pyrate_limiter` adds 50ms on top.
+    # Hence adding 100 covers this
+    return value * multiplier * 1000 + 100
+
+
 def build_limiter(rate: str) -> Limiter:
-    from pyrate_limiter import Limiter, RequestRate
+    from ._rate_limiter import Limiter, Rate
 
     limit, interval = parse_units(rate)
-    rate = RequestRate(limit, interval)
-    return Limiter(rate)
+    rate = Rate(limit, interval)
+    kwargs = {}
+    if IS_PYRATE_LIMITER_ABOVE_3:
+        kwargs["max_delay"] = _get_max_delay(limit, interval)
+    return Limiter(rate, **kwargs)

schemathesis/transports/__init__.py

@@ -1,5 +1,359 @@
+from __future__ import annotations
+
 import base64
+import inspect
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import timedelta
+from inspect import iscoroutinefunction
+from typing import TYPE_CHECKING, Any, Generator, Protocol, TypeVar, cast
+from urllib.parse import urlparse
+
+from .. import failures
+from .._dependency_versions import IS_WERKZEUG_ABOVE_3
+from ..constants import DEFAULT_RESPONSE_TIMEOUT, NOT_SET
+from ..exceptions import get_timeout_error
+from ..serializers import SerializerContext
+from ..types import Cookies, NotSet, RequestCert
+
+if TYPE_CHECKING:
+    import requests
+    import werkzeug
+    from _typeshed.wsgi import WSGIApplication
+    from starlette_testclient._testclient import ASGI2App, ASGI3App
+
+    from ..models import Case
+    from .responses import WSGIResponse
+
+
+@dataclass
+class RequestConfig:
+    timeout: int | None = None
+    tls_verify: bool | str = True
+    proxy: str | None = None
+    cert: RequestCert | None = None
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    @property
+    def prepared_timeout(self) -> float | None:
+        return prepare_timeout(self.timeout)
 
 
 def serialize_payload(payload: bytes) -> str:
     return base64.b64encode(payload).decode()
+
+
+def deserialize_payload(data: str | None) -> bytes | None:
+    if data is None:
+        return None
+    return base64.b64decode(data)
+
+
+def get(app: Any) -> Transport:
+    """Get transport to send the data to the application."""
+    if app is None:
+        return RequestsTransport()
+    if iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    ):
+        return ASGITransport(app=app)
+    return WSGITransport(app=app)
+
+
+S = TypeVar("S", contravariant=True)
+R = TypeVar("R", covariant=True)
+
+
+class Transport(Protocol[S, R]):
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: S | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> R:
+        raise NotImplementedError
+
+
+class RequestsTransport:
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        final_headers = case._get_headers(headers)
+        media_type: str | None
+        if case.body is not NOT_SET and case.media_type is None:
+            media_type = case.operation._get_default_media_type()
+        else:
+            media_type = case.media_type
+        if media_type and media_type != "multipart/form-data" and not isinstance(case.body, NotSet):
+            # `requests` will handle multipart form headers with the proper `boundary` value.
+            if "content-type" not in final_headers:
+                final_headers["Content-Type"] = media_type
+        url = case._get_url(base_url)
+        serializer = case._get_serializer(media_type)
+        if serializer is not None and not isinstance(case.body, NotSet):
+            context = SerializerContext(case=case)
+            extra = serializer.as_requests(context, case._get_body())
+        else:
+            extra = {}
+        if case._auth is not None:
+            extra["auth"] = case._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)
+        data = {
+            "method": case.method,
+            "url": url,
+            "cookies": case.cookies,
+            "headers": final_headers,
+            "params": case.query,
+            **extra,
+        }
+        if params is not None:
+            _merge_dict_to(data, "params", params)
+        if cookies is not None:
+            _merge_dict_to(data, "cookies", cookies)
+        return data
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: requests.Session | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        import requests
+        from urllib3.exceptions import ReadTimeoutError
+
+        data = self.serialize_case(case, base_url=base_url, headers=headers, params=params, cookies=cookies)
+        data.update(kwargs)
+        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 case.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 = case._get_code_message(case.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(case.operation.verbose_name, 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._session = session  # type: ignore[attr-defined]
+        if close_session:
+            session.close()
+        return response
+
+
+def _merge_dict_to(data: dict[str, Any], data_key: str, new: dict[str, Any]) -> None:
+    original = data[data_key] or {}
+    for key, value in new.items():
+        original[key] = value
+    data[data_key] = original
+
+
+def prepare_timeout(timeout: int | None) -> float | None:
+    """Request timeout is in milliseconds, but `requests` uses seconds."""
+    output: int | float | None = timeout
+    if timeout is not None:
+        output = timeout / 1000
+    return output
+
+
+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.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}"
+        )
+
+
+@dataclass
+class ASGITransport(RequestsTransport):
+    app: ASGI2App | ASGI3App
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: requests.Session | None = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        from starlette_testclient import TestClient as ASGIClient
+
+        if base_url is None:
+            base_url = case.get_full_base_url()
+        with ASGIClient(self.app) as client:
+            return super().send(
+                case, session=client, base_url=base_url, headers=headers, params=params, cookies=cookies, **kwargs
+            )
+
+
+@dataclass
+class WSGITransport:
+    app: WSGIApplication
+
+    def serialize_case(
+        self,
+        case: Case,
+        *,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        final_headers = case._get_headers(headers)
+        media_type: str | None
+        if case.body is not NOT_SET and case.media_type is None:
+            media_type = case.operation._get_default_media_type()
+        else:
+            media_type = case.media_type
+        if media_type and not isinstance(case.body, NotSet):
+            # If we need to send a payload, then the Content-Type header should be set
+            final_headers["Content-Type"] = media_type
+        extra: dict[str, Any]
+        serializer = case._get_serializer(media_type)
+        if serializer is not None and not isinstance(case.body, NotSet):
+            context = SerializerContext(case=case)
+            extra = serializer.as_werkzeug(context, case._get_body())
+        else:
+            extra = {}
+        data = {
+            "method": case.method,
+            "path": case.operation.schema.get_full_path(case.formatted_path),
+            # Convert to a regular dictionary, as we use `CaseInsensitiveDict` which is not supported by Werkzeug
+            "headers": dict(final_headers),
+            "query_string": case.query,
+            **extra,
+        }
+        if params is not None:
+            _merge_dict_to(data, "query_string", params)
+        return data
+
+    def send(
+        self,
+        case: Case,
+        *,
+        session: Any = None,
+        base_url: str | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> WSGIResponse:
+        import requests
+        import werkzeug
+
+        from .responses import WSGIResponse
+
+        application = kwargs.pop("app", self.app) or self.app
+        data = self.serialize_case(case, headers=headers, params=params)
+        data.update(kwargs)
+        client = werkzeug.Client(application, WSGIResponse)
+        cookies = {**(case.cookies or {}), **(cookies or {})}
+        with cookie_handler(client, cookies), case.operation.schema.ratelimit():
+            start = time.monotonic()
+            response = client.open(**data)
+            elapsed = time.monotonic() - start
+        requests_kwargs = RequestsTransport().serialize_case(
+            case,
+            base_url=case.get_full_base_url(),
+            headers=headers,
+            params=params,
+            cookies=cookies,
+        )
+        response.request = requests.Request(**requests_kwargs).prepare()
+        response.elapsed = timedelta(seconds=elapsed)
+        return response
+
+
+@contextmanager
+def cookie_handler(client: werkzeug.Client, cookies: Cookies | None) -> Generator[None, None, None]:
+    """Set cookies required for a call."""
+    if not cookies:
+        yield
+    else:
+        for key, value in cookies.items():
+            if IS_WERKZEUG_ABOVE_3:
+                client.set_cookie(key=key, value=value, domain="localhost")
+            else:
+                client.set_cookie("localhost", key=key, value=value)
+        yield
+        for key in cookies:
+            if IS_WERKZEUG_ABOVE_3:
+                client.delete_cookie(key=key, domain="localhost")
+            else:
+                client.delete_cookie("localhost", key=key)

schemathesis/transports/asgi.py

@@ -0,0 +1,7 @@
+from inspect import iscoroutinefunction
+
+
+def is_asgi_app(app: object) -> bool:
+    return iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    )

schemathesis/transports/auth.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
-from ..types import RawAuth
+from typing import TYPE_CHECKING, Any
+
+from ..constants import USER_AGENT
 
 if TYPE_CHECKING:
     from requests.auth import HTTPDigestAuth
 
+    from ..types import RawAuth
+
 
 def get_requests_auth(auth: RawAuth | None, auth_type: str | None) -> HTTPDigestAuth | RawAuth | None:
     from requests.auth import HTTPDigestAuth
@@ -13,3 +16,23 @@ def get_requests_auth(auth: RawAuth | None, auth_type: str | None) -> HTTPDigest
     if auth and auth_type == "digest":
         return HTTPDigestAuth(*auth)
     return auth
+
+
+def prepare_wsgi_headers(headers: dict[str, Any] | None, auth: RawAuth | None, auth_type: str | None) -> dict[str, Any]:
+    headers = headers or {}
+    if "user-agent" not in {header.lower() for header in headers}:
+        headers["User-Agent"] = USER_AGENT
+    wsgi_auth = get_wsgi_auth(auth, auth_type)
+    if wsgi_auth:
+        headers["Authorization"] = wsgi_auth
+    return headers
+
+
+def get_wsgi_auth(auth: RawAuth | None, auth_type: str | None) -> str | None:
+    from requests.auth import _basic_auth_str
+
+    if auth:
+        if auth_type == "digest":
+            raise ValueError("Digest auth is not supported for WSGI apps")
+        return _basic_auth_str(*auth)
+    return None

schemathesis/transports/content_types.py

@@ -1,4 +1,5 @@
-from typing import Tuple, Generator
+from functools import lru_cache
+from typing import Generator, Tuple
 
 
 def _parseparam(s: str) -> Generator[str, None, None]:
@@ -30,6 +31,7 @@ def parse_header(line: str) -> Tuple[str, dict]:
     return key, pdict
 
 
+@lru_cache
 def parse_content_type(content_type: str) -> Tuple[str, str]:
     """Parse Content Type and return main type and subtype."""
     try:

schemathesis/transports/headers.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import re
 from typing import Any
 
@@ -25,8 +26,8 @@ INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
 
 
 def has_invalid_characters(name: str, value: str) -> bool:
-    from requests.utils import check_header_validity
     from requests.exceptions import InvalidHeader
+    from requests.utils import check_header_validity
 
     try:
         check_header_validity((name, value))

schemathesis/transports/responses.py

@@ -1,20 +1,25 @@
 from __future__ import annotations
 
-import sys
 import json
-from typing import Union, TYPE_CHECKING, NoReturn, Any
-from .._compat import JSONMixin
+import sys
+from typing import TYPE_CHECKING, Any, NoReturn, Union
+
 from werkzeug.wrappers import Response as BaseResponse
 
+from .._compat import JSONMixin
+
 if TYPE_CHECKING:
+    from datetime import timedelta
+
     from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
     from requests import PreparedRequest
+    from requests import Response as requestsResponse
 
 
 class WSGIResponse(BaseResponse, JSONMixin):
     # We store "requests" request to build a reproduction code
     request: PreparedRequest
+    elapsed: timedelta
 
     def on_json_loading_failed(self, e: json.JSONDecodeError) -> NoReturn:
         # We don't need a werkzeug-specific exception when JSON parsing error happens

schemathesis/types.py

@@ -1,8 +1,10 @@
+import enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Set, Tuple, Union
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
+
     from .hooks import HookContext
 
 PathLike = Union[Path, str]
@@ -33,3 +35,10 @@ Hook = Union[
 RawAuth = Tuple[str, str]
 # Generic test with any arguments and no return
 GenericTest = Callable[..., None]
+
+
+class Specification(str, enum.Enum):
+    """Specification of the given schema."""
+
+    OPENAPI = "openapi"
+    GRAPHQL = "graphql"