schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/engine/context.py

@@ -2,14 +2,12 @@ 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.config import ProjectConfig
 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 schemathesis.schemas import APIOperation, BaseSchema
 
 from .control import ExecutionControl
 
@@ -18,8 +16,6 @@ if TYPE_CHECKING:
 
     import requests
 
-    from schemathesis.engine.config import EngineConfig
-
 
 @dataclass
 class EngineContext:
@@ -28,26 +24,30 @@ class EngineContext:
     schema: BaseSchema
     control: ExecutionControl
     outcome_cache: dict[int, BaseException | None]
-    config: EngineConfig
     start_time: float
 
+    __slots__ = ("schema", "control", "outcome_cache", "start_time", "_session", "_transport_kwargs_cache")
+
     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.control = ExecutionControl(stop_event=stop_event, max_failures=schema.config.max_failures)
         self.outcome_cache = {}
-        self.config = config
         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
@@ -74,46 +74,45 @@ class EngineContext:
     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:
+    def get_session(self, *, operation: APIOperation | None = None) -> 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
+        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
 
-    @property
-    def transport_kwargs(self) -> dict[str, Any]:
+    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.session,
-            "headers": self.config.network.headers,
-            "timeout": self.config.network.timeout,
-            "verify": self.config.network.tls_verify,
-            "cert": self.config.network.cert,
+            "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),
         }
-        if self.config.network.proxy is not None:
-            kwargs["proxies"] = {"all": self.config.network.proxy}
+        proxy = config.proxy_for(operation=operation)
+        if proxy is not None:
+            kwargs["proxies"] = {"all": proxy}
+        self._transport_kwargs_cache[key] = kwargs
         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/core.py

@@ -9,7 +9,6 @@ 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
@@ -18,15 +17,14 @@ 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:
+        if self.schema.config.auth.is_defined:
             unregister_auth()
 
-        ctx = EngineContext(schema=self.schema, stop_event=threading.Event(), config=self.config)
+        ctx = EngineContext(schema=self.schema, stop_event=threading.Event())
         plan = self._create_execution_plan()
         return EventStream(plan.execute(ctx), ctx.control.stop_event)
 
@@ -70,7 +68,11 @@ class Engine:
                 skip_reason=PhaseSkipReason.NOT_SUPPORTED,
             )
 
