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

schemathesis/{throttling.py → core/rate_limit.py}

@@ -1,14 +1,23 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from contextlib import nullcontext
+from typing import TYPE_CHECKING, ContextManager
+from urllib.parse import urlparse
 
-from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
-from .exceptions import UsageError
+from schemathesis.core.errors import InvalidRateLimit
 
 if TYPE_CHECKING:
     from pyrate_limiter import Duration, Limiter
 
 
+def ratelimit(rate_limiter: Limiter | None, base_url: str | None) -> ContextManager:
+    """Limit the rate of sending generated requests."""
+    label = urlparse(base_url).netloc
+    if rate_limiter is not None:
+        rate_limiter.try_acquire(label)
+    return nullcontext()
+
+
 def parse_units(rate: str) -> tuple[int, int]:
     from pyrate_limiter import Duration
 
@@ -21,17 +30,10 @@ def parse_units(rate: str) -> tuple[int, int]:
             "d": Duration.DAY,
         }.get(interval_text)
         if interval is None:
-            raise invalid_rate(rate)
+            raise InvalidRateLimit(rate)
         return int(limit), interval
     except ValueError as exc:
-        raise invalid_rate(rate) from exc
-
-
-def invalid_rate(value: str) -> UsageError:
-    return UsageError(
-        f"Invalid rate limit value: `{value}`. Should be in form `limit/interval`. "
-        "Example: `10/m` for 10 requests per minute."
-    )
+        raise InvalidRateLimit(rate) from exc
 
 
 def _get_max_delay(value: int, unit: Duration) -> int:
@@ -51,11 +53,8 @@ def _get_max_delay(value: int, unit: Duration) -> int:
 
 
 def build_limiter(rate: str) -> Limiter:
-    from ._rate_limiter import Limiter, Rate
+    from pyrate_limiter import Limiter, Rate
 
     limit, interval = parse_units(rate)
     rate = Rate(limit, interval)
-    kwargs = {}
-    if IS_PYRATE_LIMITER_ABOVE_3:
-        kwargs["max_delay"] = _get_max_delay(limit, interval)
-    return Limiter(rate, **kwargs)
+    return Limiter(rate, max_delay=_get_max_delay(limit, interval))

schemathesis/core/registries.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Callable, Generic, Sequence, TypeVar, Union
+
+T = TypeVar("T", bound=Union[Callable, type])
+
+
+class Registry(Generic[T]):
+    """Container for Schemathesis extensions."""
+
+    __slots__ = ("_items",)
+
+    def __init__(self) -> None:
+        self._items: dict[str, T] = {}
+
+    def register(self, item: T) -> T:
+        self._items[item.__name__] = item
+        return item
+
+    def unregister(self, name: str) -> None:
+        del self._items[name]
+
+    def get_all_names(self) -> list[str]:
+        return list(self._items)
+
+    def get_all(self) -> list[T]:
+        return list(self._items.values())
+
+    def get_by_names(self, names: Sequence[str]) -> list[T]:
+        """Get items by their names."""
+        return [self._items[name] for name in names]

