schemathesis 4.0.0a12__py3-none-any.whl → 4.0.1__py3-none-any.whl

schemathesis/generation/case.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Mapping
 
+from schemathesis import transport
 from schemathesis.checks import CHECKS, CheckContext, CheckFunction, run_checks
 from schemathesis.core import NOT_SET, SCHEMATHESIS_TEST_CASE_HEADER, NotSet, curl
 from schemathesis.core.failures import FailureGroup, failure_report_title, format_failures
@@ -11,42 +12,121 @@ from schemathesis.generation import generate_random_case_id
 from schemathesis.generation.meta import CaseMetadata
 from schemathesis.generation.overrides import Override, store_components
 from schemathesis.hooks import HookContext, dispatch
-from schemathesis.transport.prepare import prepare_request
+from schemathesis.transport.prepare import prepare_path, prepare_request
 
 if TYPE_CHECKING:
+    import httpx
+    import requests
     import requests.auth
     from requests.structures import CaseInsensitiveDict
+    from werkzeug.test import TestResponse
 
     from schemathesis.schemas import APIOperation
 
 
+def _default_headers() -> CaseInsensitiveDict:
+    from requests.structures import CaseInsensitiveDict
+
+    return CaseInsensitiveDict()
+
+
 @dataclass
 class Case:
-    """A single test case parameters."""
+    """Generated test case data for a single API operation."""
 
     operation: APIOperation
     method: str
+    """HTTP verb (`GET`, `POST`, etc.)"""
     path: str
-    # Unique test case identifier
-    id: str = field(default_factory=generate_random_case_id, compare=False)
-    path_parameters: dict[str, Any] | None = None
-    headers: CaseInsensitiveDict | None = None
-    cookies: dict[str, Any] | None = None
-    query: dict[str, Any] | None = None
+    """Path template from schema (e.g., `/users/{user_id}`)"""
+    id: str
+    """Random ID sent in headers for log correlation"""
+    path_parameters: dict[str, Any]
+    """Generated path variables (e.g., `{"user_id": "123"}`)"""
+    headers: CaseInsensitiveDict
+    """Generated HTTP headers"""
+    cookies: dict[str, Any]
+    """Generated cookies"""
+    query: dict[str, Any]
+    """Generated query parameters"""
     # By default, there is no body, but we can't use `None` as the default value because it clashes with `null`
     # which is a valid payload.
-    body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET
-    # The media type for cases with a payload. For example, "application/json"
-    media_type: str | None = None
+    body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet
+    """Generated request body"""
+    media_type: str | None
+    """Media type from OpenAPI schema (e.g., "multipart/form-data")"""
 
-    meta: CaseMetadata | None = field(compare=False, default=None)
+    meta: CaseMetadata | None
 
-    _auth: requests.auth.AuthBase | None = None
-    _has_explicit_auth: bool = False
+    _auth: requests.auth.AuthBase | None
+    _has_explicit_auth: bool
 
-    def __post_init__(self) -> None:
+    __slots__ = (
+        "operation",
+        "method",
+        "path",
+        "id",
+        "path_parameters",
+        "headers",
+        "cookies",
+        "query",
+        "body",
+        "media_type",
+        "meta",
+        "_auth",
+        "_has_explicit_auth",
+        "_components",
+    )
+
+    def __init__(
+        self,
+        operation: APIOperation,
+        method: str,
+        path: str,
+        *,
+        id: str | None = None,
+        path_parameters: dict[str, Any] | None = None,
+        headers: CaseInsensitiveDict | None = None,
+        cookies: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        body: list | dict[str, Any] | str | int | float | bool | bytes | "NotSet" = NOT_SET,
+        media_type: str | None = None,
+        meta: CaseMetadata | None = None,
+        _auth: requests.auth.AuthBase | None = None,
+        _has_explicit_auth: bool = False,
+    ) -> None:
+        self.operation = operation
+        self.method = method
+        self.path = path
+
+        self.id = id if id is not None else generate_random_case_id()
+        self.path_parameters = path_parameters if path_parameters is not None else {}
+        self.headers = headers if headers is not None else _default_headers()
+        self.cookies = cookies if cookies is not None else {}
+        self.query = query if query is not None else {}
+        self.body = body
+        self.media_type = media_type
+        self.meta = meta
+        self._auth = _auth
+        self._has_explicit_auth = _has_explicit_auth
         self._components = store_components(self)
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Case):
+            return NotImplemented
+
+        return (
+            self.operation == other.operation
+            and self.method == other.method
+            and self.path == other.path
+            and self.path_parameters == other.path_parameters
+            and self.headers == other.headers
+            and self.cookies == other.cookies
+            and self.query == other.query
+            and self.body == other.body
+            and self.media_type == other.media_type
+        )
+
     @property
     def _override(self) -> Override:
         return Override.from_components(self._components, self)