-        if phase_name not in self.config.execution.phases:
+        phase = phase_name.value.lower()
+        if (
+            phase in ("examples", "coverage", "fuzzing", "stateful")
+            and not self.schema.config.phases.get_by_name(name=phase).enabled
+        ):
             return Phase(
                 name=phase_name,
                 is_supported=True,

schemathesis/engine/errors.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import enum
 import re
+from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
@@ -24,6 +25,8 @@ from schemathesis.core.errors import (
 
 if TYPE_CHECKING:
     import hypothesis.errors
+    import requests
+    from requests.exceptions import ChunkedEncodingError
 
 __all__ = ["EngineErrorInfo", "DeadlineExceeded", "UnsupportedRecursiveReference", "UnexpectedError"]
 
@@ -61,8 +64,9 @@ class EngineErrorInfo:
     It serves as a caching wrapper around exceptions to avoid repeated computations.
     """
 
-    def __init__(self, error: Exception) -> None:
+    def __init__(self, error: Exception, code_sample: str | None = None) -> None:
         self._error = error
+        self._code_sample = code_sample
 
     def __str__(self) -> str:
         return self._error_repr
@@ -212,6 +216,9 @@ class EngineErrorInfo:
             message.append("")  # Empty line before extras
             message.extend(f"{indent}{extra}" for extra in extras)
 
+        if self._code_sample is not None:
+            message.append(f"\nReproduce with: \n\n    {self._code_sample}")
+
         # Suggestion
         suggestion = get_runtime_error_suggestion(self._kind, bold=bold)
         if suggestion is not None:
@@ -403,3 +410,55 @@ def canonicalize_error_message(error: Exception, with_traceback: bool = True) ->
     message = MEMORY_ADDRESS_RE.sub("0xbaaaaaaaaaad", message)
     # Remove URL information
     return URL_IN_ERROR_MESSAGE_RE.sub("", message)
+
+
+def clear_hypothesis_notes(exc: Exception) -> None:
+    notes = getattr(exc, "__notes__", [])
+    if any("while generating" in note for note in notes):
+        notes.clear()
+
+
+def is_unrecoverable_network_error(exc: Exception) -> bool:
+    from http.client import RemoteDisconnected
+
+    from urllib3.exceptions import ProtocolError
+
+    def has_connection_reset(inner: BaseException) -> bool:
+        exc_str = str(inner)
+        if any(pattern in exc_str for pattern in ["Connection reset by peer", "[Errno 104]", "ECONNRESET"]):
+            return True
+
+        if inner.__context__ is not None:
+            return has_connection_reset(inner.__context__)
+
+        return False
+
+    if isinstance(exc.__context__, ProtocolError):
+        if len(exc.__context__.args) == 2 and isinstance(exc.__context__.args[1], RemoteDisconnected):
+            return True
+        if len(exc.__context__.args) == 1 and exc.__context__.args[0] == "Response ended prematurely":
+            return True
+
+    return has_connection_reset(exc)
+
+
+@dataclass()
+class UnrecoverableNetworkError:
+    error: requests.ConnectionError | ChunkedEncodingError
+    code_sample: str
+
+    __slots__ = ("error", "code_sample")
+
+    def __init__(self, error: requests.ConnectionError | ChunkedEncodingError, code_sample: str) -> None:
+        self.error = error
+        self.code_sample = code_sample
+
+
+@dataclass
+class TestingState:
+    unrecoverable_network_error: UnrecoverableNetworkError | None
+
+    __slots__ = ("unrecoverable_network_error",)
+
+    def __init__(self) -> None:
+        self.unrecoverable_network_error = None

schemathesis/engine/events.py

@@ -200,10 +200,18 @@ class NonFatalError(EngineEvent):
 
     __slots__ = ("id", "timestamp", "info", "value", "phase", "label", "related_to_operation")
 
-    def __init__(self, *, error: Exception, phase: PhaseName, label: str, related_to_operation: bool) -> None:
+    def __init__(
+        self,
+        *,
+        error: Exception,
+        phase: PhaseName,
+        label: str,
+        related_to_operation: bool,
+        code_sample: str | None = None,
+    ) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
-        self.info = EngineErrorInfo(error=error)
+        self.info = EngineErrorInfo(error=error, code_sample=code_sample)
         self.value = error
         self.phase = phase
         self.label = label

schemathesis/engine/phases/__init__.py

@@ -23,6 +23,16 @@ class PhaseName(str, enum.Enum):
     def defaults(cls) -> list[PhaseName]:
         return [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING, PhaseName.STATEFUL_TESTING]
 
+    @property
+    def name(self) -> str:
+        return {
+            PhaseName.PROBING: "probing",
+            PhaseName.EXAMPLES: "examples",
+            PhaseName.COVERAGE: "coverage",
+            PhaseName.FUZZING: "fuzzing",
+            PhaseName.STATEFUL_TESTING: "stateful",
+        }[self]
+
     @classmethod
     def from_str(cls, value: str) -> PhaseName:
         return {

schemathesis/engine/phases/probes.py

@@ -16,11 +16,11 @@ from typing import TYPE_CHECKING
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.core.transport import USER_AGENT
 from schemathesis.engine import Status, events
+from schemathesis.transport.prepare import get_default_headers
 
 if TYPE_CHECKING:
     import requests
 
-    from schemathesis.engine.config import NetworkConfig
     from schemathesis.engine.context import EngineContext
     from schemathesis.engine.events import EventGenerator
     from schemathesis.engine.phases import Phase
@@ -36,7 +36,7 @@ class ProbePayload:
 
 def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     """Discover capabilities of the tested app."""
-    probes = run(ctx.schema, ctx.session, ctx.config.network)
+    probes = run(ctx)
     status = Status.SUCCESS
     payload: Result[ProbePayload, Exception] | None = None
     for result in probes:
@@ -44,7 +44,7 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
             from ...specs.openapi import formats
             from ...specs.openapi.formats import HEADER_FORMAT, header_values
 
-            formats.register(HEADER_FORMAT, header_values(blacklist_characters="\n\r\x00"))
+            formats.register(HEADER_FORMAT, header_values(exclude_characters="\n\r\x00"))
         if result.error is not None:
             status = Status.ERROR
             payload = Err(result.error)
@@ -54,9 +54,9 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     yield events.PhaseFinished(phase=phase, status=status, payload=payload)
 
 
-def run(schema: BaseSchema, session: requests.Session, config: NetworkConfig) -> list[ProbeRun]:
+def run(ctx: EngineContext) -> list[ProbeRun]:
     """Run all probes against the given schema."""
-    return [send(probe(), session, schema, config) for probe in PROBES]
+    return [send(probe(), ctx) for probe in PROBES]
 
 
 HEADER_NAME = "X-Schemathesis-Probe"
@@ -124,19 +124,22 @@ class NullByteInHeader(Probe):
 PROBES = (NullByteInHeader,)
 
 
-def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: NetworkConfig) -> ProbeRun:
+def send(probe: Probe, ctx: EngineContext) -> ProbeRun:
     """Send the probe to the application."""
     from requests import PreparedRequest, Request, RequestException
     from requests.exceptions import MissingSchema
     from urllib3.exceptions import InsecureRequestWarning
 
     try:
-        request = probe.prepare_request(session, Request(), schema)
+        session = ctx.get_session()
+        request = probe.prepare_request(session, Request(), ctx.schema)
         request.headers[HEADER_NAME] = probe.name
         request.headers["User-Agent"] = USER_AGENT
+        for header, value in get_default_headers().items():
+            request.headers.setdefault(header, value)
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", InsecureRequestWarning)
-            response = session.send(request, timeout=config.timeout or 2)
+            response = session.send(request, timeout=ctx.config.request_timeout or 2)
     except MissingSchema:
         # In-process ASGI/WSGI testing will have local URLs and requires extra handling
         # which is not currently implemented

schemathesis/engine/phases/stateful/__init__.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 from schemathesis.engine import Status, events
 from schemathesis.engine.phases import Phase, PhaseName, PhaseSkipReason
+from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 
 if TYPE_CHECKING:
     from schemathesis.engine.context import EngineContext
@@ -19,7 +20,7 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
     try:
         state_machine = engine.schema.as_state_machine()
     except Exception as exc:
-        yield events.NonFatalError(error=exc, phase=phase.name, label="Stateful tests", related_to_operation=False)
+        yield events.NonFatalError(error=exc, phase=phase.name, label=STATEFUL_TESTS_LABEL, related_to_operation=False)
         yield events.PhaseFinished(phase=phase, status=Status.ERROR, payload=None)
         return