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

schemathesis/__init__.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 from schemathesis import errors, graphql, openapi, pytest
-from schemathesis.auths import AuthContext, auth
+from schemathesis.auths import AuthContext, AuthProvider, auth
 from schemathesis.checks import CheckContext, CheckFunction, check
+from schemathesis.config import SchemathesisConfig as Config
 from schemathesis.core.transport import Response
 from schemathesis.core.version import SCHEMATHESIS_VERSION
-from schemathesis.generation import GenerationMode
+from schemathesis.generation import GenerationMode, stateful
 from schemathesis.generation.case import Case
 from schemathesis.generation.metrics import MetricContext, MetricFunction, metric
 from schemathesis.hooks import HookContext, hook
-from schemathesis.schemas import BaseSchema
+from schemathesis.schemas import APIOperation, BaseSchema
 from schemathesis.transport import SerializationContext, serializer
 
 __version__ = SCHEMATHESIS_VERSION
@@ -19,8 +20,11 @@ __all__ = [
     # Core data structures
     "Case",
     "Response",
-    "GenerationMode",
+    "APIOperation",
     "BaseSchema",
+    "Config",
+    "GenerationMode",
+    "stateful",
     # Public errors
     "errors",
     # Spec or usage specific namespaces
@@ -37,6 +41,7 @@ __all__ = [
     # Auth
     "auth",
     "AuthContext",
+    "AuthProvider",
     # Targeted Property-based Testing
     "metric",
     "MetricContext",

schemathesis/auths.py

@@ -69,22 +69,28 @@ CacheKeyFunction = Callable[["Case", "AuthContext"], Union[str, int]]
 
 @runtime_checkable
 class AuthProvider(Generic[Auth], Protocol):
-    """Get authentication data for an API and set it on the generated test cases."""
+    """Protocol for implementing custom authentication in API tests."""
 
-    def get(self, case: Case, context: AuthContext) -> Auth | None:
-        """Get the authentication data.
+    def get(self, case: Case, ctx: AuthContext) -> Auth | None:
+        """Obtain authentication data for the test case.
+
+        Args:
+            case: Generated test case requiring authentication.
+            ctx: Authentication state and configuration.
+
+        Returns:
+            Authentication data (e.g., token, credentials) or `None`.
 
-        :param Case case: Generated test case.
-        :param AuthContext context: Holds state relevant for the authentication process.
-        :return: Any authentication data you find useful for your use case. For example, it could be an access token.
         """
 
-    def set(self, case: Case, data: Auth, context: AuthContext) -> None:
-        """Set authentication data on a generated test case.
+    def set(self, case: Case, data: Auth, ctx: AuthContext) -> None:
+        """Apply authentication data to the test case.
+
+        Args:
+            case: Test case to modify.
+            data: Authentication data from the `get` method.
+            ctx: Authentication state and configuration.
 
-        :param Optional[Auth] data: Authentication data you got from the ``get`` method.
-        :param Case case: Generated test case.
-        :param AuthContext context: Holds state relevant for the authentication process.
         """
 
 
@@ -333,8 +339,9 @@ class AuthStorage(Generic[Auth]):
     ) -> None:
         if not issubclass(provider_class, AuthProvider):
             raise TypeError(
-                f"`{provider_class.__name__}` is not a valid auth provider. "
-                f"Check `schemathesis.auths.AuthProvider` documentation for examples."
+                f"`{provider_class.__name__}` does not implement the `AuthProvider` protocol. "
+                f"Auth providers must have `get` and `set` methods. "
+                f"See `schemathesis.AuthProvider` documentation for examples."
             )
         provider: AuthProvider
         # Apply caching if desired
@@ -389,23 +396,6 @@ class AuthStorage(Generic[Auth]):
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
         cache_by_key: CacheKeyFunction | None = None,
     ) -> FilterableApplyAuth:
-        """Register auth provider only on one test function.
-
-        :param Type[AuthProvider] provider_class: Authentication provider class.
-        :param Optional[int] refresh_interval: Cache duration in seconds.
-
-        .. code-block:: python
-
-            class Auth:
-                ...
-
-
-            @schema.auth(Auth)
-            @schema.parametrize()
-            def test_api(case):
-                ...
-
-        """
         filter_set = FilterSet()
 
         def wrapper(test: Callable) -> Callable:

schemathesis/checks.py

@@ -91,6 +91,11 @@ class CheckContext:
 CHECKS = Registry[CheckFunction]()
 
 