@@ -56,6 +136,8 @@ class Case:
         first = True
         for name in ("path_parameters", "headers", "cookies", "query", "body"):
             value = getattr(self, name)
+            if name != "body" and not value:
+                continue
             if value is not None and not isinstance(value, NotSet):
                 if first:
                     first = False
@@ -69,8 +151,19 @@ class Case:
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
+    @property
+    def formatted_path(self) -> str:
+        """Path template with variables substituted (e.g., /users/{user_id} → /users/123)."""
+        return prepare_path(self.path, self.path_parameters)
+
     def as_curl_command(self, headers: Mapping[str, Any] | None = None, verify: bool = True) -> str:
-        """Construct a curl command for a given case."""
+        """Generate a curl command that reproduces this test case.
+
+        Args:
+            headers: Additional headers to include in the command.
+            verify: When False, adds `--insecure` flag to curl command.
+
+        """
         request_data = prepare_request(self, headers, config=self.operation.schema.config.output.sanitization)
         return curl.generate(
             method=str(request_data.method),
@@ -82,7 +175,6 @@ class Case:
         )
 
     def as_transport_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
-        """Convert the test case into a dictionary acceptable by the underlying transport call."""
         return self.operation.schema.transport.serialize_case(self, base_url=base_url, headers=headers)
 
     def call(
@@ -94,11 +186,28 @@ class Case:
         cookies: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Response:
+        """Make an HTTP request using this test case's data without validation.
+
+        Use when you need to validate response separately
+
+        Args:
+            base_url: Override the schema's base URL.
+            session: Reuse an existing requests session.
+            headers: Additional headers.
+            params: Additional query parameters.
+            cookies: Additional cookies.
+            **kwargs: Additional transport-level arguments.
+
+        """
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self, **kwargs)
         if self.operation.app is not None:
