schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/__init__.py

@@ -1,82 +1,44 @@
 from __future__ import annotations
 
-from typing import Any
-
-from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets
-from ._lazy_import import lazy_import
-from .constants import SCHEMATHESIS_VERSION
-from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig
-from .models import Case
-from .specs import openapi
+from schemathesis import auths, contrib, engine, errors, experimental, graphql, hooks, openapi, pytest, python
+from schemathesis.checks import CheckContext, CheckFunction, check
+from schemathesis.core.output import OutputConfig, sanitization
+from schemathesis.core.transport import Response
+from schemathesis.core.version import SCHEMATHESIS_VERSION
+from schemathesis.generation import GenerationConfig, GenerationMode, HeaderConfig
+from schemathesis.generation.case import Case
+from schemathesis.generation.targets import TargetContext, TargetFunction, target
 
 __version__ = SCHEMATHESIS_VERSION
 
-# Default loaders
-from_aiohttp = openapi.from_aiohttp
-from_asgi = openapi.from_asgi
-from_dict = openapi.from_dict
-from_file = openapi.from_file
-from_path = openapi.from_path
-from_pytest_fixture = openapi.from_pytest_fixture
-from_uri = openapi.from_uri
-from_wsgi = openapi.from_wsgi
-
 # Public API
 auth = auths.GLOBAL_AUTH_STORAGE
-check = checks.register
 hook = hooks.register
-serializer = serializers.register
-target = targets.register
-
-# Backward compatibility
-register_check = checks.register
-register_target = targets.register
-register_string_format = openapi.format
 
 __all__ = [
-    "auths",
-    "checks",
-    "experimental",
-    "contrib",
-    "fixups",
-    "graphql",
-    "hooks",
-    "runner",
-    "serializers",
-    "targets",
-    "DataGenerationMethod",
-    "SCHEMATHESIS_VERSION",
     "Case",
-    "openapi",
+    "CheckContext",
+    "CheckFunction",
+    "GenerationMode",
+    "GenerationConfig",
+    "HeaderConfig",
+    "OutputConfig",
+    "Response",
+    "TargetContext",
+    "TargetFunction",
     "__version__",
-    "from_aiohttp",
-    "from_asgi",
-    "from_dict",
-    "from_file",
-    "from_path",
-    "from_pytest_fixture",
-    "from_uri",
-    "from_wsgi",
     "auth",
     "check",
+    "contrib",
+    "engine",
+    "errors",
+    "experimental",
+    "graphql",
     "hook",
-    "serializer",
+    "hooks",
+    "openapi",
+    "pytest",
+    "python",
+    "sanitization",
     "target",
-    "register_check",
-    "register_target",
-    "register_string_format",
 ]
-
-
-def _load_generic_response() -> Any:
-    from .transports.responses import GenericResponse
-
-    return GenericResponse
-
-
-_imports = {"GenericResponse": _load_generic_response}
-
-
-def __getattr__(name: str) -> Any:
-    # Some modules are relatively heavy, hence load them lazily to improve startup time for CLI
-    return lazy_import(__name__, name, _imports, globals())

schemathesis/auths.py

@@ -2,10 +2,8 @@
 
 from __future__ import annotations
 
-import inspect
 import threading
 import time
