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

schemathesis/stateful/events.py

@@ -1,274 +0,0 @@
-from __future__ import annotations
-
-import time
-from dataclasses import asdict as _asdict
-from dataclasses import dataclass
-from enum import Enum
-from typing import TYPE_CHECKING, Any
-
-from ..exceptions import format_exception
-
-if TYPE_CHECKING:
-    from ..models import Case, Check
-    from ..transports.responses import GenericResponse
-    from .state_machine import APIStateMachine
-
-
-class RunStatus(str, Enum):
-    """Status of the state machine run."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    ERROR = "error"
-    INTERRUPTED = "interrupted"
-
-
-@dataclass
-class StatefulEvent:
-    """Basic stateful test event."""
-
-    timestamp: float
-
-    __slots__ = ("timestamp",)
-
-    def asdict(self) -> dict[str, Any]:
-        return _asdict(self)
-
-
-@dataclass
-class RunStarted(StatefulEvent):
-    """Before executing all scenarios."""
-
-    started_at: float
-    state_machine: type[APIStateMachine]
-
-    __slots__ = ("state_machine", "timestamp", "started_at")
-
-    def __init__(self, *, state_machine: type[APIStateMachine]) -> None:
-        self.state_machine = state_machine
-        self.started_at = time.time()
-        self.timestamp = time.monotonic()
-
-    def asdict(self) -> dict[str, Any]:
-        return {
-            "timestamp": self.timestamp,
-            "started_at": self.started_at,
-        }
-
-
-@dataclass
-class RunFinished(StatefulEvent):
-    """After executing all scenarios."""
-
-    status: RunStatus
-
-    __slots__ = ("timestamp", "status")
-
-    def __init__(self, *, status: RunStatus) -> None:
-        self.status = status
-        self.timestamp = time.monotonic()
-
-
-class SuiteStatus(str, Enum):
-    """Status of the suite execution."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    ERROR = "error"
-    INTERRUPTED = "interrupted"
-
-
-@dataclass
-class SuiteStarted(StatefulEvent):
-    """Before executing a set of scenarios."""
-
-    __slots__ = ("timestamp",)
-
-    def __init__(self) -> None:
-        self.timestamp = time.monotonic()
-
-
-@dataclass
-class SuiteFinished(StatefulEvent):
-    """After executing a set of scenarios."""
-
-    status: SuiteStatus
-    failures: list[Check]
-
-    __slots__ = ("timestamp", "status", "failures")
-
-    def __init__(self, *, status: SuiteStatus, failures: list[Check]) -> None:
-        self.status = status
-        self.failures = failures
-        self.timestamp = time.monotonic()
-
-    def asdict(self) -> dict[str, Any]:
-        from ..runner.serialization import SerializedCheck, _serialize_check
-
-        return {
-            "timestamp": self.timestamp,
-            "status": self.status,
-            "failures": [_serialize_check(SerializedCheck.from_check(failure)) for failure in self.failures],
-        }
-
-
-class ScenarioStatus(str, Enum):
-    """Status of a single scenario execution."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    ERROR = "error"
-    # Rejected by Hypothesis
-    REJECTED = "rejected"
-    INTERRUPTED = "interrupted"
-
-
-@dataclass
-class ScenarioStarted(StatefulEvent):
-    """Before a single state machine execution."""
-
-    # Whether this is a scenario that tries to reproduce a failure
-    is_final: bool
-
-    __slots__ = ("timestamp", "is_final")
-
-    def __init__(self, *, is_final: bool) -> None:
-        self.is_final = is_final
-        self.timestamp = time.monotonic()
-
-
-@dataclass
-class ScenarioFinished(StatefulEvent):
-    """After a single state machine execution."""
-
-    status: ScenarioStatus
-    # Whether this is a scenario that tries to reproduce a failure
-    is_final: bool
-
-    __slots__ = ("timestamp", "status", "is_final")
-
-    def __init__(self, *, status: ScenarioStatus, is_final: bool) -> None:
-        self.status = status
-        self.is_final = is_final
-        self.timestamp = time.monotonic()
-
-
-class StepStatus(str, Enum):
-    """Status of a single state machine step."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    ERROR = "error"
-    INTERRUPTED = "interrupted"
-
-
-@dataclass
-class StepStarted(StatefulEvent):
-    """Before a single state machine step."""
-
-    __slots__ = ("timestamp",)
-
-    def __init__(self) -> None:
-        self.timestamp = time.monotonic()
-
-
-@dataclass
-class TransitionId:
-    """Id of the the that was hit."""
-
-    name: str
-    # Status code as defined in the transition, i.e. may be `default`
-    status_code: str
-    source: str
-
-    __slots__ = ("name", "status_code", "source")
-
-
-@dataclass
-class ResponseData:
-    """Common data for responses."""
-
-    status_code: int
-    elapsed: float
-    __slots__ = ("status_code", "elapsed")
-
-
-@dataclass
-class StepFinished(StatefulEvent):
-    """After a single state machine step."""
-
-    status: StepStatus | None
-    transition_id: TransitionId | None
-    target: str
-    case: Case
-    response: GenericResponse | None
-    checks: list[Check]
-
-    __slots__ = ("timestamp", "status", "transition_id", "target", "case", "response", "checks")
-
-    def __init__(
-        self,
-        *,
-        status: StepStatus | None,
-        transition_id: TransitionId | None,
-        target: str,
-        case: Case,
-        response: GenericResponse | None,
-        checks: list[Check],
-    ) -> None:
-        self.status = status
-        self.transition_id = transition_id
-        self.target = target
-        self.case = case
-        self.response = response
-        self.checks = checks
-        self.timestamp = time.monotonic()
-
-    def asdict(self) -> dict[str, Any]:
-        return {
-            "timestamp": self.timestamp,
-            "status": self.status,
-            "transition_id": {
-                "name": self.transition_id.name,
-                "status_code": self.transition_id.status_code,
-                "source": self.transition_id.source,
-            }
-            if self.transition_id is not None
-            else None,
-            "target": self.target,
-            "response": {
-                "status_code": self.response.status_code,
-                "elapsed": self.response.elapsed.total_seconds(),
-            }
-            if self.response is not None
-            else None,
-        }
-
-
-@dataclass
-class Interrupted(StatefulEvent):
-    """The state machine execution was interrupted."""
-
-    __slots__ = ("timestamp",)
-
-    def __init__(self) -> None:
-        self.timestamp = time.monotonic()
-
-
-@dataclass
-class Errored(StatefulEvent):
-    """An error occurred during the state machine execution."""
-
-    exception: Exception
-
-    __slots__ = ("timestamp", "exception")
-
-    def __init__(self, *, exception: Exception) -> None:
-        self.exception = exception
-        self.timestamp = time.monotonic()
-
-    def asdict(self) -> dict[str, Any]:
-        return {
-            "timestamp": self.timestamp,
-            "exception": format_exception(self.exception, True),
-        }

