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

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,73 @@
+import re
+from urllib.parse import urlparse
+
+from schemathesis.core.errors import InvalidSchema
+
+# 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
+
+
+def check_header_name(name: str) -> None:
+    from requests.exceptions import InvalidHeader
+    from requests.utils import check_header_validity
+
+    if not name:
+        raise InvalidSchema("Header name should not be empty")
+    if not name.isascii():
+        # `urllib3` encodes header names to ASCII
+        raise InvalidSchema(f"Header name should be ASCII: {name}")
+    try:
+        check_header_validity((name, ""))
+    except InvalidHeader as exc:
+        raise InvalidSchema(str(exc)) from None
+    if bool(INVALID_HEADER_RE.search(name)):
+        raise InvalidSchema(f"Invalid header name: {name}")
+
+
+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("schemathesis")
+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,152 @@
+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.engine.control import ExecutionControl
+from schemathesis.engine.observations import Observations
+from schemathesis.generation.case import Case
+from schemathesis.schemas import APIOperation, BaseSchema
+
+if TYPE_CHECKING:
+    import threading
+
+    import requests
+
+    from schemathesis.engine.recorder import ScenarioRecorder
+
+
+@dataclass
+class EngineContext:
+    """Holds context shared for a test run."""
+
+    schema: BaseSchema
+    control: ExecutionControl
+    outcome_cache: dict[int, BaseException | None]
+    start_time: float
+    observations: Observations | None
+
+    __slots__ = (
+        "schema",
+        "control",
+        "outcome_cache",
+        "start_time",
+        "observations",
+        "_session",
+        "_transport_kwargs_cache",
+    )
+
+    def __init__(
+        self,
+        *,
+        schema: BaseSchema,
+        stop_event: threading.Event,
+        observations: Observations | None = None,
+        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.observations = observations
+        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 record_observations(self, recorder: ScenarioRecorder) -> None:
+        """Add new observations from a scenario."""
+        if self.observations is not None:
+            self.observations.extract_observations_from(recorder)
+
+    def inject_links(self) -> int:
+        """Inject inferred OpenAPI links into API operations based on collected observations."""
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+        injected = 0
+        if self.observations is not None and self.observations.location_headers:
+            assert isinstance(self.schema, BaseOpenAPISchema)
+
+            # Generate links from collected Location headers
+            for operation, entries in self.observations.location_headers.items():
+                injected += self.schema.analysis.inferencer.inject_links(operation.responses, entries)
+        if isinstance(self.schema, BaseOpenAPISchema) and self.schema.analysis.should_inject_links():
+            injected += self.schema.analysis.inject_links()
+        return injected
+
+    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),
+            "max_redirects": config.max_redirects_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,44 @@
+"""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
+    has_reached_the_failure_limit: bool
+
+    __slots__ = ("stop_event", "max_failures", "_failures_counter", "has_reached_the_failure_limit")
+
+    def __init__(self, stop_event: threading.Event, max_failures: int | None) -> None:
+        self.stop_event = stop_event
+        self.max_failures = max_failures
+        self._failures_counter = 0
+        self.has_reached_the_failure_limit = 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