-import warnings
 from dataclasses import dataclass, field
 from typing import (
     TYPE_CHECKING,
@@ -19,17 +17,18 @@ from typing import (
     runtime_checkable,
 )
 
-from .exceptions import UsageError
-from .filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
+from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.marks import Mark
+from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, attach_filter_chain
+from schemathesis.generation.case import Case
 
 if TYPE_CHECKING:
     import requests.auth
 
-    from .models import APIOperation, Case
-    from .types import GenericTest
+    from schemathesis.schemas import APIOperation
 
 DEFAULT_REFRESH_INTERVAL = 300
-AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"
+AuthStorageMark = Mark["AuthStorage"](attr_name="auth_storage")
 Auth = TypeVar("Auth")
 
 
@@ -111,7 +110,7 @@ class CachingAuthProvider(Generic[Auth]):
                     # Another thread updated the cache
                     return cache_entry.data
                 # We know that optional auth is possible only inside a higher-level wrapper
-                data: Auth = _provider_get(self.provider, case, context)  # type: ignore[assignment]
+                data: Auth = self.provider.get(case, context)  # type: ignore[assignment]
                 self._set_cache_entry(data, case, context)
                 return data
         return cache_entry.data
@@ -152,8 +151,7 @@ class KeyedCachingAuthProvider(CachingAuthProvider[Auth]):
 class FilterableRegisterAuth(Protocol):
     """Protocol that adds filters to the return value of `register`."""
 
-    def __call__(self, provider_class: type[AuthProvider]) -> type[AuthProvider]:
-        pass
+    def __call__(self, provider_class: type[AuthProvider]) -> type[AuthProvider]: ...
 
     def apply_to(
         self,
@@ -165,8 +163,7 @@ class FilterableRegisterAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableRegisterAuth:
-        pass
+    ) -> FilterableRegisterAuth: ...
 
     def skip_for(
         self,
@@ -178,15 +175,13 @@ class FilterableRegisterAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableRegisterAuth:
-        pass
+    ) -> FilterableRegisterAuth: ...
 
 
 class FilterableApplyAuth(Protocol):
     """Protocol that adds filters to the return value of `apply`."""
 
-    def __call__(self, test: GenericTest) -> GenericTest:
-        pass
+    def __call__(self, test: Callable) -> Callable: ...
 
     def apply_to(
         self,
@@ -198,8 +193,7 @@ class FilterableApplyAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableApplyAuth:
-        pass
+    ) -> FilterableApplyAuth: ...
 
     def skip_for(
         self,
@@ -211,8 +205,7 @@ class FilterableApplyAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableApplyAuth:
-        pass
+    ) -> FilterableApplyAuth: ...
 
 
 class FilterableRequestsAuth(Protocol):
@@ -228,8 +221,7 @@ class FilterableRequestsAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableRequestsAuth:
-        pass
+    ) -> FilterableRequestsAuth: ...
 
     def skip_for(
         self,
@@ -241,8 +233,7 @@ class FilterableRequestsAuth(Protocol):
         method_regex: str | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
-    ) -> FilterableRequestsAuth:
-        pass
+    ) -> FilterableRequestsAuth: ...
 
 
 @dataclass
@@ -254,7 +245,7 @@ class SelectiveAuthProvider(Generic[Auth]):
 
     def get(self, case: Case, context: AuthContext) -> Auth | None:
         if self.filter_set.match(context):
-            return _provider_get(self.provider, case, context)
+            return self.provider.get(case, context)
         return None
 
     def set(self, case: Case, data: Auth, context: AuthContext) -> None:
@@ -278,8 +269,7 @@ class AuthStorage(Generic[Auth]):
         *,
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
         cache_by_key: CacheKeyFunction | None = None,