+def load_all_checks() -> None:
+    # NOTE: Trigger registering all Open API checks
+    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401, F403
+
+
 def check(func: CheckFunction) -> CheckFunction:
     """Register a custom validation check to run against API responses.
 

schemathesis/cli/commands/run/__init__.py

@@ -6,7 +6,7 @@ from typing import Any, Callable
 import click
 from click.utils import LazyFile
 
-from schemathesis.checks import CHECKS
+from schemathesis.checks import CHECKS, load_all_checks
 from schemathesis.cli.commands.run import executor, validation
 from schemathesis.cli.commands.run.filters import with_filters
 from schemathesis.cli.constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS
@@ -30,8 +30,7 @@ from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.metrics import METRICS, MetricFunction
 
-# NOTE: Need to explicitly import all registered checks
-from schemathesis.specs.openapi.checks import *  # noqa: F401, F403
+load_all_checks()
 
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 
@@ -477,10 +476,14 @@ def run(
     no_color: bool = False,
     **__kwargs: Any,
 ) -> None:
-    """Run tests against an API using a specified SCHEMA.
+    """Generate and run property-based tests against your API.
 
-    [Required] SCHEMA: Path to an OpenAPI (`.json`, `.yml`) or GraphQL SDL file, or a URL pointing to such specifications
-    """
+    \b
+    LOCATION can be:
+        - Local file: ./openapi.json, ./schema.yaml, ./schema.graphql
+        - OpenAPI URL: https://api.example.com/openapi.json
+        - GraphQL URL: https://api.example.com/graphql/
+    """  # noqa: D301
     if no_color and force_color:
         raise click.UsageError(COLOR_OPTIONS_INVALID_USAGE_MESSAGE)
 

schemathesis/cli/commands/run/handlers/output.py

@@ -1039,6 +1039,7 @@ class OutputHandler(EventHandler):
             assert self.stateful_tests_manager is not None
             links_seen = {case.transition.id for case in event.recorder.cases.values() if case.transition is not None}
             self.stateful_tests_manager.update(links_seen, event.status)
+            self._check_stateful_warnings(ctx, event)
 
     def _check_warnings(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
         statistic = aggregate_status_codes(event.recorder.interactions.values())
@@ -1090,6 +1091,18 @@ class OutputHandler(EventHandler):
             ):
                 self.warnings.validation_mismatch.add(event.recorder.label)
 
+    def _check_stateful_warnings(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
+        # If stateful testing had successful responses for API operations that were marked with "missing_test_data"
+        # warnings, then remove them from warnings
+        for key, node in event.recorder.cases.items():
+            if not self.warnings.missing_test_data:
+                break
+            if node.value.operation.label in self.warnings.missing_test_data and key in event.recorder.interactions:
+                response = event.recorder.interactions[key].response
+                if response is not None and response.status_code < 300:
+                    self.warnings.missing_test_data.remove(node.value.operation.label)
+                    continue
+
     def _on_interrupted(self, event: events.Interrupted) -> None:
         from rich.padding import Padding
 

schemathesis/cli/constants.py

@@ -5,4 +5,4 @@ ISSUE_TRACKER_URL = (
     "https://github.com/schemathesis/schemathesis/issues/new?"
     "labels=Status%3A%20Needs%20Triage%2C+Type%3A+Bug&template=bug_report.md&title=%5BBUG%5D"
 )
-EXTENSIONS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/extending.html"
+EXTENSIONS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/guides/extending/"

schemathesis/config/_operations.py

@@ -159,34 +159,23 @@ class OperationsConfig(DiffBase):
         if exclude_deprecated:
             exclude_set.include(is_deprecated)
 
-        # Also update operations list for consistency with config structure
-        if not include_set.is_empty():
-            self.operations.insert(0, OperationConfig(filter_set=include_set, enabled=True))
-        if not exclude_set.is_empty():
-            self.operations.insert(0, OperationConfig(filter_set=exclude_set, enabled=False))
+        operations = list(self.operations)
 
         final = FilterSet()
 
-        # Get a stable reference to operations
-        operations = list(self.operations)
-
-        # Define a closure that implements our priority logic
         def priority_filter(ctx: HasAPIOperation) -> bool:
             """Filter operations according to CLI and config priority."""
-            # 1. CLI includes override everything if present
-            if not include_set.is_empty():
-                return include_set.match(ctx)
-
-            # 2. CLI excludes take precedence over config
-            if not exclude_set.is_empty() and exclude_set.match(ctx):
-                return False
-
-            # 3. Check config operations in priority order (first match wins)
             for op_config in operations:
-                if op_config._filter_set.match(ctx):
-                    return op_config.enabled
+                if op_config._filter_set.match(ctx) and not op_config.enabled:
+                    return False
+
+            if not include_set.is_empty():
+                if exclude_set.is_empty():
+                    return include_set.match(ctx)
+                return include_set.match(ctx) and not exclude_set.match(ctx)
+            elif not exclude_set.is_empty():
+                return not exclude_set.match(ctx)
 
-            # 4. Default to include if no rule matches
             return True
 
         # Add our priority function as the filter
@@ -278,24 +267,30 @@ class OperationConfig(DiffBase):
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> OperationConfig:
         filter_set = FilterSet()
+        seen = set()
         for key_suffix, arg_suffix in (("", ""), ("-regex", "_regex")):
             for attr, arg_name in FILTER_ATTRIBUTES:
                 key = f"include-{attr}{key_suffix}"
                 if key in data:
+                    seen.add(key)
                     with reraise_filter_error(attr):
                         filter_set.include(**{f"{arg_name}{arg_suffix}": data[key]})
                 key = f"exclude-{attr}{key_suffix}"
                 if key in data:
+                    seen.add(key)
                     with reraise_filter_error(attr):
                         filter_set.exclude(**{f"{arg_name}{arg_suffix}": data[key]})
         for key, method in (("include-by", filter_set.include), ("exclude-by", filter_set.exclude)):
             if key in data:
+                seen.add(key)
                 expression = data[key]
                 try:
                     func = expression_to_filter_function(expression)
                     method(func)
                 except ValueError:
                     raise ConfigError(f"Invalid filter expression: '{expression}'") from None
+        if not set(data) - seen:
+            raise ConfigError("Operation filters defined, but no settings are being overridden")
 
         return cls(
             filter_set=filter_set,

schemathesis/config/_projects.py

@@ -192,6 +192,7 @@ class ProjectConfig(DiffBase):
         tls_verify: bool | str | None = None,
         request_cert: str | None = None,
         request_cert_key: str | None = None,
+        parameters: dict[str, Any] | None = None,
         proxy: str | None = None,
         suppress_health_check: list[HealthCheck] | None = None,
         warnings: bool | list[SchemathesisWarning] | None = None,
@@ -235,6 +236,9 @@ class ProjectConfig(DiffBase):
         if proxy is not None:
             self.proxy = proxy
 
+        if parameters is not None:
+            self.parameters = parameters
+
         if suppress_health_check is not None:
             self.suppress_health_check = suppress_health_check
 
@@ -251,7 +255,7 @@ class ProjectConfig(DiffBase):
             return self.auth.basic
         return None
 
-    def headers_for(self, *, operation: APIOperation | None = None) -> dict[str, str] | None:
+    def headers_for(self, *, operation: APIOperation | None = None) -> dict[str, str]:
         """Get explicitly configured headers."""
         headers = self.headers.copy() if self.headers else {}
         if operation is not None:

schemathesis/core/errors.py

@@ -20,10 +20,16 @@ if TYPE_CHECKING:
 
 
 SCHEMA_ERROR_SUGGESTION = "Ensure that the definition complies with the OpenAPI specification"
-SERIALIZERS_SUGGESTION_MESSAGE = (
-    "You can register your own serializer with `schemathesis.serializer` "
-    "and Schemathesis will be able to make API calls with this media type. \n"
-    "See https://schemathesis.readthedocs.io/en/stable/how.html#payload-serialization for more information."
+SERIALIZERS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/guides/custom-serializers/"
+SERIALIZERS_SUGGESTION_MESSAGE = f"Check your schema or add custom serializers: {SERIALIZERS_DOCUMENTATION_URL}"
+SERIALIZATION_NOT_POSSIBLE_MESSAGE = f"No supported serializers for media types: {{}}\n{SERIALIZERS_SUGGESTION_MESSAGE}"
+SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
+    f"Cannot serialize to '{{}}' (unsupported media type)\n{SERIALIZERS_SUGGESTION_MESSAGE}"
+)
+RECURSIVE_REFERENCE_ERROR_MESSAGE = (
+    "Currently, Schemathesis can't generate data for this operation due to "
+    "recursive references in the operation definition. See more information in "
+    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
 )
 
 
@@ -277,19 +283,6 @@ class UnboundPrefix(SerializationError):
         super().__init__(UNBOUND_PREFIX_MESSAGE_TEMPLATE.format(prefix=prefix))
 
 
-SERIALIZATION_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to any of the defined media types: {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-RECURSIVE_REFERENCE_ERROR_MESSAGE = (
-    "Currently, Schemathesis can't generate data for this operation due to "
-    "recursive references in the operation definition. See more information in "
-    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
-)
-
-
 class SerializationNotPossible(SerializationError):
     """Not possible to serialize data to specified media type(s).
 

