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

schemathesis/core/transport.py

@@ -0,0 +1,108 @@
+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 requests
+
+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:
+    """Unified response for both testing and reporting purposes."""
+
+    __slots__ = (
+        "status_code",
+        "headers",
+        "content",
+        "request",
+        "elapsed",
+        "verify",
+        "_json",
+        "message",
+        "http_version",
+        "encoding",
+        "_encoded_body",
+    )
+
+    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,
+    ):
+        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
+
+    @classmethod
+    def from_requests(cls, response: requests.Response, verify: bool) -> 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,
+        )
+
+    @property
+    def text(self) -> str:
+        return self.content.decode(self.encoding if self.encoding else "utf-8")
+
+    def json(self) -> Any:
+        if self._json is None:
+            self._json = json.loads(self.text)
+        return self._json
+
+    @property
+    def body_size(self) -> int | None:
+        return len(self.content) if self.content else None
+
+    @property
+    def encoded_body(self) -> str | None:
+        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,38 @@
+import re
+
+# 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))

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,30 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from schemathesis.engine.config import EngineConfig
+
+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, *, config: EngineConfig | None = None) -> Engine:
+    from .core import Engine
+
+    return Engine(schema=schema, config=config or EngineConfig())

schemathesis/engine/config.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.checks import CheckFunction, not_a_server_error
+from schemathesis.engine.phases import PhaseName
+from schemathesis.generation import GenerationConfig
+from schemathesis.generation.overrides import Override
+
+if TYPE_CHECKING:
+    import hypothesis
+
+    from schemathesis.checks import ChecksConfig
+    from schemathesis.generation.targets import TargetFunction
+
+
+def _default_hypothesis_settings() -> hypothesis.settings:
+    import hypothesis
+
+    return hypothesis.settings(deadline=None)
+
+
+@dataclass
+class ExecutionConfig:
+    """Configuration for test execution."""
+
+    phases: list[PhaseName] = field(default_factory=lambda: [PhaseName.UNIT_TESTING, PhaseName.STATEFUL_TESTING])
+    checks: list[CheckFunction] = field(default_factory=lambda: [not_a_server_error])
+    targets: list[TargetFunction] = field(default_factory=list)
+    hypothesis_settings: hypothesis.settings = field(default_factory=_default_hypothesis_settings)
+    generation: GenerationConfig = field(default_factory=GenerationConfig)
+    max_failures: int | None = None
+    unique_inputs: bool = False
+    no_failfast: bool = False
+    seed: int | None = None
+    workers_num: int = 1
+
+
+@dataclass
+class NetworkConfig:
+    """Network-related configuration."""
+
+    auth: tuple[str, str] | None = None
+    headers: dict[str, Any] = field(default_factory=dict)
+    timeout: int | None = None
+    tls_verify: bool | str = True
+    proxy: str | None = None
+    cert: str | tuple[str, str] | None = None
+
+
+@dataclass
+class EngineConfig:
+    """Complete engine configuration."""
+
+    execution: ExecutionConfig = field(default_factory=ExecutionConfig)
+    network: NetworkConfig = field(default_factory=NetworkConfig)
+    checks_config: ChecksConfig = field(default_factory=dict)
+    override: Override | None = None

schemathesis/engine/context.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.checks import CheckContext
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.generation.case import Case
+from schemathesis.schemas import BaseSchema
+
+from .control import ExecutionControl
+
+if TYPE_CHECKING:
+    import threading
+
+    import requests
+
+    from schemathesis.engine.config import EngineConfig
+
+
+@dataclass
+class EngineContext:
+    """Holds context shared for a test run."""
+
+    schema: BaseSchema
+    control: ExecutionControl
+    outcome_cache: dict[int, BaseException | None]
+    config: EngineConfig
+    start_time: float
+
+    def __init__(
+        self,
+        *,
+        schema: BaseSchema,
+        stop_event: threading.Event,
+        config: EngineConfig,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.schema = schema
+        self.control = ExecutionControl(stop_event=stop_event, max_failures=config.execution.max_failures)
+        self.outcome_cache = {}
+        self.config = config
+        self.start_time = time.monotonic()
+        self._session = session
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    @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)
+
+    @cached_property
+    def session(self) -> requests.Session:
+        if self._session is not None:
+            return self._session
+        import requests
+
+        session = requests.Session()
+        config = self.config.network
+        session.verify = config.tls_verify
+        if config.auth is not None:
+            session.auth = config.auth
+        if config.headers:
+            session.headers.update(config.headers)
+        if config.cert is not None:
+            session.cert = config.cert
+        if config.proxy is not None:
+            session.proxies["all"] = config.proxy
+        return session
+
+    @property
+    def transport_kwargs(self) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {
+            "session": self.session,
+            "headers": self.config.network.headers,
+            "timeout": self.config.network.timeout,
+            "verify": self.config.network.tls_verify,
+            "cert": self.config.network.cert,
+        }
+        if self.config.network.proxy is not None:
+            kwargs["proxies"] = {"all": self.config.network.proxy}
+        return kwargs
+
+    def get_check_context(self, recorder: ScenarioRecorder) -> CheckContext:
+        from requests.models import CaseInsensitiveDict
+
+        return CheckContext(
+            override=self.config.override,
+            auth=self.config.network.auth,
+            headers=CaseInsensitiveDict(self.config.network.headers) if self.config.network.headers else None,
+            config=self.config.checks_config,
+            transport_kwargs=self.transport_kwargs,
+            recorder=recorder,
+        )

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

