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

schemathesis/stateful/state_machine.py

@@ -1,328 +0,0 @@
-from __future__ import annotations
-
-import re
-import time
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import TYPE_CHECKING, Any, ClassVar
-
-from hypothesis.errors import InvalidDefinition
-from hypothesis.stateful import RuleBasedStateMachine
-
-from .._dependency_versions import HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS
-from ..constants import NO_LINKS_ERROR_MESSAGE, NOT_SET
-from ..exceptions import UsageError
-from ..internal.checks import CheckFunction
-from ..models import APIOperation, Case
-from .config import _default_hypothesis_settings_factory
-from .runner import StatefulTestRunner, StatefulTestRunnerConfig
-from .sink import StateMachineSink
-
-if TYPE_CHECKING:
-    import hypothesis
-    from requests.structures import CaseInsensitiveDict
-
-    from ..schemas import BaseSchema
-    from ..transports.responses import GenericResponse
-    from .statistic import TransitionStats
-
-
-@dataclass
-class StepResult:
-    """Output from a single transition of a state machine."""
-
-    response: GenericResponse
-    case: Case
-    elapsed: float
-
-
-def _normalize_name(name: str) -> str:
-    return re.sub(r"\W|^(?=\d)", "_", name).replace("__", "_")
-
-
-class APIStateMachine(RuleBasedStateMachine):
-    """The base class for state machines generated from API schemas.
-
-    Exposes additional extension points in the testing process.
-    """
-
-    # This is a convenience attribute, which happened to clash with `RuleBasedStateMachine` instance level attribute
-    # They don't interfere, since it is properly overridden on the Hypothesis side, but it is likely that this
-    # attribute will be renamed in the future
-    bundles: ClassVar[dict[str, CaseInsensitiveDict]]  # type: ignore
-    schema: BaseSchema
-    # A template for transition statistics that can be filled with data from the state machine during its execution
-    _transition_stats_template: ClassVar[TransitionStats]
-
-    def __init__(self) -> None:
-        try:
-            super().__init__()  # type: ignore
-        except InvalidDefinition as exc:
-            if "defines no rules" in str(exc):
-                raise UsageError(NO_LINKS_ERROR_MESSAGE) from None
-            raise
-        self.setup()
-
-    @classmethod
-    @lru_cache
-    def _to_test_case(cls) -> type:
-        from . import run_state_machine_as_test
-
-        class StateMachineTestCase(RuleBasedStateMachine.TestCase):
-            settings = _default_hypothesis_settings_factory()
-
-            def runTest(self) -> None:
-                run_state_machine_as_test(cls, settings=self.settings)
-
-            runTest.is_hypothesis_test = True  # type: ignore[attr-defined]
-
-        StateMachineTestCase.__name__ = cls.__name__ + ".TestCase"
-        StateMachineTestCase.__qualname__ = cls.__qualname__ + ".TestCase"
-        return StateMachineTestCase
-
-    def _pretty_print(self, value: Any) -> str:
-        if isinstance(value, Case):
-            # State machines suppose to be reproducible, hence it is OK to get kwargs here
-            kwargs = self.get_call_kwargs(value)
-            return _print_case(value, kwargs)
-        return super()._pretty_print(value)  # type: ignore
-
-    if HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS:
-
-        def _new_name(self, target: str) -> str:
-            target = _normalize_name(target)
-            return super()._new_name(target)  # type: ignore
-
-    def _get_target_for_result(self, result: StepResult) -> str | None:
-        raise NotImplementedError
-
-    def _add_result_to_targets(self, targets: tuple[str, ...], result: StepResult | None) -> None:
-        if result is None:
-            return
-        target = self._get_target_for_result(result)
-        if target is not None:
-            super()._add_result_to_targets((target,), result)
-
-    @classmethod
-    def format_rules(cls) -> str:
-        raise NotImplementedError
-
-    @classmethod
-    def run(cls, *, settings: hypothesis.settings | None = None) -> None:
-        """Run state machine as a test."""
-        from . import run_state_machine_as_test
-
-        return run_state_machine_as_test(cls, settings=settings)
-
-    @classmethod
-    def runner(cls, *, config: StatefulTestRunnerConfig | None = None) -> StatefulTestRunner:
-        """Create a runner for this state machine."""
-        from .runner import StatefulTestRunnerConfig
-
-        return StatefulTestRunner(cls, config=config or StatefulTestRunnerConfig())
-
-    @classmethod
-    def sink(cls) -> StateMachineSink:
-        """Create a sink to collect events into."""
-        return StateMachineSink(transitions=cls._transition_stats_template.copy())
-
-    def setup(self) -> None:
-        """Hook method that runs unconditionally in the beginning of each test scenario.
-
-        Does nothing by default.
-        """
-
-    def teardown(self) -> None:
-        pass
-
-    # To provide the return type in the rendered documentation
-    teardown.__doc__ = RuleBasedStateMachine.teardown.__doc__
-
-    def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
-        raise NotImplementedError
-
-    def _step(self, case: Case, previous: StepResult | None = None, link: Direction | None = None) -> StepResult | None:
-        # This method is a proxy that is used under the hood during the state machine initialization.
-        # The whole point of having it is to make it possible to override `step`; otherwise, custom "step" is ignored.
-        # It happens because, at the point of initialization, the final class is not yet created.
-        __tracebackhide__ = True
-        if previous is not None and link is not None:
-            return self.step(case, (previous, link))
-        return self.step(case, None)
-
-    def step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult | None:
-        """A single state machine step.
-
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-        :param previous: Optional result from the previous step and the direction in which this step should be done.
-
-        Schemathesis prepares data, makes a call and validates the received response.
-        It is the most high-level point to extend the testing process. You probably don't need it in most cases.
-        """
-        from ..specs.openapi.checks import use_after_free
-
-        __tracebackhide__ = True
-        if previous is not None:
-            result, direction = previous
-            case = self.transform(result, direction, case)
-        self.before_call(case)
-        kwargs = self.get_call_kwargs(case)
-        start = time.monotonic()
-        response = self.call(case, **kwargs)
-        self._transport_kwargs = kwargs
-        elapsed = time.monotonic() - start
-        self.after_call(response, case)
-        self.validate_response(response, case, additional_checks=(use_after_free,))
-        return self.store_result(response, case, elapsed)
-
-    def before_call(self, case: Case) -> None:
-        """Hook method for modifying the case data before making a request.
-
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-
-        Use it if you want to inject static data, for example,
-        a query parameter that should always be used in API calls:
-
-        .. code-block:: python
-
-            class APIWorkflow(schema.as_state_machine()):
-                def before_call(self, case):
-                    case.query = case.query or {}
-                    case.query["test"] = "true"
-
-        You can also modify data only for some operations:
-
-        .. code-block:: python
-
-            class APIWorkflow(schema.as_state_machine()):
-                def before_call(self, case):
-                    if case.method == "PUT" and case.path == "/items":
-                        case.body["is_fake"] = True
-        """
-
-    def after_call(self, response: GenericResponse, case: Case) -> None:
-        """Hook method for additional actions with case or response instances.
-
-        :param response: Response from the application under test.
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-
-        For example, you can log all response statuses by using this hook:
-
-        .. code-block:: python
-
-            import logging
-
-            logger = logging.getLogger(__file__)
-            logger.setLevel(logging.INFO)
-
-
-            class APIWorkflow(schema.as_state_machine()):
-                def after_call(self, response, case):
-                    logger.info(
-                        "%s %s -> %d",
-                        case.method,
-                        case.path,
-                        response.status_code,
-                    )
-
-
-            # POST /users/ -> 201
-            # GET /users/{user_id} -> 200
-            # PATCH /users/{user_id} -> 200
-            # GET /users/{user_id} -> 200
-            # PATCH /users/{user_id} -> 500
-        """
-
-    def call(self, case: Case, **kwargs: Any) -> GenericResponse:
-        """Make a request to the API.
-
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-        :param kwargs: Keyword arguments that will be passed to the appropriate ``case.call_*`` method.
-        :return: Response from the application under test.
-
-        Note that WSGI/ASGI applications are detected automatically in this method. Depending on the result of this
-        detection the state machine will call the ``call`` method.
-
-        Usually, you don't need to override this method unless you are building a different state machine on top of this
-        one and want to customize the transport layer itself.
-        """
-        return case.call(**kwargs)
-
-    def get_call_kwargs(self, case: Case) -> dict[str, Any]:
-        """Create custom keyword arguments that will be passed to the :meth:`Case.call` method.
-
-        Mostly they are proxied to the :func:`requests.request` call.
-
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-
-        .. code-block:: python
-
-            class APIWorkflow(schema.as_state_machine()):
-                def get_call_kwargs(self, case):
-                    return {"verify": False}
-
-        The above example disables the server's TLS certificate verification.
-        """
-        return {}
-
-    def validate_response(
-        self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
-    ) -> None:
-        """Validate an API response.
-
-        :param response: Response from the application under test.
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
-        :param additional_checks: A list of checks that will be run together with the default ones.
-        :raises CheckFailed: If any of the supplied checks failed.
-
-        If you need to change the default checks or provide custom validation rules, you can do it here.
-
-        .. code-block:: python
-
-            def my_check(response, case):
-                ...  # some assertions
-
-
-            class APIWorkflow(schema.as_state_machine()):
-                def validate_response(self, response, case):
-                    case.validate_response(response, checks=(my_check,))
-
-        The state machine from the example above will execute only the ``my_check`` check instead of all
-        available checks.
-
-        Each check function should accept ``response`` as the first argument and ``case`` as the second one and raise
-        ``AssertionError`` if the check fails.
-
-        **Note** that it is preferred to pass check functions as an argument to ``case.validate_response``.
-        In this case, all checks will be executed, and you'll receive a grouped exception that contains results from
-        all provided checks rather than only the first encountered exception.
-        """
-        __tracebackhide__ = True
-        case.validate_response(response, additional_checks=additional_checks, transport_kwargs=self._transport_kwargs)
-
-    def store_result(self, response: GenericResponse, case: Case, elapsed: float) -> StepResult:
-        return StepResult(response, case, elapsed)
-
-
-def _print_case(case: Case, kwargs: dict[str, Any]) -> str:
-    from requests.structures import CaseInsensitiveDict
-
-    operation = f"state.schema['{case.operation.path}']['{case.operation.method.upper()}']"
-    headers = case.headers or CaseInsensitiveDict()
-    headers.update(kwargs.get("headers", {}))
-    case.headers = headers
-    data = [
-        f"{name}={getattr(case, name)!r}"
-        for name in ("path_parameters", "headers", "cookies", "query", "body", "media_type")
-        if getattr(case, name) not in (None, NOT_SET)
-    ]
-    return f"{operation}.make_case({', '.join(data)})"
-
-
-class Direction:
-    name: str
-    status_code: str
-    operation: APIOperation
-
-    def set_data(self, case: Case, elapsed: float, **kwargs: Any) -> None:
-        raise NotImplementedError