schemathesis/core/transport.py

@@ -7,7 +7,11 @@ from typing import TYPE_CHECKING, Any, Mapping
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 
 if TYPE_CHECKING:
+    import httpx
     import requests
+    from werkzeug.test import TestResponse
+
+    from schemathesis.generation.overrides import Override
 
 USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
 DEFAULT_RESPONSE_TIMEOUT = 10
@@ -51,6 +55,7 @@ class Response:
     """HTTP protocol version ("1.0" or "1.1")."""
     encoding: str | None
     """Character encoding for text content, if detected."""
+    _override: Override | None
 
     __slots__ = (
         "status_code",
@@ -64,6 +69,7 @@ class Response:
         "http_version",
         "encoding",
         "_encoded_body",
+        "_override",
     )
 
     def __init__(
@@ -77,6 +83,7 @@ class Response:
         message: str = "",
         http_version: str = "1.1",
         encoding: str | None = None,
+        _override: Override | None = None,
     ):
         self.status_code = status_code
         self.headers = {key.lower(): value for key, value in headers.items()}
@@ -90,9 +97,24 @@ class Response:
         self.message = message
         self.http_version = http_version
         self.encoding = encoding
+        self._override = _override
+
+    @classmethod
+    def from_any(cls, response: Response | httpx.Response | requests.Response | TestResponse) -> Response:
+        import httpx
+        import requests
+        from werkzeug.test import TestResponse
+
+        if isinstance(response, requests.Response):
+            return Response.from_requests(response, verify=True)
+        elif isinstance(response, httpx.Response):
+            return Response.from_httpx(response, verify=True)
+        elif isinstance(response, TestResponse):
+            return Response.from_wsgi(response)
+        return response
 
     @classmethod