schemathesis/engine/core.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+from typing import Sequence
+
+from schemathesis.auths import unregister as unregister_auth
+from schemathesis.core import SpecificationFeature
+from schemathesis.engine import Status, events, phases
+from schemathesis.schemas import BaseSchema
+
+from .config import EngineConfig
+from .context import EngineContext
+from .events import EventGenerator
+from .phases import Phase, PhaseName, PhaseSkipReason
+
+
+@dataclass
+class Engine:
+    schema: BaseSchema
+    config: EngineConfig
+
+    def execute(self) -> EventStream:
+        """Execute all test phases."""
+        # Unregister auth if explicitly provided
+        if self.config.network.auth is not None:
+            unregister_auth()
+
+        ctx = EngineContext(schema=self.schema, stop_event=threading.Event(), config=self.config)
+        plan = self._create_execution_plan()
+        return EventStream(plan.execute(ctx), ctx.control.stop_event)
+
+    def _create_execution_plan(self) -> ExecutionPlan:
+        """Create execution plan based on configuration."""
+        phases = [
+            self.get_phase_config(PhaseName.PROBING, is_supported=True, requires_links=False),
+            self.get_phase_config(PhaseName.UNIT_TESTING, is_supported=True, requires_links=False),
+            self.get_phase_config(
+                PhaseName.STATEFUL_TESTING,
+                is_supported=self.schema.specification.supports_feature(SpecificationFeature.STATEFUL_TESTING),
+                requires_links=True,
+            ),
+        ]
+        return ExecutionPlan(phases)
+
+    def get_phase_config(
+        self,
+        phase_name: PhaseName,
+        *,
+        is_supported: bool = True,
+        requires_links: bool = False,
+    ) -> Phase:
+        """Helper to determine phase configuration with proper skip reasons."""
+        # Check if feature is supported by the schema
+        if not is_supported:
+            return Phase(
+                name=phase_name,
+                is_supported=False,
+                is_enabled=False,
+                skip_reason=PhaseSkipReason.NOT_SUPPORTED,
+            )
+
+        if phase_name not in self.config.execution.phases:
+            return Phase(
+                name=phase_name,
+                is_supported=True,
+                is_enabled=False,
+                skip_reason=PhaseSkipReason.DISABLED,
+            )
+
+        if requires_links and self.schema.statistic.links.selected == 0:
+            return Phase(
+                name=phase_name,
+                is_supported=True,
+                is_enabled=False,
+                skip_reason=PhaseSkipReason.NOT_APPLICABLE,
+            )
+
+        # Phase can be executed
+        return Phase(
+            name=phase_name,
+            is_supported=True,
+            is_enabled=True,
+            skip_reason=None,
+        )
+
+
+@dataclass
+class ExecutionPlan:
+    """Manages test execution phases."""
+
+    phases: Sequence[Phase]
+
+    def execute(self, engine: EngineContext) -> EventGenerator:
+        """Execute all phases in sequence."""
+        yield events.EngineStarted()
+        try:
+            if engine.is_interrupted:
+                yield from self._finish(engine)
+                return
+            if engine.is_interrupted:
+                yield from self._finish(engine)  # type: ignore[unreachable]
+                return
+
+            # Run main phases
+            for phase in self.phases:
+                if engine.has_reached_the_failure_limit:
+                    phase.skip_reason = PhaseSkipReason.FAILURE_LIMIT_REACHED
+                yield events.PhaseStarted(phase=phase)
+                if phase.should_execute(engine):
+                    yield from phases.execute(engine, phase)
+                else:
+                    if engine.has_reached_the_failure_limit:
+                        phase.skip_reason = PhaseSkipReason.FAILURE_LIMIT_REACHED
+                    yield events.PhaseFinished(phase=phase, status=Status.SKIP, payload=None)
+                if engine.is_interrupted:
+                    break  # type: ignore[unreachable]
+
+        except KeyboardInterrupt:
+            engine.stop()
+            yield events.Interrupted(phase=None)
+
+        # Always finish
+        yield from self._finish(engine)
+
+    def _finish(self, ctx: EngineContext) -> EventGenerator:
+        """Finish the test run."""
+        yield events.EngineFinished(running_time=ctx.running_time)
+
+
+@dataclass
+class EventStream:
+    """Schemathesis event stream.
+
+    Provides an API to control the execution flow.
+    """
+
+    generator: EventGenerator
+    stop_event: threading.Event
+
+    def __next__(self) -> events.EngineEvent:
+        return next(self.generator)
+
+    def __iter__(self) -> EventGenerator:
+        return self.generator
+
+    def stop(self) -> None:
+        """Stop the event stream.
+
+        Its next value will be the last one (Finished).
+        """
+        self.stop_event.set()
+
+    def finish(self) -> events.EngineEvent:
+        """Stop the event stream & return the last event."""
+        self.stop()
+        return next(self)