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

schemathesis/engine/events.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generator
+
+from schemathesis.core.result import Result
+from schemathesis.engine.errors import EngineErrorInfo
+from schemathesis.engine.phases import Phase, PhaseName
+from schemathesis.engine.recorder import ScenarioRecorder
+
+if TYPE_CHECKING:
+    from schemathesis.engine import Status
+    from schemathesis.engine.phases.probes import ProbePayload
+
+EventGenerator = Generator["EngineEvent", None, None]
+
+
+@dataclass
+class EngineEvent:
+    """An event within the engine's lifecycle."""
+
+    id: uuid.UUID
+    timestamp: float
+    # Indicates whether this event is the last in the event stream
+    is_terminal = False
+
+
+@dataclass
+class EngineStarted(EngineEvent):
+    """Start of an engine."""
+
+    __slots__ = ("id", "timestamp")
+
+    def __init__(self) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+
+
+@dataclass
+class PhaseEvent(EngineEvent):
+    """Event associated with a specific execution phase."""
+
+    phase: Phase
+
+
+@dataclass
+class PhaseStarted(PhaseEvent):
+    """Start of an execution phase."""
+
+    __slots__ = ("id", "timestamp", "phase")
+
+    def __init__(self, *, phase: Phase) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.phase = phase
+
+
+@dataclass
+class PhaseFinished(PhaseEvent):
+    """End of an execution phase."""
+
+    status: Status
+    payload: Result[ProbePayload, Exception] | None
+
+    __slots__ = ("id", "timestamp", "phase", "status", "payload")
+
+    def __init__(self, *, phase: Phase, status: Status, payload: Result[ProbePayload, Exception] | None) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.phase = phase
+        self.status = status
+        self.payload = payload
+
+
+@dataclass
+class TestEvent(EngineEvent):
+    phase: PhaseName
+
+
+@dataclass
+class SuiteStarted(TestEvent):
+    """Before executing a set of scenarios."""
+
+    __slots__ = ("id", "timestamp", "phase")
+
+    def __init__(self, *, phase: PhaseName) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.phase = phase
+
+
+@dataclass
+class SuiteFinished(TestEvent):
+    """After executing a set of test scenarios."""
+
+    status: Status
+
+    __slots__ = ("id", "timestamp", "phase", "status")
+
+    def __init__(self, *, id: uuid.UUID, phase: PhaseName, status: Status) -> None:
+        self.id = id
+        self.timestamp = time.time()
+        self.phase = phase
+        self.status = status
+
+
+@dataclass
+class ScenarioEvent(TestEvent):
+    suite_id: uuid.UUID
+
+
+@dataclass
+class ScenarioStarted(ScenarioEvent):
+    """Before executing a grouped set of test steps."""
+
+    __slots__ = ("id", "timestamp", "phase", "suite_id", "label")
+
+    def __init__(self, *, phase: PhaseName, suite_id: uuid.UUID, label: str | None) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.phase = phase
+        self.suite_id = suite_id
+        self.label = label
+
+
+@dataclass
+class ScenarioFinished(ScenarioEvent):
+    """After executing a grouped set of test steps."""
+
+    status: Status
+    recorder: ScenarioRecorder
+    elapsed_time: float
+    skip_reason: str | None
+    # Whether this is a scenario that tries to reproduce a failure
+    is_final: bool
+
+    __slots__ = (
+        "id",
+        "timestamp",
+        "phase",
+        "suite_id",
+        "label",
+        "status",
+        "recorder",
+        "elapsed_time",
+        "skip_reason",
+        "is_final",
+    )
+
+    def __init__(
+        self,
+        *,
+        id: uuid.UUID,
+        phase: PhaseName,
+        suite_id: uuid.UUID,
+        label: str | None,
+        status: Status,
+        recorder: ScenarioRecorder,
+        elapsed_time: float,
+        skip_reason: str | None,
+        is_final: bool,
+    ) -> None:
+        self.id = id
+        self.timestamp = time.time()
+        self.phase = phase
+        self.suite_id = suite_id
+        self.label = label
+        self.status = status
+        self.recorder = recorder
+        self.elapsed_time = elapsed_time
+        self.skip_reason = skip_reason
+        self.is_final = is_final
+
+
+@dataclass
+class Interrupted(EngineEvent):
+    """If execution was interrupted by Ctrl-C, or a received SIGTERM."""
+
+    phase: PhaseName | None
+
+    __slots__ = ("id", "timestamp", "phase")
+
+    def __init__(self, *, phase: PhaseName | None) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.phase = phase
+
+
+@dataclass
+class NonFatalError(EngineEvent):
+    """Error that doesn't halt execution but should be reported."""
+
+    info: EngineErrorInfo
+    value: Exception
+    phase: PhaseName
+    label: str
+    related_to_operation: bool
+
+    __slots__ = ("id", "timestamp", "info", "value", "phase", "label", "related_to_operation")
+
+    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, code_sample=code_sample)
+        self.value = error
+        self.phase = phase
+        self.label = label
+        self.related_to_operation = related_to_operation
+
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, NonFatalError)
+        return self.label == other.label and type(self.value) is type(other.value)
+
+    def __hash__(self) -> int:
+        return hash((self.label, type(self.value)))
+
+
+@dataclass
+class FatalError(EngineEvent):
+    """Internal error in the engine."""
+
+    exception: Exception
+    is_terminal = True
+
+    __slots__ = ("id", "timestamp", "exception")
+
+    def __init__(self, *, exception: Exception) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.exception = exception
+
+
+@dataclass
+class EngineFinished(EngineEvent):
+    """The final event of the run.
+
+    No more events after this point.
+    """
+
+    is_terminal = True
+    running_time: float
+
+    __slots__ = ("id", "timestamp", "running_time")
+
+    def __init__(self, *, running_time: float) -> None:
+        self.id = uuid.uuid4()
+        self.timestamp = time.time()
+        self.running_time = running_time

