schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/generation/hypothesis/given.py

@@ -0,0 +1,66 @@
+"""Integrating `hypothesis.given` into Schemathesis."""
+
+from __future__ import annotations
+
+from inspect import getfullargspec
+from typing import TYPE_CHECKING, Any, Callable, NoReturn, Union
+
+from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.marks import Mark
+
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+
+__all__ = ["is_given_applied", "given_proxy", "merge_given_args", "GivenInput", "GivenArgsMark", "GivenKwargsMark"]
+
+EllipsisType = type(...)
+GivenInput = Union["SearchStrategy", EllipsisType]  # type: ignore[valid-type]
+
+GivenArgsMark = Mark[tuple](attr_name="given_args", default=())
+GivenKwargsMark = Mark[dict[str, Any]](attr_name="given_kwargs", default=dict)
+
+
+def is_given_applied(func: Callable) -> bool:
+    return GivenArgsMark.is_set(func) or GivenKwargsMark.is_set(func)
+
+
+def given_proxy(*args: GivenInput, **kwargs: GivenInput) -> Callable[[Callable], Callable]:
+    """Proxy Hypothesis strategies to ``hypothesis.given``."""
+
+    def wrapper(func: Callable) -> Callable:
+        if is_given_applied(func):
+
+            def wrapped_test(*_: Any, **__: Any) -> NoReturn:
+                raise IncorrectUsage(
+                    f"You have applied `given` to the `{func.__name__}` test more than once, which "
+                    "overrides the previous decorator. You need to pass all arguments to the same `given` call."
+                )
+
+            return wrapped_test
+
+        GivenArgsMark.set(func, args)
+        GivenKwargsMark.set(func, kwargs)
+        return func
+
+    return wrapper
+
+
+def merge_given_args(func: Callable, args: tuple, kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Merge positional arguments to ``@schema.given`` into a dictionary with keyword arguments.
+
+    Kwargs are modified inplace.
+    """
+    if args:
+        argspec = getfullargspec(func)
+        for name, strategy in zip(reversed([arg for arg in argspec.args if arg != "case"]), reversed(args)):
+            kwargs[name] = strategy
+    return kwargs
+
+
+def validate_given_args(func: Callable, args: tuple, kwargs: dict[str, Any]) -> Callable | None:
+    from hypothesis.core import is_invalid_test
+    from hypothesis.internal.reflection import get_signature
+
+    signature = get_signature(func)
+    return is_invalid_test(func, signature, args, kwargs)  # type: ignore

schemathesis/generation/hypothesis/reporting.py

@@ -0,0 +1,14 @@
+from contextlib import contextmanager
+from typing import Generator
+
+from hypothesis.reporting import with_reporter
+
+
+def ignore(_: str) -> None:
+    pass
+
+
+@contextmanager
+def ignore_hypothesis_output() -> Generator:
+    with with_reporter(ignore):  # type: ignore
+        yield

schemathesis/generation/hypothesis/strategies.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from functools import reduce
+from operator import or_
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from hypothesis import strategies as st
+
+
+def combine(strategies: list[st.SearchStrategy] | tuple[st.SearchStrategy]) -> st.SearchStrategy:
+    """Combine a list of strategies into a single one.
+
+    If the input is `[a, b, c]`, then the result is equivalent to `a | b | c`.
+    """
+    return reduce(or_, strategies[1:], strategies[0])

schemathesis/generation/meta.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from schemathesis.generation import GenerationMode
+
+
+class TestPhase(str, Enum):
+    __test__ = False
+
+    EXPLICIT = "explicit"
+    COVERAGE = "coverage"
+    GENERATE = "generate"
+
+
+class ComponentKind(str, Enum):
+    """Components that can be generated."""
+
+    QUERY = "query"
+    PATH_PARAMETERS = "path_parameters"
+    HEADERS = "headers"
+    COOKIES = "cookies"
+    BODY = "body"
+
+
+@dataclass
+class ComponentInfo:
+    """Information about how a specific component was generated."""
+
+    mode: GenerationMode
+
+    __slots__ = ("mode",)
+
+
+@dataclass
+class GeneratePhaseData:
+    """Metadata specific to generate phase."""
+
+
+@dataclass
+class ExplicitPhaseData:
+    """Metadata specific to explicit phase."""
+
+
+@dataclass
+class CoveragePhaseData:
+    """Metadata specific to coverage phase."""
+
+    description: str
+    location: str | None
+    parameter: str | None
+    parameter_location: str | None
+
+    __slots__ = ("description", "location", "parameter", "parameter_location")
+
+
+@dataclass
+class PhaseInfo:
+    """Phase-specific information."""
+
+    name: TestPhase
+    data: CoveragePhaseData | ExplicitPhaseData | GeneratePhaseData
+
+    __slots__ = ("name", "data")
+
+    @classmethod
+    def coverage(
+        cls,
+        description: str,
+        location: str | None = None,
+        parameter: str | None = None,
+        parameter_location: str | None = None,
+    ) -> PhaseInfo:
+        return cls(
+            name=TestPhase.COVERAGE,
+            data=CoveragePhaseData(
+                description=description, location=location, parameter=parameter, parameter_location=parameter_location
+            ),
+        )
+
+    @classmethod
+    def generate(cls) -> PhaseInfo:
+        return cls(name=TestPhase.GENERATE, data=GeneratePhaseData())
+
+
+@dataclass
+class GenerationInfo:
+    """Information about test case generation."""
+
+    time: float
+    mode: GenerationMode
+
+    __slots__ = ("time", "mode")
+
+
+@dataclass
+class CaseMetadata:
+    """Complete metadata for generated cases."""
+
+    generation: GenerationInfo
+    components: dict[ComponentKind, ComponentInfo]
+    phase: PhaseInfo
+
+    __slots__ = ("generation", "components", "phase")
+
+    def __init__(
+        self,
+        generation: GenerationInfo,
+        components: dict[ComponentKind, ComponentInfo],
+        phase: PhaseInfo,
+    ) -> None:
+        self.generation = generation
+        self.components = components
+        self.phase = phase

schemathesis/generation/modes.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GenerationMode(str, Enum):
+    """Defines what data Schemathesis generates for tests."""
+
+    # Generate data, that fits the API schema
+    POSITIVE = "positive"
+    # Doesn't fit the API schema
+    NEGATIVE = "negative"
+
+    @classmethod
+    def default(cls) -> GenerationMode:
+        return cls.POSITIVE
+
+    @classmethod
+    def all(cls) -> list[GenerationMode]:
+        return list(GenerationMode)
+
+    @property
+    def is_positive(self) -> bool:
+        return self == GenerationMode.POSITIVE
+
+    @property
+    def is_negative(self) -> bool:
+        return self == GenerationMode.NEGATIVE

schemathesis/generation/overrides.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable
+
+from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.marks import Mark
+from schemathesis.core.transforms import diff
+from schemathesis.generation.meta import ComponentKind
+
+if TYPE_CHECKING:
+    from schemathesis.generation.case import Case
+    from schemathesis.schemas import APIOperation, ParameterSet
+
+
+@dataclass
+class Override:
+    """Overrides for various parts of a test case."""
+
+    query: dict[str, str]
+    headers: dict[str, str]
+    cookies: dict[str, str]
+    path_parameters: dict[str, str]
+
+    def for_operation(self, operation: APIOperation) -> dict[str, dict[str, str]]:
+        return {
+            "query": (_for_parameters(self.query, operation.query)),
+            "headers": (_for_parameters(self.headers, operation.headers)),
+            "cookies": (_for_parameters(self.cookies, operation.cookies)),
+            "path_parameters": (_for_parameters(self.path_parameters, operation.path_parameters)),
+        }
+
+    @classmethod
+    def from_components(cls, components: dict[ComponentKind, StoredValue], case: Case) -> Override:
+        return Override(
+            **{
+                kind.value: get_component_diff(stored=stored, current=getattr(case, kind.value))
+                for kind, stored in components.items()
+            }
+        )
+
+
+def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[str, str]:
+    output = {}
+    for param in defined:
+        if param.name in overridden:
+            output[param.name] = overridden[param.name]
+    return output
+
+
+@dataclass
+class StoredValue:
+    value: dict[str, Any] | None
+    is_generated: bool
+
+    __slots__ = ("value", "is_generated")
+
+
+def store_original_state(value: dict[str, Any] | None) -> dict[str, Any] | None:
+    if isinstance(value, Mapping):
+        return value.copy()
+    return value
+
+
+def get_component_diff(stored: StoredValue, current: dict[str, Any] | None) -> dict[str, Any]:
+    """Calculate difference between stored and current components."""
+    if not (current and stored.value):
+        return {}
+    if stored.is_generated:
+        return diff(stored.value, current)
+    return current
+
+
+def store_components(case: Case) -> dict[ComponentKind, StoredValue]:
+    """Store original component states for a test case."""
+    return {
+        kind: StoredValue(
+            value=store_original_state(getattr(case, kind.value)),
+            is_generated=bool(case.meta and kind in case.meta.components),
+        )
+        for kind in [
+            ComponentKind.QUERY,
+            ComponentKind.HEADERS,
+            ComponentKind.COOKIES,
+            ComponentKind.PATH_PARAMETERS,
+        ]
+    }
+
+
+OverrideMark = Mark[Override](attr_name="override")
+
+
+def check_no_override_mark(test: Callable) -> None:
+    if OverrideMark.is_set(test):
+        raise IncorrectUsage(f"`{test.__name__}` has already been decorated with `override`.")

schemathesis/generation/stateful/__init__.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import hypothesis
+
+    from schemathesis.generation.stateful.state_machine import APIStateMachine
+
+
+def run_state_machine_as_test(
+    state_machine_factory: type[APIStateMachine], *, settings: hypothesis.settings | None = None
+) -> None:
+    """Run a state machine as a test.
+
+    It automatically adds the `_min_steps` argument if ``Hypothesis`` is recent enough.
+    """
+    from hypothesis.stateful import run_state_machine_as_test as _run_state_machine_as_test
+
+    return _run_state_machine_as_test(state_machine_factory, settings=settings, _min_steps=2)

schemathesis/{stateful → generation/stateful}/state_machine.py

@@ -1,36 +1,49 @@
 from __future__ import annotations
 
-import time
 import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, ClassVar
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, ClassVar
 
+import hypothesis
 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 ..models import APIOperation, Case, CheckFunction
+from schemathesis.checks import CheckFunction
+from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.transport import Response
+from schemathesis.generation.case import Case
 
 if TYPE_CHECKING:
     import hypothesis
     from requests.structures import CaseInsensitiveDict
 
-    from ..schemas import BaseSchema
-    from ..transports.responses import GenericResponse
+    from schemathesis.schemas import APIOperation, BaseSchema
+
+
+NO_LINKS_ERROR_MESSAGE = (
+    "Stateful testing requires at least one OpenAPI link in the schema, but no links detected. "
+    "Please add OpenAPI links to enable stateful testing or use stateless tests instead. \n"
+    "See https://schemathesis.readthedocs.io/en/stable/stateful.html#how-to-specify-connections for more information."
+)
+
+DEFAULT_STATE_MACHINE_SETTINGS = hypothesis.settings(
+    phases=[hypothesis.Phase.generate],
+    deadline=None,
+    stateful_step_count=6,
+    suppress_health_check=list(hypothesis.HealthCheck),
+)
 
 
 @dataclass
 class StepResult:
     """Output from a single transition of a state machine."""
 
-    response: GenericResponse
+    response: Response
     case: Case
-    elapsed: float
 
 
-def _operation_name_to_identifier(name: str) -> str:
+def _normalize_name(name: str) -> str:
     return re.sub(r"\W|^(?=\d)", "_", name).replace("__", "_")
 
 
@@ -51,26 +64,40 @@ class APIStateMachine(RuleBasedStateMachine):
             super().__init__()  # type: ignore
         except InvalidDefinition as exc:
             if "defines no rules" in str(exc):
-                raise UsageError(NO_LINKS_ERROR_MESSAGE) from None
+                raise IncorrectUsage(NO_LINKS_ERROR_MESSAGE) from None
             raise
         self.setup()
 
-    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)
-        if isinstance(value, tuple) and len(value) == 2:
-            result, direction = value
-            wrapper = _DirectionWrapper(direction)
-            return super()._pretty_print((result, wrapper))  # type: ignore
-        return super()._pretty_print(value)  # type: ignore
+    @classmethod
+    @lru_cache
+    def _to_test_case(cls) -> type:
+        from schemathesis.generation.stateful import run_state_machine_as_test
+
+        class StateMachineTestCase(RuleBasedStateMachine.TestCase):
+            settings = DEFAULT_STATE_MACHINE_SETTINGS
+
+            def runTest(self) -> None:
+                run_state_machine_as_test(cls, settings=self.settings)
 
-    if HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS:
+            runTest.is_hypothesis_test = True  # type: ignore[attr-defined]
 
-        def _new_name(self, target: str) -> str:
-            target = _operation_name_to_identifier(target)
-            return super()._new_name(target)  # type: ignore
+        StateMachineTestCase.__name__ = cls.__name__ + ".TestCase"
+        StateMachineTestCase.__qualname__ = cls.__qualname__ + ".TestCase"
+        return StateMachineTestCase
+
+    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 run(cls, *, settings: hypothesis.settings | None = None) -> None:
@@ -80,10 +107,7 @@ class APIStateMachine(RuleBasedStateMachine):
         return run_state_machine_as_test(cls, settings=settings)
 
     def setup(self) -> None:
-        """Hook method that runs unconditionally in the beginning of each test scenario.
-
-        Does nothing by default.
-        """
+        """Hook method that runs unconditionally in the beginning of each test scenario."""
 
     def teardown(self) -> None:
         pass
@@ -94,12 +118,14 @@ class APIStateMachine(RuleBasedStateMachine):
     def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
         raise NotImplementedError
 
-    def _step(self, case: Case, previous: tuple[StepResult, Direction] | None = None) -> StepResult:
+    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
-        return self.step(case, previous)
+        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:
         """A single state machine step.
@@ -116,12 +142,10 @@ class APIStateMachine(RuleBasedStateMachine):
             case = self.transform(result, direction, case)
         self.before_call(case)
         kwargs = self.get_call_kwargs(case)
-        start = time.monotonic()
         response = self.call(case, **kwargs)
-        elapsed = time.monotonic() - start
         self.after_call(response, case)
         self.validate_response(response, case)
-        return self.store_result(response, case, elapsed)
+        return self.store_result(response, case)
 
     def before_call(self, case: Case) -> None:
         """Hook method for modifying the case data before making a request.
@@ -148,7 +172,7 @@ class APIStateMachine(RuleBasedStateMachine):
                         case.body["is_fake"] = True
         """
 
-    def after_call(self, response: GenericResponse, case: Case) -> None:
+    def after_call(self, response: Response, case: Case) -> None:
         """Hook method for additional actions with case or response instances.
 
         :param response: Response from the application under test.
@@ -181,7 +205,7 @@ class APIStateMachine(RuleBasedStateMachine):
             # PATCH /users/{user_id} -> 500
         """
 
-    def call(self, case: Case, **kwargs: Any) -> GenericResponse:
+    def call(self, case: Case, **kwargs: Any) -> Response:
         """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.
@@ -189,13 +213,12 @@ class APIStateMachine(RuleBasedStateMachine):
         :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 ``call``, ``call_wsgi`` or ``call_asgi`` methods.
+        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.
         """
-        method = self._get_call_method(case)
-        return method(**kwargs)
+        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.
@@ -214,24 +237,15 @@ class APIStateMachine(RuleBasedStateMachine):
         """
         return {}
 
-    def _get_call_method(self, case: Case) -> Callable:
-        if case.app is not None:
-            from starlette.applications import Starlette
-
-            if isinstance(case.app, Starlette):
-                return case.call_asgi
-            return case.call_wsgi
-        return case.call
-
     def validate_response(
-        self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
+        self, response: Response, case: Case, additional_checks: list[CheckFunction] | None = None
     ) -> 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.
+        :raises FailureGroup: 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.
 
@@ -258,23 +272,8 @@ class APIStateMachine(RuleBasedStateMachine):
         __tracebackhide__ = True
         case.validate_response(response, additional_checks=additional_checks)
 
-    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}={repr(getattr(case, name))}"
-        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)})"
+    def store_result(self, response: Response, case: Case) -> StepResult:
+        return StepResult(response, case)
 
 
 class Direction:
@@ -282,17 +281,5 @@ class Direction:
     status_code: str
     operation: APIOperation
 
-    def set_data(self, case: Case, elapsed: float, **kwargs: Any) -> None:
+    def set_data(self, case: Case, **kwargs: Any) -> None:
         raise NotImplementedError
-
-
-@dataclass(repr=False)
-class _DirectionWrapper:
-    """Purely to avoid modification of `Direction.__repr__`."""
-
-    direction: Direction
-
-    def __repr__(self) -> str:
-        path = self.direction.operation.path
-        method = self.direction.operation.method.upper()
-        return f"state.schema['{path}']['{method}'].links['{self.direction.status_code}']['{self.direction.name}']"