schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/stateful/validation.py

@@ -1,100 +0,0 @@
-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,77 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable
-
-if TYPE_CHECKING:
-    from .models import Case
-    from .transports.responses import GenericResponse
-
-
-@dataclass
-class TargetContext:
-    """Context for targeted testing.
-
-    :ivar Case case: Generated example that is being processed.
-    :ivar GenericResponse response: API response.
-    :ivar float response_time: API response time.
-    """
-
-    case: Case
-    response: GenericResponse
-    response_time: float
-
-
-def response_time(context: TargetContext) -> float:
-    return context.response_time
-
-
-Target = Callable[[TargetContext], float]
-DEFAULT_TARGETS = ()
-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.
-
-    :param target: A function that will be called to calculate a metric passed to ``hypothesis.target``.
-    """
-    from . import cli
-
-    global ALL_TARGETS
-
-    ALL_TARGETS += (target,)
-    cli.TARGETS_TYPE.choices += (target.__name__,)  # type: ignore
-    return target

schemathesis/transports/__init__.py

@@ -1,359 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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,38 +0,0 @@
-from __future__ import annotations
-
-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
-
-    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/headers.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Any
-
-from ..constants import USER_AGENT
-
-
-def setup_default_headers(kwargs: dict[str, Any]) -> None:
-    headers = kwargs.setdefault("headers", {})
-    if "user-agent" not in {header.lower() for header in headers}:
-        kwargs["headers"]["User-Agent"] = USER_AGENT
-
-
-def is_latin_1_encodable(value: str) -> bool:
-    """Header values are encoded to latin-1 before sending."""
-    try:
-        value.encode("latin-1")
-        return True
-    except UnicodeEncodeError:
-        return False
-
-
-# Adapted from http.client._is_illegal_header_value
-INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
-
-
-def has_invalid_characters(name: str, value: str) -> bool:
-    from requests.exceptions import InvalidHeader
-    from requests.utils import check_header_validity
-
-    try:
-        check_header_validity((name, value))
-        return bool(INVALID_HEADER_RE.search(value))
-    except InvalidHeader:
-        return True

schemathesis/transports/responses.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import json
-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 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
-        raise e
-
-
-def get_payload(response: GenericResponse) -> str:
-    from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
-
-    if isinstance(response, (httpxResponse, requestsResponse)):
-        return response.text
-    return response.get_data(as_text=True)
-
-
-def get_json(response: GenericResponse) -> Any:
-    from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
-
-    if isinstance(response, (httpxResponse, requestsResponse)):
-        return json.loads(response.text)
-    return response.json
-
-
-def get_reason(status_code: int) -> str:
-    if sys.version_info < (3, 9) and status_code == 418:
-        # Python 3.8 does not have 418 status in the `HTTPStatus` enum
-        return "I'm a Teapot"
-
-    import http.client
-
-    return http.client.responses.get(status_code, "Unknown")
-
-
-GenericResponse = Union["httpxResponse", "requestsResponse", WSGIResponse]