schemathesis/stateful/statistic.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from . import events
-
-
-@dataclass
-class TransitionStats:
-    """Statistic for transitions in a state machine."""
-
-    def consume(self, event: events.StatefulEvent) -> None:
-        raise NotImplementedError
-
-    def copy(self) -> TransitionStats:
-        """Create a copy of the statistic."""
-        raise NotImplementedError
-
-    def to_formatted_table(self, width: int) -> str:
-        raise NotImplementedError

schemathesis/stateful/validation.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from ..exceptions import CheckFailed, get_grouped_exception
-from ..internal.checks import CheckContext
-
-if TYPE_CHECKING:
-    from ..failures import FailureContext
-    from ..internal.checks import CheckFunction
-    from ..models import Case
-    from ..transports.responses import GenericResponse
-    from .context import RunnerContext
-
-
-def validate_response(
-    *,
-    response: GenericResponse,
-    case: Case,
-    runner_ctx: RunnerContext,
-    check_ctx: CheckContext,
-    checks: tuple[CheckFunction, ...],
-    additional_checks: tuple[CheckFunction, ...] = (),
-    max_response_time: int | None = None,
-) -> None:
-    """Validate the response against the provided checks."""
-    from .._compat import MultipleFailures
-    from ..checks import _make_max_response_time_failure_message
-    from ..failures import ResponseTimeExceeded
-    from ..models import Check, Status
-
-    exceptions: list[CheckFailed | AssertionError] = []
-    check_results = runner_ctx.checks_for_step
-
-    def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
-        exceptions.append(exc)
-        if runner_ctx.is_seen_in_suite(exc):
-            return
-        failed_check = Check(
-            name=name,
-            value=Status.failure,
-            response=response,
-            elapsed=response.elapsed.total_seconds(),
-            example=copied_case,
-            message=message,
-            context=context,
-            request=None,
-        )
-        runner_ctx.add_failed_check(failed_check)
-        check_results.append(failed_check)
-        runner_ctx.mark_as_seen_in_suite(exc)
-
-    def _on_passed(_name: str, _case: Case) -> None:
-        passed_check = Check(
-            name=_name,
-            value=Status.success,
-            response=response,
-            elapsed=response.elapsed.total_seconds(),
-            example=_case,
-            request=None,
-        )
-        check_results.append(passed_check)
-
-    for check in tuple(checks) + tuple(additional_checks):
-        name = check.__name__
-        copied_case = case.partial_deepcopy()
-        try:
-            skip_check = check(check_ctx, response, copied_case)
-            if not skip_check:
-                _on_passed(name, copied_case)
-        except CheckFailed as exc:
-            if runner_ctx.is_seen_in_run(exc):
-                continue
-            _on_failure(exc, str(exc), exc.context)
-        except AssertionError as exc:
-            if runner_ctx.is_seen_in_run(exc):
-                continue
-            _on_failure(exc, str(exc) or f"Custom check failed: `{name}`", None)
-        except MultipleFailures as exc:
-            for subexc in exc.exceptions:
-                if runner_ctx.is_seen_in_run(subexc):
-                    continue
-                _on_failure(subexc, str(subexc), subexc.context)
-
-    if max_response_time:
-        elapsed_time = response.elapsed.total_seconds() * 1000
-        if elapsed_time > max_response_time:
-            message = _make_max_response_time_failure_message(elapsed_time, max_response_time)
-            context = ResponseTimeExceeded(message=message, elapsed=elapsed_time, deadline=max_response_time)
-            try:
-                raise AssertionError(message)
-            except AssertionError as _exc:
-                if not runner_ctx.is_seen_in_run(_exc):
-                    _on_failure(_exc, message, context)
-        else:
-            _on_passed("max_response_time", case)
-
-    # Raise a grouped exception so Hypothesis can properly deduplicate it against the other failures
-    if exceptions:
-        raise get_grouped_exception(case.operation.verbose_name, *exceptions)(causes=tuple(exceptions))