schemathesis/engine/phases/__init__.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import enum
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from schemathesis.engine.context import EngineContext
+    from schemathesis.engine.events import EventGenerator
+
+
+class PhaseName(str, enum.Enum):
+    """Available execution phases."""
+
+    PROBING = "API probing"
+    EXAMPLES = "Examples"
+    COVERAGE = "Coverage"
+    FUZZING = "Fuzzing"
+    STATEFUL_TESTING = "Stateful"
+
+    @classmethod
+    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 {
+            "probing": cls.PROBING,
+            "examples": cls.EXAMPLES,
+            "coverage": cls.COVERAGE,
+            "fuzzing": cls.FUZZING,
+            "stateful": cls.STATEFUL_TESTING,
+        }[value.lower()]
+
+
+class PhaseSkipReason(str, enum.Enum):
+    """Reasons why a phase might not be executed."""
+
+    DISABLED = "disabled"  # Explicitly disabled via config
+    NOT_SUPPORTED = "not supported"  # Feature not supported by schema
+    NOT_APPLICABLE = "not applicable"  # No relevant data (e.g., no links for stateful)
+    FAILURE_LIMIT_REACHED = "failure limit reached"
+    NOTHING_TO_TEST = "nothing to test"
+
+
+@dataclass
+class Phase:
+    """A logically separate engine execution phase."""
+
+    name: PhaseName
+    is_supported: bool
+    is_enabled: bool = True
+    skip_reason: PhaseSkipReason | None = None
+
+    def should_execute(self, ctx: EngineContext) -> bool:
+        """Determine if phase should run based on context & configuration."""
+        return self.is_enabled and not ctx.has_to_stop
+
+
+def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
+    from urllib3.exceptions import InsecureRequestWarning
+
+    from . import probes, stateful, unit
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", InsecureRequestWarning)
+
+        if phase.name == PhaseName.PROBING:
+            yield from probes.execute(ctx, phase)
+        elif phase.name == PhaseName.EXAMPLES:
+            yield from unit.execute(ctx, phase)
+        elif phase.name == PhaseName.COVERAGE:
+            yield from unit.execute(ctx, phase)
+        elif phase.name == PhaseName.FUZZING:
+            yield from unit.execute(ctx, phase)
+        elif phase.name == PhaseName.STATEFUL_TESTING:
+            yield from stateful.execute(ctx, phase)