schemathesis/core/transforms.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Mapping, Union, overload
+
+
+def deepclone(value: Any) -> Any:
+    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
+
+    It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
+    """
+    if isinstance(value, dict):
+        return {
+            k1: (
+                {k2: deepclone(v2) for k2, v2 in v1.items()}
+                if isinstance(v1, dict)
+                else [deepclone(v2) for v2 in v1]
+                if isinstance(v1, list)
+                else v1
+            )
+            for k1, v1 in value.items()
+        }
+    if isinstance(value, list):
+        return [
+            {k2: deepclone(v2) for k2, v2 in v1.items()}
+            if isinstance(v1, dict)
+            else [deepclone(v2) for v2 in v1]
+            if isinstance(v1, list)
+            else v1
+            for v1 in value
+        ]
+    return value
+
+
+def diff(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]:
+    """Calculate the difference between two dictionaries."""
+    diff = {}
+    for key, value in right.items():
+        if key not in left or left[key] != value:
+            diff[key] = value
+    return diff
+
+
+def merge_at(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
+
+
+JsonValue = Union[Dict[str, Any], List, str, float, int]
+
+
+@overload
+def transform(schema: dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+
+
+@overload
+def transform(schema: list, callback: Callable, *args: Any, **kwargs: Any) -> list: ...
+
+
+@overload
+def transform(schema: str, callback: Callable, *args: Any, **kwargs: Any) -> str: ...
+
+
+@overload
+def transform(schema: float, callback: Callable, *args: Any, **kwargs: Any) -> float: ...
+
+
+def transform(schema: JsonValue, callback: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> JsonValue:
+    """Apply callback recursively to the given schema."""
+    if isinstance(schema, dict):
+        schema = callback(schema, *args, **kwargs)
+        for key, sub_item in schema.items():
+            schema[key] = transform(sub_item, callback, *args, **kwargs)
+    elif isinstance(schema, list):
+        schema = [transform(sub_item, callback, *args, **kwargs) for sub_item in schema]
+    return schema
+
+
+class Unresolvable: ...
+
+
+UNRESOLVABLE = Unresolvable()
+
+
+def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
+    """Implementation is adapted from Rust's `serde-json` crate.
+
+    Ref: https://github.com/serde-rs/json/blob/master/src/value/mod.rs#L751
+    """
+    if not pointer:
+        return document
+    if not pointer.startswith("/"):
+        return UNRESOLVABLE
+
+    def replace(value: str) -> str:
+        return value.replace("~1", "/").replace("~0", "~")
+
+    tokens = map(replace, pointer.split("/")[1:])
+    target = document
+    for token in tokens:
+        if isinstance(target, dict):
+            target = target.get(token, UNRESOLVABLE)
+            if target is UNRESOLVABLE:
+                return UNRESOLVABLE
+        elif isinstance(target, list):
+            try:
+                target = target[int(token)]
+            except (IndexError, ValueError):
+                return UNRESOLVABLE
+        else:
+            return UNRESOLVABLE
+    return target

schemathesis/core/transport.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import base64
+import json
+from typing import TYPE_CHECKING, Any, Mapping
+
+from schemathesis.core.version import SCHEMATHESIS_VERSION
+
+if TYPE_CHECKING:
+    import httpx
+    import requests
+    from werkzeug.test import TestResponse
+
+    from schemathesis.generation.overrides import Override
+
+USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
+DEFAULT_RESPONSE_TIMEOUT = 10
+
+
+def prepare_urlencoded(data: Any) -> Any:
+    if isinstance(data, list):
+        output = []
+        for item in data:
+            if isinstance(item, dict):
+                for key, value in item.items():
+                    output.append((key, value))
+            else:
+                output.append((item, "arbitrary-value"))
+        return output
+    return data
+
+
+class Response:
+    """HTTP response wrapper that normalizes different transport implementations.
+
+    Provides a consistent interface for accessing response data whether the request
+    was made via HTTP, ASGI, or WSGI transports.
+    """
+
+    status_code: int
+    """HTTP status code (e.g., 200, 404, 500)."""
+    headers: dict[str, list[str]]
+    """Response headers with lowercase keys and list values."""
+    content: bytes
+    """Raw response body as bytes."""
+    request: requests.PreparedRequest
+    """The request that generated this response."""
+    elapsed: float
+    """Response time in seconds."""
+    verify: bool
+    """Whether TLS verification was enabled for the request."""
+    message: str
+    """HTTP status message (e.g., "OK", "Not Found")."""
+    http_version: str
+    """HTTP protocol version ("1.0" or "1.1")."""
+    encoding: str | None
+    """Character encoding for text content, if detected."""
+    _override: Override | None
+
+    __slots__ = (
+        "status_code",
+        "headers",
+        "content",
+        "request",
+        "elapsed",
+        "verify",
+        "_json",
+        "message",
+        "http_version",
+        "encoding",
+        "_encoded_body",
+        "_override",
+    )
+
+    def __init__(
+        self,
+        status_code: int,
+        headers: Mapping[str, list[str]],
+        content: bytes,
+        request: requests.PreparedRequest,
+        elapsed: float,
+        verify: bool,
+        message: str = "",
+        http_version: str = "1.1",
+        encoding: str | None = None,
+        _override: Override | None = None,
+    ):
+        self.status_code = status_code
+        self.headers = {key.lower(): value for key, value in headers.items()}
+        assert all(isinstance(v, list) for v in headers.values())
+        self.content = content
+        self.request = request
+        self.elapsed = elapsed
+        self.verify = verify
+        self._json = None
+        self._encoded_body: str | None = None
+        self.message = message
+        self.http_version = http_version
+        self.encoding = encoding
+        self._override = _override
+
+    @classmethod
+    def from_any(cls, response: Response | httpx.Response | requests.Response | TestResponse) -> Response:
+        import httpx
+        import requests
+        from werkzeug.test import TestResponse
+
+        if isinstance(response, requests.Response):
+            return Response.from_requests(response, verify=True)
+        elif isinstance(response, httpx.Response):
+            return Response.from_httpx(response, verify=True)
+        elif isinstance(response, TestResponse):
+            return Response.from_wsgi(response)
+        return response
+
+    @classmethod
+    def from_requests(cls, response: requests.Response, verify: bool, _override: Override | None = None) -> Response:
+        raw = response.raw
+        raw_headers = raw.headers if raw is not None else {}
+        headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
+        # Similar to http.client:319 (HTTP version detection in stdlib's `http` package)
+        version = raw.version if raw is not None else 10
+        http_version = "1.0" if version == 10 else "1.1"
+        return Response(
+            status_code=response.status_code,
+            headers=headers,
+            content=response.content,
+            request=response.request,
+            elapsed=response.elapsed.total_seconds(),
+            message=response.reason,
+            encoding=response.encoding,
+            http_version=http_version,
+            verify=verify,
+            _override=_override,
+        )
+
+    @classmethod
+    def from_httpx(cls, response: httpx.Response, verify: bool) -> Response:
+        import requests
+
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.url.params),
+            data=response.request.content,
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={key: [value] for key, value in response.headers.items()},
+            content=response.content,
+            request=request,
+            elapsed=response.elapsed.total_seconds(),
+            message=response.reason_phrase,
+            encoding=response.encoding,
+            http_version=response.http_version,
+            verify=verify,
+        )
+
+    @classmethod
+    def from_wsgi(cls, response: TestResponse) -> Response:
+        import http.client
+
+        import requests
+
+        reason = http.client.responses.get(response.status_code, "Unknown")
+        data = response.get_data()
+        if response.response == []:
+            # Werkzeug <3.0 had `charset` attr, newer versions always have UTF-8
+            encoding = response.mimetype_params.get("charset", getattr(response, "charset", "utf-8"))
+        else:
+            encoding = None
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.args),
+            # Request body is not available
+            data=b"",
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={name: response.headers.getlist(name) for name in response.headers.keys()},
+            content=data,
+            request=request,
+            # Elapsed time is not available
+            elapsed=0.0,
+            message=reason,
+            encoding=encoding,
+            http_version="1.1",
+            verify=False,
+        )
+
+    @property
+    def text(self) -> str:
+        """Decode response content as text using the detected or default encoding."""
+        return self.content.decode(self.encoding if self.encoding else "utf-8")
+
+    def json(self) -> Any:
+        """Parse response content as JSON.
+
+        Returns:
+            Parsed JSON data (dict, list, or primitive types)
+
+        Raises:
+            json.JSONDecodeError: If content is not valid JSON
+
+        """
+        if self._json is None:
+            self._json = json.loads(self.text)
+        return self._json
+
+    @property
+    def body_size(self) -> int | None:
+        """Size of response body in bytes, or None if no content."""
+        return len(self.content) if self.content else None
+
+    @property
+    def encoded_body(self) -> str | None:
+        """Base64-encoded response body for binary-safe serialization."""
+        if self._encoded_body is None and self.content:
+            self._encoded_body = base64.b64encode(self.content).decode()
+        return self._encoded_body

schemathesis/core/validation.py

@@ -0,0 +1,54 @@
+import re
+from urllib.parse import urlparse
+
+# 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: object) -> bool:
+    from requests.exceptions import InvalidHeader
+    from requests.utils import check_header_validity
+
+    if not isinstance(value, str):
+        return False
+    try:
+        check_header_validity((name, value))
+        return bool(INVALID_HEADER_RE.search(value))
+    except InvalidHeader:
+        return True
+
+
+def is_latin_1_encodable(value: object) -> bool:
+    """Check if a value is a Latin-1 encodable string."""
+    if not isinstance(value, str):
+        return False
+    try:
+        value.encode("latin-1")
+        return True
+    except UnicodeEncodeError:
+        return False
+
+
+SURROGATE_PAIR_RE = re.compile(r"[\ud800-\udfff]")
+_contains_surrogate_pair = SURROGATE_PAIR_RE.search
+
+
+def contains_unicode_surrogate_pair(item: object) -> bool:
+    if isinstance(item, list):
+        return any(isinstance(item_, str) and bool(_contains_surrogate_pair(item_)) for item_ in item)
+    return isinstance(item, str) and bool(_contains_surrogate_pair(item))
+
+
+INVALID_BASE_URL_MESSAGE = (
+    "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
+    "Make sure it is a properly formatted URL."
+)
+
+
+def validate_base_url(value: str) -> None:
+    try:
+        netloc = urlparse(value).netloc
+    except ValueError as exc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE) from exc
+    if value and not netloc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE)

schemathesis/core/version.py

@@ -0,0 +1,7 @@
+from importlib import metadata
+
+try:
+    SCHEMATHESIS_VERSION = metadata.version(__package__)
+except metadata.PackageNotFoundError:
+    # Local run without installation
+    SCHEMATHESIS_VERSION = "dev"

schemathesis/engine/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from schemathesis.engine.core import Engine
+    from schemathesis.schemas import BaseSchema
+
+
+class Status(str, Enum):
+    SUCCESS = "success"
+    FAILURE = "failure"
+    ERROR = "error"
+    INTERRUPTED = "interrupted"
+    SKIP = "skip"
+
+    def __lt__(self, other: Status) -> bool:  # type: ignore[override]
+        return _STATUS_ORDER[self] < _STATUS_ORDER[other]
+
+
+_STATUS_ORDER = {Status.SUCCESS: 0, Status.FAILURE: 1, Status.ERROR: 2, Status.INTERRUPTED: 3, Status.SKIP: 4}
+
+
+def from_schema(schema: BaseSchema) -> Engine:
+    from .core import Engine
+
+    return Engine(schema=schema)

schemathesis/engine/context.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.config import ProjectConfig
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.generation.case import Case
+from schemathesis.schemas import APIOperation, BaseSchema
+
+from .control import ExecutionControl
+
+if TYPE_CHECKING:
+    import threading
+
+    import requests
+
+
+@dataclass
+class EngineContext:
+    """Holds context shared for a test run."""
+
+    schema: BaseSchema
+    control: ExecutionControl
+    outcome_cache: dict[int, BaseException | None]
+    start_time: float
+
+    __slots__ = ("schema", "control", "outcome_cache", "start_time", "_session", "_transport_kwargs_cache")
+
+    def __init__(
+        self,
+        *,
+        schema: BaseSchema,
+        stop_event: threading.Event,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.schema = schema
+        self.control = ExecutionControl(stop_event=stop_event, max_failures=schema.config.max_failures)
+        self.outcome_cache = {}
+        self.start_time = time.monotonic()
+        self._session = session
+        self._transport_kwargs_cache: dict[str | None, dict[str, Any]] = {}
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    @property
+    def config(self) -> ProjectConfig:
+        return self.schema.config
+
+    @property
+    def running_time(self) -> float:
+        return time.monotonic() - self.start_time
+
+    @property
+    def has_to_stop(self) -> bool:
+        """Check if execution should stop."""
+        return self.control.is_stopped
+
+    @property
+    def is_interrupted(self) -> bool:
+        return self.control.is_interrupted
+
+    @property
+    def has_reached_the_failure_limit(self) -> bool:
+        return self.control.has_reached_the_failure_limit
+
+    def stop(self) -> None:
+        self.control.stop()
+
+    def cache_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.outcome_cache[hash(case)] = outcome
+
+    def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.outcome_cache.get(hash(case), NOT_SET)
+
+    def get_session(self, *, operation: APIOperation | None = None) -> requests.Session:
+        if self._session is not None:
+            return self._session
+        import requests
+
+        session = requests.Session()
+        session.headers = {}
+        config = self.config
+
+        session.verify = config.tls_verify_for(operation=operation)
+        auth = config.auth_for(operation=operation)
+        if auth is not None:
+            session.auth = auth
+        headers = config.headers_for(operation=operation)
+        if headers:
+            session.headers.update(headers)
+        request_cert = config.request_cert_for(operation=operation)
+        if request_cert is not None:
+            session.cert = request_cert
+        proxy = config.proxy_for(operation=operation)
+        if proxy is not None:
+            session.proxies["all"] = proxy
+        return session
+
+    def get_transport_kwargs(self, operation: APIOperation | None = None) -> dict[str, Any]:
+        key = operation.label if operation is not None else None
+        cached = self._transport_kwargs_cache.get(key)
+        if cached is not None:
+            return cached.copy()
+        config = self.config
+        kwargs: dict[str, Any] = {
+            "session": self.get_session(operation=operation),
+            "headers": config.headers_for(operation=operation),
+            "timeout": config.request_timeout_for(operation=operation),
+            "verify": config.tls_verify_for(operation=operation),
+            "cert": config.request_cert_for(operation=operation),
+        }
+        proxy = config.proxy_for(operation=operation)
+        if proxy is not None:
+            kwargs["proxies"] = {"all": proxy}
+        self._transport_kwargs_cache[key] = kwargs
+        return kwargs

schemathesis/engine/control.py

@@ -0,0 +1,36 @@
+"""Control for the Schemathesis Engine execution."""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+
+
+@dataclass
+class ExecutionControl:
+    """Controls engine execution flow and tracks failures."""
+
+    stop_event: threading.Event
+    max_failures: int | None
+    _failures_counter: int = 0
+    has_reached_the_failure_limit: bool = False
+
+    @property
+    def is_stopped(self) -> bool:
+        """Check if execution should stop."""
+        return self.is_interrupted or self.has_reached_the_failure_limit
+
+    @property
+    def is_interrupted(self) -> bool:
+        return self.stop_event.is_set()
+
+    def stop(self) -> None:
+        """Signal to stop execution."""
+        self.stop_event.set()
+
+    def count_failure(self) -> None:
+        # N failures limit
+        if self.max_failures is not None:
+            self._failures_counter += 1
+            if self._failures_counter >= self.max_failures:
+                self.has_reached_the_failure_limit = True