schemathesis/stateful/runner.py

@@ -1,309 +0,0 @@
-from __future__ import annotations
-
-import queue
-import threading
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generator, Iterator
-
-import hypothesis
-import requests
-from hypothesis.control import current_build_context
-from hypothesis.errors import Flaky, Unsatisfiable
-
-from ..exceptions import CheckFailed
-from ..internal.checks import CheckContext
-from ..targets import TargetMetricCollector
-from . import events
-from .config import StatefulTestRunnerConfig
-from .context import RunnerContext
-from .validation import validate_response
-
-if TYPE_CHECKING:
-    from hypothesis.stateful import Rule
-
-    from ..models import Case, CheckFunction
-    from ..transports.responses import GenericResponse
-    from .state_machine import APIStateMachine, Direction, StepResult
-
-EVENT_QUEUE_TIMEOUT = 0.01
-
-
-@dataclass
-class StatefulTestRunner:
-    """Stateful test runner for the given state machine.
-
-    By default, the test runner executes the state machine in a loop until there are no new failures are found.
-    The loop is executed in a separate thread for better control over the execution and reporting.
-    """
-
-    # State machine class to use
-    state_machine: type[APIStateMachine]
-    # Test runner configuration that defines the runtime behavior
-    config: StatefulTestRunnerConfig = field(default_factory=StatefulTestRunnerConfig)
-    # Event to stop the execution
-    stop_event: threading.Event = field(default_factory=threading.Event)
-    # Queue to communicate with the state machine execution
-    event_queue: queue.Queue = field(default_factory=queue.Queue)
-
-    def execute(self) -> Iterator[events.StatefulEvent]:
-        """Execute a test run for a state machine."""
-        self.stop_event.clear()
-
-        yield events.RunStarted(state_machine=self.state_machine)
-
-        runner_thread = threading.Thread(
-            target=_execute_state_machine_loop,
-            kwargs={
-                "state_machine": self.state_machine,
-                "event_queue": self.event_queue,
-                "config": self.config,
-                "stop_event": self.stop_event,
-            },
-        )
-        run_status = events.RunStatus.SUCCESS
-
-        with thread_manager(runner_thread):
-            try:
-                while True:
-                    try:
-                        event = self.event_queue.get(timeout=EVENT_QUEUE_TIMEOUT)
-                        # 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):
-                            if event.status == events.SuiteStatus.FAILURE:
-                                run_status = events.RunStatus.FAILURE
-                            elif event.status == events.SuiteStatus.ERROR:
-                                run_status = events.RunStatus.ERROR
-                            elif event.status == events.SuiteStatus.INTERRUPTED:
-                                run_status = events.RunStatus.INTERRUPTED
-                        yield event
-                    except queue.Empty:
-                        if not runner_thread.is_alive():
-                            break
-            except KeyboardInterrupt:
-                # Immediately notify the runner thread to stop, even though that the event will be set below in `finally`
-                self.stop()
-                run_status = events.RunStatus.INTERRUPTED
-                yield events.Interrupted()
-            finally:
-                self.stop()
-
-            yield events.RunFinished(status=run_status)
-
-    def stop(self) -> None:
-        """Stop the execution of the state machine."""
-        self.stop_event.set()
-
-
-@contextmanager
-def thread_manager(thread: threading.Thread) -> Generator[None, None, None]:
-    thread.start()
-    try:
-        yield
-    finally:
-        thread.join()
-
-
-def _execute_state_machine_loop(
-    *,
-    state_machine: type[APIStateMachine],
-    event_queue: queue.Queue,
-    config: StatefulTestRunnerConfig,
-    stop_event: threading.Event,
-) -> None:
-    """Execute the state machine testing loop."""
-    from hypothesis import reporting
-    from requests.structures import CaseInsensitiveDict
-
-    from ..transports import RequestsTransport
-
-    ctx = RunnerContext(metric_collector=TargetMetricCollector(targets=config.targets))
-
-    call_kwargs: dict[str, Any] = {"headers": config.headers}
-    if isinstance(state_machine.schema.transport, RequestsTransport):
-        call_kwargs["timeout"] = config.request.prepared_timeout
-        call_kwargs["verify"] = config.request.tls_verify
-        call_kwargs["cert"] = config.request.cert
-        if config.request.proxy is not None:
-            call_kwargs["proxies"] = {"all": config.request.proxy}
-        session = requests.Session()
-        if config.auth is not None:
-            session.auth = config.auth
-        call_kwargs["session"] = session
-    check_ctx = CheckContext(
-        override=config.override,
-        auth=config.auth,
-        headers=CaseInsensitiveDict(config.headers) if config.headers else None,
-    )
-
-    class _InstrumentedStateMachine(state_machine):  # type: ignore[valid-type,misc]
-        """State machine with additional hooks for emitting events."""
-
-        def setup(self) -> None:
-            build_ctx = current_build_context()
-            event_queue.put(events.ScenarioStarted(is_final=build_ctx.is_final))
-            super().setup()
-
-        def get_call_kwargs(self, case: Case) -> dict[str, Any]:
-            return call_kwargs
-
-        def _repr_step(self, rule: Rule, data: dict, result: StepResult) -> str:
-            return ""
-
-        if config.override is not None:
-
-            def before_call(self, case: Case) -> None:
-                for location, entry in config.override.for_operation(case.operation).items():  # type: ignore[union-attr]
-                    if entry:
-                        container = getattr(case, location) or {}
-                        container.update(entry)
-                        setattr(case, location, container)
-                return super().before_call(case)
-
-        def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult | None:
-            # Checking the stop event once inside `step` is sufficient as it is called frequently
-            # The idea is to stop the execution as soon as possible
-            if stop_event.is_set():
-                raise KeyboardInterrupt
-            event_queue.put(events.StepStarted())
-            try:
-                if config.dry_run:
-                    return None
-                if config.unique_data:
-                    cached = ctx.get_step_outcome(case)
-                    if isinstance(cached, BaseException):
-                        raise cached
-                    elif cached is None:
-                        return None
-                result = super().step(case, previous)
-                ctx.step_succeeded()
-            except CheckFailed as exc:
-                if config.unique_data:
-                    ctx.store_step_outcome(case, exc)
-                ctx.step_failed()
-                raise
-            except Exception as exc:
-                if config.unique_data:
-                    ctx.store_step_outcome(case, exc)
-                ctx.step_errored()
-                raise
-            except KeyboardInterrupt:
-                ctx.step_interrupted()
-                raise
-            except BaseException as exc:
-                if config.unique_data:
-                    ctx.store_step_outcome(case, exc)
-                raise exc
-            else:
-                if config.unique_data:
-                    ctx.store_step_outcome(case, None)
-            finally:
-                transition_id: events.TransitionId | None
-                if previous is not None:
-                    transition = previous[1]
-                    transition_id = events.TransitionId(
-                        name=transition.name,
-                        status_code=transition.status_code,
-                        source=transition.operation.verbose_name,
-                    )
-                else:
-                    transition_id = None
-                event_queue.put(
-                    events.StepFinished(
-                        status=ctx.current_step_status,
-                        transition_id=transition_id,
-                        target=case.operation.verbose_name,
-                        case=case,
-                        response=ctx.current_response,
-                        checks=ctx.checks_for_step,
-                    )
-                )
-                ctx.reset_step()
-            return result
-
-        def validate_response(
-            self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
-        ) -> None:
-            ctx.collect_metric(case, response)
-            ctx.current_response = response
-            validate_response(
-                response=response,
-                case=case,
-                runner_ctx=ctx,
-                check_ctx=check_ctx,
-                checks=config.checks,
-                additional_checks=additional_checks,
-                max_response_time=config.max_response_time,
-            )
-
-        def teardown(self) -> None:
-            build_ctx = current_build_context()
-            event_queue.put(
-                events.ScenarioFinished(
-                    status=ctx.current_scenario_status,
-                    is_final=build_ctx.is_final,
-                )
-            )
-            ctx.maximize_metrics()
-            ctx.reset_scenario()
-            super().teardown()
-
-    if config.seed is not None:
-        InstrumentedStateMachine = hypothesis.seed(config.seed)(_InstrumentedStateMachine)
-    else:
-        InstrumentedStateMachine = _InstrumentedStateMachine
-
-    def should_stop() -> bool:
-        return config.exit_first or (config.max_failures is not None and ctx.failures_count >= config.max_failures)
-
-    while True:
-        # This loop is running until no new failures are found in a single iteration
-        event_queue.put(events.SuiteStarted())
-        if stop_event.is_set():
-            event_queue.put(events.SuiteFinished(status=events.SuiteStatus.INTERRUPTED, failures=[]))
-            break
-        suite_status = events.SuiteStatus.SUCCESS
-        try:
-            with reporting.with_reporter(lambda _: None):  # type: ignore
-                InstrumentedStateMachine.run(settings=config.hypothesis_settings)
-        except KeyboardInterrupt:
-            # Raised in the state machine when the stop event is set or it is raised by the user's code
-            # that is placed in the base class of the state machine.
-            # Therefore, set the stop event to cover the latter case
-            stop_event.set()
-            suite_status = events.SuiteStatus.INTERRUPTED
-            break
-        except CheckFailed as exc:
-            # When a check fails, the state machine is stopped
-            # The failure is already sent to the queue by the state machine
-            # Here we need to either exit or re-run the state machine with this failure marked as known
-            suite_status = events.SuiteStatus.FAILURE
-            if should_stop():
-                break
-            ctx.mark_as_seen_in_run(exc)
-            continue
-        except Flaky:
-            suite_status = events.SuiteStatus.FAILURE
-            if should_stop():
-                break
-            # Mark all failures in this suite as seen to prevent them being re-discovered
-            ctx.mark_current_suite_as_seen_in_run()
-            continue
-        except Exception as exc:
-            if isinstance(exc, Unsatisfiable) and ctx.completed_scenarios > 0:
-                # Sometimes Hypothesis randomly gives up on generating some complex cases. However, if we know that
-                # values are possible to generate based on the previous observations, we retry the generation
-                if ctx.completed_scenarios >= config.hypothesis_settings.max_examples:
-                    # Avoid infinite restarts
-                    break
-                continue
-            # Any other exception is an inner error and the test run should be stopped
-            suite_status = events.SuiteStatus.ERROR
-            event_queue.put(events.Errored(exception=exc))
-            break
-        finally:
-            event_queue.put(events.SuiteFinished(status=suite_status, failures=ctx.failures_for_suite))
-            ctx.reset()
-        # Exit on the first successful state machine execution
-        break