-    ) -> FilterableRegisterAuth:
-        pass
+    ) -> FilterableRegisterAuth: ...
 
     @overload
     def __call__(
@@ -288,8 +278,7 @@ class AuthStorage(Generic[Auth]):
         *,
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
         cache_by_key: CacheKeyFunction | None = None,
-    ) -> FilterableApplyAuth:
-        pass
+    ) -> FilterableApplyAuth: ...
 
     def __call__(
         self,
@@ -307,8 +296,7 @@ class AuthStorage(Generic[Auth]):
         filter_set = FilterSet()
         self.providers.append(SelectiveAuthProvider(provider=RequestsAuth(auth), filter_set=filter_set))
 
-        class _FilterableRequestsAuth:
-            pass
+        class _FilterableRequestsAuth: ...
 
         attach_filter_chain(_FilterableRequestsAuth, "apply_to", filter_set.include)
         attach_filter_chain(_FilterableRequestsAuth, "skip_for", filter_set.exclude)
@@ -418,8 +406,11 @@ class AuthStorage(Generic[Auth]):
         """
         filter_set = FilterSet()
 
-        def wrapper(test: GenericTest) -> GenericTest:
-            auth_storage = self.add_auth_storage(test)
+        def wrapper(test: Callable) -> Callable:
+            if AuthStorageMark.is_set(test):
+                raise IncorrectUsage(f"`{test.__name__}` has already been decorated with `apply`.")
+            auth_storage = self.__class__()
+            AuthStorageMark.set(test, auth_storage)
             auth_storage._set_provider(
                 provider_class=provider_class,
                 refresh_interval=refresh_interval,
@@ -433,46 +424,18 @@ class AuthStorage(Generic[Auth]):
 
         return wrapper  # type: ignore[return-value]
 
-    @classmethod
-    def add_auth_storage(cls, test: GenericTest) -> AuthStorage:
-        """Attach a new auth storage instance to the test if it is not already present."""
-        if not hasattr(test, AUTH_STORAGE_ATTRIBUTE_NAME):
-            setattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, cls())
-        else:
-            raise UsageError(f"`{test.__name__}` has already been decorated with `apply`.")
-        return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME)
-
     def set(self, case: Case, context: AuthContext) -> None:
         """Set authentication data on a generated test case."""
         if not self.is_defined:
-            raise UsageError("No auth provider is defined.")
+            raise IncorrectUsage("No auth provider is defined.")
         for provider in self.providers:
-            data: Auth | None = _provider_get(provider, case, context)
+            data: Auth | None = provider.get(case, context)
             if data is not None:
                 provider.set(case, data, context)
                 case._has_explicit_auth = True
                 break
 
 
-def _provider_get(auth_provider: AuthProvider, case: Case, context: AuthContext) -> Auth | None:
-    # A shim to provide a compatibility layer between previously used convention for `AuthProvider.get`
-    # where it used to accept a single `context` argument
-    method = auth_provider.get
-    parameters = inspect.signature(method).parameters
-    if len(parameters) == 1:
-        # Old calling convention
-        warnings.warn(
-            "The method 'get' of your AuthProvider is using the old calling convention, "
-            "which is deprecated and will be removed in Schemathesis 4.0. "
-            "Please update it to accept both 'case' and 'context' as arguments.",
-            DeprecationWarning,
-            stacklevel=1,
-        )
-        return method(context)  # type: ignore
-    # New calling convention
-    return method(case, context)
-
-
 def set_on_case(case: Case, context: AuthContext, auth_storage: AuthStorage | None) -> None:
     """Set authentication data on this case.
 
@@ -486,11 +449,6 @@ def set_on_case(case: Case, context: AuthContext, auth_storage: AuthStorage | No
         GLOBAL_AUTH_STORAGE.set(case, context)
 
 
-def get_auth_storage_from_test(test: GenericTest) -> AuthStorage | None:
-    """Extract the currently attached auth storage from a test function."""
-    return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, None)
-
-
 # Global auth API
 GLOBAL_AUTH_STORAGE: AuthStorage = AuthStorage()
 register = GLOBAL_AUTH_STORAGE.register

schemathesis/checks.py

@@ -1,80 +1,150 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING
-
-from . import failures
-from .exceptions import get_response_parsing_error, get_server_error
-from .specs.openapi.checks import (
-    content_type_conformance,
-    ignored_auth,
-    negative_data_rejection,
-    response_headers_conformance,
-    response_schema_conformance,
-    status_code_conformance,
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, Optional
+
+from schemathesis.core.failures import (
+    CustomFailure,
+    Failure,
+    FailureGroup,
+    MalformedJson,
+    MaxResponseTimeConfig,
+    ResponseTimeExceeded,
+    ServerError,
 )
+from schemathesis.core.registries import Registry
+from schemathesis.core.transport import Response
+from schemathesis.generation.overrides import Override
 
 if TYPE_CHECKING:
-    from .internal.checks import CheckContext, CheckFunction
-    from .models import Case
-    from .transports.responses import GenericResponse
+    from requests.models import CaseInsensitiveDict
 
+    from schemathesis.engine.recorder import ScenarioRecorder
+    from schemathesis.generation.case import Case
 
-def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
+CheckFunction = Callable[["CheckContext", "Response", "Case"], Optional[bool]]
+ChecksConfig = dict[CheckFunction, Any]
+
+
+class CheckContext:
+    """Context for Schemathesis checks.
+
+    Provides access to broader test execution data beyond individual test cases.
+    """
+
+    override: Override | None
+    auth: tuple[str, str] | None
+    headers: CaseInsensitiveDict | None
+    config: ChecksConfig
+    transport_kwargs: dict[str, Any] | None
+    recorder: ScenarioRecorder | None
+
+    __slots__ = ("override", "auth", "headers", "config", "transport_kwargs", "recorder")
+
+    def __init__(
+        self,
+        override: Override | None,
+        auth: tuple[str, str] | None,
+        headers: CaseInsensitiveDict | None,
+        config: ChecksConfig,
+        transport_kwargs: dict[str, Any] | None,
+        recorder: ScenarioRecorder | None = None,
+    ) -> None:
+        self.override = override
+        self.auth = auth
+        self.headers = headers
+        self.config = config
+        self.transport_kwargs = transport_kwargs
+        self.recorder = recorder
+
+    def find_parent(self, *, case_id: str) -> Case | None:
+        if self.recorder is not None:
+            return self.recorder.find_parent(case_id=case_id)
+        return None
+
+    def find_related(self, *, case_id: str) -> Iterator[Case]:
+        if self.recorder is not None:
+            yield from self.recorder.find_related(case_id=case_id)
+
+    def find_response(self, *, case_id: str) -> Response | None:
+        if self.recorder is not None:
+            return self.recorder.find_response(case_id=case_id)
+        return None
+
+    def record_case(self, *, parent_id: str, case: Case) -> None:
+        if self.recorder is not None:
+            self.recorder.record_case(parent_id=parent_id, transition=None, case=case)
+
+    def record_response(self, *, case_id: str, response: Response) -> None:
+        if self.recorder is not None:
+            self.recorder.record_response(case_id=case_id, response=response)
+
+
+CHECKS = Registry[CheckFunction]()
+check = CHECKS.register
+
+
+@check
+def not_a_server_error(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
-    from .specs.graphql.schemas import GraphQLCase
+    from .specs.graphql.schemas import GraphQLSchema
     from .specs.graphql.validation import validate_graphql_response
-    from .transports.responses import get_json
 
     status_code = response.status_code
     if status_code >= 500:
-        exc_class = get_server_error(case.operation.verbose_name, status_code)
-        raise exc_class(failures.ServerError.title, context=failures.ServerError(status_code=status_code))
-    if isinstance(case, GraphQLCase):
+        raise ServerError(operation=case.operation.label, status_code=status_code)
+    if isinstance(case.operation.schema, GraphQLSchema):
         try:
-            data = get_json(response)
-            validate_graphql_response(data)
+            data = response.json()
+            validate_graphql_response(case, data)
         except json.JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(case.operation.verbose_name, exc)
-            context = failures.JSONDecodeErrorContext.from_exception(exc)
-            raise exc_class(context.title, context=context) from exc
+            raise MalformedJson.from_exception(operation=case.operation.label, exc=exc) from None
     return None
 
 
-def _make_max_response_time_failure_message(elapsed_time: float, max_response_time: int) -> str:
-    return f"Actual: {elapsed_time:.2f}ms\nLimit: {max_response_time}.00ms"
-
-
-DEFAULT_CHECKS: tuple[CheckFunction, ...] = (not_a_server_error,)
-OPTIONAL_CHECKS = (
-    status_code_conformance,
-    content_type_conformance,
-    response_headers_conformance,
-    response_schema_conformance,
-    negative_data_rejection,
-    ignored_auth,
-)
-ALL_CHECKS: tuple[CheckFunction, ...] = DEFAULT_CHECKS + OPTIONAL_CHECKS
-
-
-def register(check: CheckFunction) -> CheckFunction:
-    """Register a new check for schemathesis CLI.
-
-    :param check: A function to validate API responses.
-
-    .. code-block:: python
-
-        @schemathesis.check
-        def new_check(ctx, response, case):
-            # some awesome assertions!
-            ...
-    """
-    from . import cli
-    from .internal.checks import wrap_check
+def max_response_time(ctx: CheckContext, response: Response, case: Case) -> bool | None:
+    config = ctx.config.get(max_response_time, MaxResponseTimeConfig())
+    elapsed = response.elapsed
+    if elapsed > config.limit:
+        raise ResponseTimeExceeded(
+            operation=case.operation.label,
+            message=f"Actual: {elapsed:.2f}ms\nLimit: {config.limit * 1000:.2f}ms",
+            elapsed=elapsed,
+            deadline=config.limit,
+        )
+    return None
 
-    _check = wrap_check(check)
-    global ALL_CHECKS
 
-    ALL_CHECKS += (_check,)
-    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
-    return check
+def run_checks(
+    *,
+    case: Case,
+    response: Response,
+    ctx: CheckContext,
+    checks: Iterable[CheckFunction],
+    on_failure: Callable[[str, set[Failure], Failure], None],
+    on_success: Callable[[str, Case], None] | None = None,
+) -> set[Failure]:
+    """Run a set of checks against a response."""
+    collected: set[Failure] = set()
+
+    for check in checks:
+        name = check.__name__
+        try:
+            skip_check = check(ctx, response, case)
+            if not skip_check and on_success:
+                on_success(name, case)
+        except Failure as failure:
+            on_failure(name, collected, failure.with_traceback(None))
+        except AssertionError as exc:
+            custom_failure = CustomFailure(
+                operation=case.operation.label,
+                title=f"Custom check failed: `{name}`",
+                message=str(exc),
+                exception=exc,
+            )
+            on_failure(name, collected, custom_failure)
+        except FailureGroup as group:
+            for sub_failure in group.exceptions:
+                on_failure(name, collected, sub_failure)
+
+    return collected