-            kwargs["app"] = self.operation.app
-        response = self.operation.schema.transport.send(
+            kwargs.setdefault("app", self.operation.app)
+        if "app" in kwargs:
+            transport_ = transport.get(kwargs["app"])
+        else:
+            transport_ = self.operation.schema.transport
+        response = transport_.send(
             self,
             session=session,
             base_url=base_url,
@@ -112,26 +221,29 @@ class Case:
 
     def validate_response(
         self,
-        response: Response,
+        response: Response | httpx.Response | requests.Response | TestResponse,
         checks: list[CheckFunction] | None = None,
         additional_checks: list[CheckFunction] | None = None,
         excluded_checks: list[CheckFunction] | None = None,
         headers: dict[str, Any] | None = None,
         transport_kwargs: dict[str, Any] | None = None,
     ) -> None:
-        """Validate application response.
+        """Validate a response against the API schema and built-in checks.
 
-        By default, all available checks will be applied.
+        Args:
+            response: Response to validate.
+            checks: Explicit set of checks to run.
+            additional_checks: Additional custom checks to run.
+            excluded_checks: Built-in checks to skip.
+            headers: Headers used in the original request.
+            transport_kwargs: Transport arguments used in the original request.
 
-        :param response: Application response.
-        :param checks: A tuple of check functions that accept ``response`` and ``case``.
-        :param additional_checks: A tuple of additional checks that will be executed after ones from the ``checks``
-            argument.
-        :param excluded_checks: Checks excluded from the default ones.
         """
         __tracebackhide__ = True
         from requests.structures import CaseInsensitiveDict
 
+        response = Response.from_any(response)
+
         checks = [
             check
             for check in list(checks or CHECKS.get_all()) + list(additional_checks or [])
@@ -180,6 +292,18 @@ class Case:
         excluded_checks: list[CheckFunction] | None = None,
         **kwargs: Any,
     ) -> Response:
+        """Make an HTTP request and validates the response automatically.
+
+        Args:
+            base_url: Override the schema's base URL.
+            session: Reuse an existing requests session.
+            headers: Additional headers to send.
+            checks: Explicit set of checks to run.
+            additional_checks: Additional custom checks to run.
+            excluded_checks: Built-in checks to skip.
+            **kwargs: Additional transport-level arguments.
+
+        """
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
         self.validate_response(

schemathesis/generation/hypothesis/builder.py

@@ -103,11 +103,11 @@ def create_test(
     if config.settings is not None:
         # Merge the user-provided settings with the current ones
         settings = hypothesis.settings(
-            settings,
+            config.settings,
             **{
-                item: getattr(config.settings, item)
+                item: getattr(settings, item)
                 for item in all_settings
-                if getattr(config.settings, item) != getattr(default, item)
+                if getattr(settings, item) != getattr(default, item)
             },
         )
 
@@ -475,7 +475,7 @@ def _iter_coverage_cases(
             data = template.with_body(value=value, media_type=body.media_type)
             yield operation.Case(
                 **data.kwargs,
-                meta=CaseMetadata(
+                _meta=CaseMetadata(
                     generation=GenerationInfo(
                         time=elapsed,
                         mode=value.generation_mode,
@@ -497,7 +497,7 @@ def _iter_coverage_cases(
                     data = template.with_body(value=next_value, media_type=body.media_type)
                     yield operation.Case(
                         **data.kwargs,
-                        meta=CaseMetadata(
+                        _meta=CaseMetadata(
                             generation=GenerationInfo(
                                 time=instant.elapsed,
                                 mode=next_value.generation_mode,
@@ -518,7 +518,7 @@ def _iter_coverage_cases(
         seen_positive.insert(data.kwargs)
         yield operation.Case(
             **data.kwargs,
-            meta=CaseMetadata(
+            _meta=CaseMetadata(
                 generation=GenerationInfo(
                     time=template_time,
                     mode=GenerationMode.POSITIVE,
@@ -546,7 +546,7 @@ def _iter_coverage_cases(
 
             yield operation.Case(
                 **data.kwargs,
-                meta=CaseMetadata(
+                _meta=CaseMetadata(
                     generation=GenerationInfo(time=instant.elapsed, mode=value.generation_mode),
                     components=data.components,
                     phase=PhaseInfo.coverage(
@@ -566,7 +566,7 @@ def _iter_coverage_cases(
             yield operation.Case(
                 **data.kwargs,
                 method=method.upper(),
-                meta=CaseMetadata(
+                _meta=CaseMetadata(
                     generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                     components=data.components,
                     phase=PhaseInfo.coverage(description=f"Unspecified HTTP method: {method.upper()}"),
@@ -588,7 +588,7 @@ def _iter_coverage_cases(
                     )
                     yield operation.Case(
                         **data.kwargs,
-                        meta=CaseMetadata(
+                        _meta=CaseMetadata(
                             generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                             components=data.components,
                             phase=PhaseInfo.coverage(
@@ -613,7 +613,7 @@ def _iter_coverage_cases(
                 )
                 yield operation.Case(
                     **data.kwargs,
-                    meta=CaseMetadata(
+                    _meta=CaseMetadata(
                         generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                         components=data.components,
                         phase=PhaseInfo.coverage(
@@ -655,7 +655,7 @@ def _iter_coverage_cases(
             )
             return operation.Case(
                 **data.kwargs,
-                meta=CaseMetadata(
+                _meta=CaseMetadata(
                     generation=GenerationInfo(
                         time=_instant.elapsed,
                         mode=_generation_mode,
@@ -781,7 +781,7 @@ def _case_to_kwargs(case: Case) -> dict:
     kwargs = {}
     for container_name in LOCATION_TO_CONTAINER.values():
         value = getattr(case, container_name)
-        if isinstance(value, CaseInsensitiveDict):
+        if isinstance(value, CaseInsensitiveDict) and value:
             kwargs[container_name] = dict(value)
         elif value and value is not NOT_SET:
             kwargs[container_name] = value

schemathesis/generation/overrides.py

@@ -2,17 +2,15 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Iterator
 
 from schemathesis.config import ProjectConfig
-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, Parameter, ParameterSet
+    from schemathesis.schemas import APIOperation, Parameter
 
 
 @dataclass
@@ -24,13 +22,15 @@ class Override:
     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)),
-        }
+    def items(self) -> Iterator[tuple[str, dict[str, str]]]:
+        for key, value in (
+            ("query", self.query),
+            ("headers", self.headers),
+            ("cookies", self.cookies),
+            ("path_parameters", self.path_parameters),
+        ):
+            if value:
+                yield key, value
 
     @classmethod
     def from_components(cls, components: dict[ComponentKind, StoredValue], case: Case) -> Override:
@@ -77,14 +77,6 @@ def _get_override_value(param: Parameter, parameters: dict[str, Any]) -> Any:
     return None
 
 
-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
@@ -122,11 +114,3 @@ def store_components(case: Case) -> dict[ComponentKind, StoredValue]:
             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

@@ -7,6 +7,19 @@ if TYPE_CHECKING:
 
     from schemathesis.generation.stateful.state_machine import APIStateMachine
 
+__all__ = [
+    "APIStateMachine",
+]
+
+
+def __getattr__(name: str) -> type[APIStateMachine]:
+    if name == "APIStateMachine":
+        from schemathesis.generation.stateful.state_machine import APIStateMachine
+
+        return APIStateMachine
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 STATEFUL_TESTS_LABEL = "Stateful tests"
 
 

schemathesis/generation/stateful/state_machine.py

@@ -129,9 +129,10 @@ def _normalize_name(name: str) -> str:
 
 
 class APIStateMachine(RuleBasedStateMachine):
-    """The base class for state machines generated from API schemas.
+    """State machine for executing API operation sequences based on OpenAPI links.
 
-    Exposes additional extension points in the testing process.
+    Automatically generates test scenarios by chaining API operations according
+    to their defined relationships in the schema.
     """
 
     # This is a convenience attribute, which happened to clash with `RuleBasedStateMachine` instance level attribute
@@ -193,17 +194,22 @@ class APIStateMachine(RuleBasedStateMachine):
 
     @classmethod
     def run(cls, *, settings: hypothesis.settings | None = None) -> None:
-        """Run state machine as a test."""
+        """Execute the state machine test scenarios.
+
+        Args:
+            settings: Hypothesis settings for test execution.
+
+        """
         from . import run_state_machine_as_test
 
         __tracebackhide__ = True
         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."""
+        """Called once at the beginning of each test scenario."""
 
     def teardown(self) -> None:
-        pass
+        """Called once at the end of each test scenario."""
 
     # To provide the return type in the rendered documentation
     teardown.__doc__ = RuleBasedStateMachine.teardown.__doc__
@@ -213,14 +219,6 @@ class APIStateMachine(RuleBasedStateMachine):
         return self.step(input)
 
     def step(self, input: StepInput) -> StepOutput:
-        """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.
-        """
         __tracebackhide__ = True
         self.before_call(input.case)
         kwargs = self.get_call_kwargs(input.case)
@@ -230,126 +228,51 @@ class APIStateMachine(RuleBasedStateMachine):
         return StepOutput(response, input.case)
 
     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:
+        """Called before each API operation in the scenario.
 
-        .. code-block:: python
+        Args:
+            case: Test case data for the operation.
 
-            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: Response, 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
+        """Called after each API operation in the scenario.
 
-            logger = logging.getLogger(__file__)
-            logger.setLevel(logging.INFO)
+        Args:
+            response: HTTP response from the operation.
+            case: Test case data that was executed.
 
-
-            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) -> 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.
-        :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.
+        """Returns keyword arguments for the API call.
 
-        :param Case case: Generated test case data that should be sent in an API call to the tested API operation.
+        Args:
+            case: Test case being executed.
 
-        .. code-block:: python
+        Returns:
+            Dictionary passed to the `case.call()` method.
 
-            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: Response, case: Case, additional_checks: list[CheckFunction] | None = None, **kwargs: Any
     ) -> 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 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.
-
-        .. 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,))
+        """Validates the API response using configured checks.
 
-        The state machine from the example above will execute only the ``my_check`` check instead of all
-        available checks.
+        Args:
+            response: HTTP response to validate.
+            case: Test case that generated the response.
+            additional_checks: Extra validation functions to run.
+            kwargs: Transport-level keyword arguments.
 
-        Each check function should accept ``response`` as the first argument and ``case`` as the second one and raise
-        ``AssertionError`` if the check fails.
+        Raises:
+            FailureGroup: When validation checks fail.
 
-        **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=kwargs)