-    def from_requests(cls, response: requests.Response, verify: bool) -> Response:
+    def from_requests(cls, response: requests.Response, verify: bool, _override: Override | None = None) -> Response:
         raw = response.raw
         raw_headers = raw.headers if raw is not None else {}
         headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
@@ -109,6 +131,64 @@ class Response:
             encoding=response.encoding,
             http_version=http_version,
             verify=verify,
+            _override=_override,
+        )
+
+    @classmethod
+    def from_httpx(cls, response: httpx.Response, verify: bool) -> Response:
+        import requests
+
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.url.params),
+            data=response.request.content,
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={key: [value] for key, value in response.headers.items()},
+            content=response.content,
+            request=request,
+            elapsed=response.elapsed.total_seconds(),
+            message=response.reason_phrase,
+            encoding=response.encoding,
+            http_version=response.http_version,
+            verify=verify,
+        )
+
+    @classmethod
+    def from_wsgi(cls, response: TestResponse) -> Response:
+        import http.client
+
+        import requests
+
+        reason = http.client.responses.get(response.status_code, "Unknown")
+        data = response.get_data()
+        if response.response == []:
+            # Werkzeug <3.0 had `charset` attr, newer versions always have UTF-8
+            encoding = response.mimetype_params.get("charset", getattr(response, "charset", "utf-8"))
+        else:
+            encoding = None
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.args),
+            # Request body is not available
+            data=b"",
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={name: response.headers.getlist(name) for name in response.headers.keys()},
+            content=data,
+            request=request,
+            # Elapsed time is not available
+            elapsed=0.0,
+            message=reason,
+            encoding=encoding,
+            http_version="1.1",
+            verify=False,
         )
 
     @property

schemathesis/engine/errors.py

@@ -261,7 +261,7 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
         RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
         "For guidance, visit: https://docs.python.org/3/library/re.html",
         RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
-        "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/graphql.html#custom-scalars",
+        "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/guides/graphql-custom-scalars/",
         RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE: _format_health_check_suggestion("data_too_large"),
         RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH: _format_health_check_suggestion("filter_too_much"),
         RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW: _format_health_check_suggestion("too_slow"),