schemathesis/{runner → engine/phases}/probes.py

@@ -10,32 +10,56 @@ from __future__ import annotations
 
 import enum
 import warnings
-from dataclasses import asdict, dataclass, field
-from typing import TYPE_CHECKING, Any
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from ..constants import USER_AGENT
-from ..exceptions import format_exception
-from ..models import Request, Response
-from ..sanitization import sanitize_request, sanitize_response
-from ..transports import RequestConfig
-from ..transports.auth import get_requests_auth
+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 ..schemas import BaseSchema
+    from schemathesis.engine.context import EngineContext
+    from schemathesis.engine.events import EventGenerator
+    from schemathesis.engine.phases import Phase
+    from schemathesis.schemas import BaseSchema
 
 
-HEADER_NAME = "X-Schemathesis-Probe"
+@dataclass
+class ProbePayload:
+    probes: list[ProbeRun]
+
+    __slots__ = ("probes",)
+
+
+def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
+    """Discover capabilities of the tested app."""
+    probes = run(ctx)
+    status = Status.SUCCESS
+    payload: Result[ProbePayload, Exception] | None = None
+    for result in probes:
+        if isinstance(result.probe, NullByteInHeader) and result.is_failure:
+            from ...specs.openapi import formats
+            from ...specs.openapi.formats import HEADER_FORMAT, header_values
+
+            formats.register(HEADER_FORMAT, header_values(exclude_characters="\n\r\x00"))
+        if result.error is not None:
+            status = Status.ERROR
+            payload = Err(result.error)
+        else:
+            status = Status.SUCCESS
+            payload = Ok(ProbePayload(probes=probes))
+    yield events.PhaseFinished(phase=phase, status=status, payload=payload)
 
 
-@dataclass
-class ProbeConfig:
-    base_url: str | None = None
-    request: RequestConfig = field(default_factory=RequestConfig)
-    auth: tuple[str, str] | None = None
-    auth_type: str | None = None
-    headers: dict[str, str] | None = None
+def run(ctx: EngineContext) -> list[ProbeRun]:
+    """Run all probes against the given schema."""
+    return [send(probe(), ctx) for probe in PROBES]
+
+
+HEADER_NAME = "X-Schemathesis-Probe"
 
 
 @dataclass
@@ -45,7 +69,7 @@ class Probe:
     name: str
 
     def prepare_request(
-        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: ProbeConfig
+        self, session: requests.Session, request: requests.Request, schema: BaseSchema
     ) -> requests.PreparedRequest:
         raise NotImplementedError
 
@@ -70,49 +94,24 @@ class ProbeRun:
     outcome: ProbeOutcome
     request: requests.PreparedRequest | None = None
     response: requests.Response | None = None
-    error: requests.RequestException | None = None
+    error: Exception | None = None
 
     @property
     def is_failure(self) -> bool:
         return self.outcome == ProbeOutcome.FAILURE
 
-    def serialize(self) -> dict[str, Any]:
-        """Serialize probe results so it can be sent over the network."""
-        if self.request:
-            _request = Request.from_prepared_request(self.request)
-            sanitize_request(_request)
-            request = asdict(_request)
-        else:
-            request = None
-        if self.response:
-            sanitize_response(self.response)
-            response = asdict(Response.from_requests(self.response))
-        else:
-            response = None
-        if self.error:
-            error = format_exception(self.error)
-        else:
-            error = None
-        return {
-            "name": self.probe.name,
-            "outcome": self.outcome.value,
-            "request": request,
-            "response": response,
-            "error": error,
-        }
-
 
 @dataclass
 class NullByteInHeader(Probe):
     """Support NULL bytes in headers."""
 