schemathesis/stateful/sink.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
-
-from . import events
-
-if TYPE_CHECKING:
-    from ..models import Check
-    from .statistic import TransitionStats
-
-
-@dataclass
-class AverageResponseTime:
-    """Average response time for a given status code.
-
-    Stored as a sum of all response times and a count of responses.
-    """
-
-    total: float
-    count: int
-
-    __slots__ = ("total", "count")
-
-    def __init__(self) -> None:
-        self.total = 0.0
-        self.count = 0
-
-
-@dataclass
-class StateMachineSink:
-    """Collects events and stores data about the state machine execution."""
-
-    transitions: TransitionStats
-    response_times: dict[str, dict[int, AverageResponseTime]] = field(default_factory=dict)
-    steps: dict[events.StepStatus, int] = field(default_factory=lambda: {status: 0 for status in events.StepStatus})
-    scenarios: dict[events.ScenarioStatus, int] = field(
-        default_factory=lambda: {status: 0 for status in events.ScenarioStatus}
-    )
-    suites: dict[events.SuiteStatus, int] = field(default_factory=lambda: {status: 0 for status in events.SuiteStatus})
-    failures: list[Check] = field(default_factory=list)
-    start_time: float | None = None
-    end_time: float | None = None
-
-    def consume(self, event: events.StatefulEvent) -> None:
-        self.transitions.consume(event)
-        if isinstance(event, events.RunStarted):
-            self.start_time = event.timestamp
-        elif isinstance(event, events.StepFinished) and event.status is not None:
-            self.steps[event.status] += 1
-            responses = self.response_times.setdefault(event.target, {})
-            if event.response is not None:
-                average = responses.setdefault(event.response.status_code, AverageResponseTime())
-                average.total += event.response.elapsed.total_seconds()
-                average.count += 1
-        elif isinstance(event, events.ScenarioFinished):
-            self.scenarios[event.status] += 1
-        elif isinstance(event, events.SuiteFinished):
-            self.suites[event.status] += 1
-            self.failures.extend(event.failures)
-        elif isinstance(event, events.RunFinished):
-            self.end_time = event.timestamp
-
-    @property
-    def duration(self) -> float | None:
-        if self.start_time is not None and self.end_time is not None:
-            return self.end_time - self.start_time
-        return None