schemathesis/targets.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable
-
-if TYPE_CHECKING:
-    from .models import Case
-    from .transports.responses import GenericResponse
-
-
-@dataclass
-class TargetContext:
-    """Context for targeted testing.
-
-    :ivar Case case: Generated example that is being processed.
-    :ivar GenericResponse response: API response.
-    :ivar float response_time: API response time.
-    """
-
-    case: Case
-    response: GenericResponse
-    response_time: float
-
-
-def response_time(context: TargetContext) -> float:
-    return context.response_time
-
-
-Target = Callable[[TargetContext], float]
-DEFAULT_TARGETS = ()
-OPTIONAL_TARGETS = (response_time,)
-ALL_TARGETS: tuple[Target, ...] = DEFAULT_TARGETS + OPTIONAL_TARGETS
-
-
-@dataclass
-class TargetMetricCollector:
-    """Collect multiple observations for target metrics."""
-
-    targets: list[Target]
-    observations: dict[str, list[int | float]] = field(init=False)
-
-    def __post_init__(self) -> None:
-        self.observations = {target.__name__: [] for target in self.targets}
-
-    def reset(self) -> None:
-        """Reset all collected observations."""
-        for target in self.targets:
-            self.observations[target.__name__].clear()
-
-    def store(self, case: Case, response: GenericResponse) -> None:
-        """Calculate target metrics & store them."""
-        context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
-        for target in self.targets:
-            self.observations[target.__name__].append(target(context))
-
-    def maximize(self) -> None:
-        """Give feedback to the Hypothesis engine, so it maximizes the aggregated metrics."""
-        import hypothesis
-
-        for target in self.targets:
-            # Currently aggregation is just a sum
-            metric = sum(self.observations[target.__name__])
-            hypothesis.target(metric, label=target.__name__)
-
-
-def register(target: Target) -> Target:
-    """Register a new testing target for schemathesis CLI.
-
-    :param target: A function that will be called to calculate a metric passed to ``hypothesis.target``.
-    """
-    from . import cli
-
-    global ALL_TARGETS
-
-    ALL_TARGETS += (target,)
-    cli.TARGETS_TYPE.choices += (target.__name__,)  # type: ignore
-    return target