-    name: str = "NULL_BYTE_IN_HEADER"
+    name: str = "Supports NULL byte in headers"
 
     def prepare_request(
-        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: ProbeConfig
+        self, session: requests.Session, request: requests.Request, schema: BaseSchema
     ) -> requests.PreparedRequest:
         request.method = "GET"
-        request.url = config.base_url or schema.get_base_url()
+        request.url = schema.get_base_url()
         request.headers = {"X-Schemathesis-Probe-Null": "\x00"}
         return session.prepare_request(request)
 
@@ -125,22 +124,22 @@ class NullByteInHeader(Probe):
 PROBES = (NullByteInHeader,)
 
 
-def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: ProbeConfig) -> 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, config)
+        session = ctx.get_session()
+        request = probe.prepare_request(session, Request(), ctx.schema)
         request.headers[HEADER_NAME] = probe.name
         request.headers["User-Agent"] = USER_AGENT
-        kwargs: dict[str, Any] = {"timeout": config.request.prepared_timeout or 2}
-        if config.request.proxy is not None:
-            kwargs["proxies"] = {"all": config.request.proxy}
+        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, **kwargs)
+            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
@@ -150,18 +149,3 @@ def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: Pr
         return ProbeRun(probe, ProbeOutcome.ERROR, req, None, exc)
     result_type = probe.analyze_response(response)
     return ProbeRun(probe, result_type, request, response)
-
-
-def run(schema: BaseSchema, config: ProbeConfig) -> list[ProbeRun]:
-    """Run all probes against the given schema."""
-    from requests import Session
-
-    session = Session()
-    session.headers.update(config.headers or {})
-    session.verify = config.request.tls_verify
-    if config.request.cert is not None:
-        session.cert = config.request.cert
-    if config.auth is not None:
-        session.auth = get_requests_auth(config.auth, config.auth_type)
-
-    return [send(probe(), session, schema, config) for probe in PROBES]

schemathesis/engine/phases/stateful/__init__.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import queue
+import threading
+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
+
+EVENT_QUEUE_TIMEOUT = 0.01
+
+
+def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
+    from schemathesis.engine.phases.stateful._executor import execute_state_machine_loop
+
+    try:
+        state_machine = engine.schema.as_state_machine()
+    except Exception as exc:
+        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
+
+    event_queue: queue.Queue = queue.Queue()
+
+    thread = threading.Thread(
+        target=execute_state_machine_loop,
+        kwargs={"state_machine": state_machine, "event_queue": event_queue, "engine": engine},
+        name="schemathesis_stateful_tests",
+    )
+    status: Status | None = None
+    is_executed = False
+
+    thread.start()
+    try:
+        while True:
+            try:
+                event = event_queue.get(timeout=EVENT_QUEUE_TIMEOUT)
+                is_executed = True
+                # Set the run status based on the suite status
+                # ERROR & INTERRUPTED statuses are terminal, therefore they should not be overridden
+                if (
+                    isinstance(event, events.SuiteFinished)
+                    and event.status != Status.SKIP
+                    and (status is None or status < event.status)
+                ):
+                    status = event.status
+                yield event
+            except queue.Empty:
+                if not thread.is_alive():
+                    break
+    except KeyboardInterrupt:
+        # Immediately notify the engine thread to stop, even though that the event will be set below in `finally`
+        engine.stop()
+        status = Status.INTERRUPTED
+        yield events.Interrupted(phase=PhaseName.STATEFUL_TESTING)
+    finally:
+        thread.join()
+
+    if not is_executed:
+        phase.skip_reason = PhaseSkipReason.NOTHING_TO_TEST
+        status = Status.SKIP
+    elif status is None:
+        status = Status.SKIP
+    yield events.PhaseFinished(phase=phase, status=status, payload=None)