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

schemathesis/graphql/checks.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from schemathesis.core.failures import Failure, Severity
+
+if TYPE_CHECKING:
+    from graphql.error import GraphQLFormattedError
+
+
+class UnexpectedGraphQLResponse(Failure):
+    """GraphQL response is not a JSON object."""
+
+    __slots__ = ("operation", "type_name", "title", "message", "case_id", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        type_name: str,
+        title: str = "Unexpected GraphQL Response",
+        message: str,
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.type_name = type_name
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self.severity = Severity.MEDIUM
+
+    @property
+    def _unique_key(self) -> str:
+        return self.type_name
+
+
+class GraphQLClientError(Failure):
+    """GraphQL query has not been executed."""
+
+    __slots__ = ("operation", "errors", "title", "message", "case_id", "_unique_key_cache", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        message: str,
+        errors: list[GraphQLFormattedError],
+        title: str = "GraphQL client error",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.errors = errors
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self._unique_key_cache: str | None = None
+        self.severity = Severity.MEDIUM
+
+    @property
+    def _unique_key(self) -> str:
+        if self._unique_key_cache is None:
+            self._unique_key_cache = _group_graphql_errors(self.errors)
+        return self._unique_key_cache
+
+
+class GraphQLServerError(Failure):
+    """GraphQL response indicates at least one server error."""
+
+    __slots__ = ("operation", "errors", "title", "message", "case_id", "_unique_key_cache", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        message: str,
+        errors: list[GraphQLFormattedError],
+        title: str = "GraphQL server error",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.errors = errors
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self._unique_key_cache: str | None = None
+        self.severity = Severity.CRITICAL
+
+    @property
+    def _unique_key(self) -> str:
+        if self._unique_key_cache is None:
+            self._unique_key_cache = _group_graphql_errors(self.errors)
+        return self._unique_key_cache
+
+
+def _group_graphql_errors(errors: list[GraphQLFormattedError]) -> str:
+    entries = []
+    for error in errors:
+        message = error["message"]
+        if "locations" in error:
+            message += ";locations:"
+            for location in sorted(error["locations"]):
+                message += f"({location['line'], location['column']})"
+        if "path" in error:
+            message += ";path:"
+            for chunk in error["path"]:
+                message += str(chunk)
+        entries.append(message)
+    entries.sort()
+    return "".join(entries)

schemathesis/graphql/loaders.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from os import PathLike
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any, Callable, Dict, NoReturn, TypeVar, cast
+
+from schemathesis.core.errors import LoaderError, LoaderErrorKind
+from schemathesis.core.loaders import load_from_url, prepare_request_kwargs, raise_for_status, require_relative_url
+from schemathesis.hooks import HookContext, dispatch
+from schemathesis.python import asgi, wsgi
+
+if TYPE_CHECKING:
+    from graphql import DocumentNode
+
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+
+def from_asgi(path: str, app: Any, **kwargs: Any) -> GraphQLSchema:
+    require_relative_url(path)
+    kwargs.setdefault("json", {"query": get_introspection_query()})
+    client = asgi.get_client(app)
+    response = load_from_url(client.post, url=path, **kwargs)
+    schema = extract_schema_from_response(response, lambda r: r.json())
+    return from_dict(schema=schema).configure(app=app, location=path)
+
+
+def from_wsgi(path: str, app: Any, **kwargs: Any) -> GraphQLSchema:
+    require_relative_url(path)
+    prepare_request_kwargs(kwargs)
+    kwargs.setdefault("json", {"query": get_introspection_query()})
+    client = wsgi.get_client(app)
+    response = client.post(path=path, **kwargs)
+    raise_for_status(response)
+    schema = extract_schema_from_response(response, lambda r: r.json)
+    return from_dict(schema=schema).configure(app=app, location=path)
+
+
+def from_url(url: str, *, wait_for_schema: float | None = None, **kwargs: Any) -> GraphQLSchema:
+    """Load from URL."""
+    import requests
+
+    kwargs.setdefault("json", {"query": get_introspection_query()})
+    response = load_from_url(requests.post, url=url, wait_for_schema=wait_for_schema, **kwargs)
+    schema = extract_schema_from_response(response, lambda r: r.json())
+    return from_dict(schema).configure(location=url)
+
+
+def from_path(path: PathLike | str, *, encoding: str = "utf-8") -> GraphQLSchema:
+    """Load from a filesystem path."""
+    with open(path, encoding=encoding) as file:
+        return from_file(file=file).configure(location=Path(path).absolute().as_uri())
+
+
+def from_file(file: IO[str] | str) -> GraphQLSchema:
+    """Load from file-like object or string."""
+    import graphql
+
+    if isinstance(file, str):
+        data = file
+    else:
+        data = file.read()
+    try:
+        document = graphql.build_schema(data)
+        result = graphql.execute(document, get_introspection_query_ast())
+        # TYPES: We don't pass `is_awaitable` above, therefore `result` is of the `ExecutionResult` type
+        result = cast(graphql.ExecutionResult, result)
+        # TYPES:
+        #  - `document` is a valid schema, because otherwise `build_schema` will rise an error;
+        #  - `INTROSPECTION_QUERY` is a valid query - it is known upfront;
+        # Therefore the execution result is always valid at this point and `result.data` is not `None`
+        schema = cast(Dict[str, Any], result.data)
+    except Exception as exc:
+        try:
+            schema = json.loads(data)
+            if not isinstance(schema, dict) or "__schema" not in schema:
+                _on_invalid_schema(exc)
+        except json.JSONDecodeError:
+            _on_invalid_schema(exc, extras=[entry for entry in str(exc).splitlines() if entry])
+    return from_dict(schema)
+
+
+def from_dict(schema: dict[str, Any]) -> GraphQLSchema:
+    """Base loader that others build upon."""
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+    if "data" in schema:
+        schema = schema["data"]
+    hook_context = HookContext()
+    dispatch("before_load_schema", hook_context, schema)
+    instance = GraphQLSchema(schema)
+    dispatch("after_load_schema", hook_context, instance)
+    return instance
+
+
+@lru_cache
+def get_introspection_query() -> str:
+    import graphql
+
+    return graphql.get_introspection_query()
+
+
+@lru_cache
+def get_introspection_query_ast() -> DocumentNode:
+    import graphql
+
+    query = get_introspection_query()
+    return graphql.parse(query)
+
+
+R = TypeVar("R")
+
+
+def extract_schema_from_response(response: R, callback: Callable[[R], Any]) -> dict[str, Any]:
+    try:
+        decoded = callback(response)
+    except json.JSONDecodeError as exc:
+        raise LoaderError(
+            LoaderErrorKind.UNEXPECTED_CONTENT_TYPE,
+            "Received unsupported content while expecting a JSON payload for GraphQL",
+        ) from exc
+    return decoded
+
+
+def _on_invalid_schema(exc: Exception, extras: list[str] | None = None) -> NoReturn:
+    raise LoaderError(
+        LoaderErrorKind.GRAPHQL_INVALID_SCHEMA,
+        "The provided API schema does not appear to be a valid GraphQL schema",
+        extras=extras or [],
+    ) from exc

schemathesis/hooks.py

@@ -2,22 +2,22 @@ from __future__ import annotations
 
 import inspect
 from collections import defaultdict
-from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
 
-from .filters import FilterSet, attach_filter_chain
-from .internal.deprecation import deprecated_property
+from schemathesis.core.marks import Mark
+from schemathesis.core.transport import Response
+from schemathesis.filters import FilterSet, attach_filter_chain
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
-    from .models import APIOperation, Case
-    from .schemas import BaseSchema
-    from .transports.responses import GenericResponse
-    from .types import GenericTest
+    from schemathesis.generation.case import Case
+    from schemathesis.schemas import APIOperation, BaseSchema
+
+HookDispatcherMark = Mark["HookDispatcher"](attr_name="hook_dispatcher")
 
 
 @unique
@@ -45,10 +45,6 @@ class HookContext:
 
     operation: APIOperation | None = None
 
-    @deprecated_property(removed_in="4.0", replacement="`operation`")
-    def endpoint(self) -> APIOperation | None:
-        return self.operation
-
 
 def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
     filter_used = False
@@ -140,18 +136,6 @@ class HookDispatcher:
         """
         raise NotImplementedError
 
-    def merge(self, other: HookDispatcher) -> HookDispatcher:
-        """Merge two dispatches together.
-
-        The resulting dispatcher will call the `self` hooks first.
-        """
-        all_hooks = deepcopy(self._hooks)
-        for name, hooks in other._hooks.items():
-            all_hooks[name].extend(hooks)
-        instance = self.__class__(scope=self.scope)
-        instance._hooks = all_hooks
-        return instance
-
     def apply(self, hook: Callable, *, name: str | None = None) -> Callable[[Callable], Callable]:
         """Register hook to run only on one test function.
 
@@ -175,7 +159,7 @@ class HookDispatcher:
         else:
             hook_name = name
 
-        def decorator(func: GenericTest) -> GenericTest:
+        def decorator(func: Callable) -> Callable:
             dispatcher = self.add_dispatcher(func)
             dispatcher.register_hook_with_name(hook, hook_name)
             return func
@@ -183,11 +167,13 @@ class HookDispatcher:
         return decorator
 
     @classmethod
-    def add_dispatcher(cls, func: GenericTest) -> HookDispatcher:
+    def add_dispatcher(cls, func: Callable) -> HookDispatcher:
         """Attach a new dispatcher instance to the test if it is not already present."""
-        if not hasattr(func, "_schemathesis_hooks"):
-            func._schemathesis_hooks = cls(scope=HookScope.TEST)  # type: ignore
-        return func._schemathesis_hooks  # type: ignore
+        if not HookDispatcherMark.is_set(func):
+            HookDispatcherMark.set(func, cls(scope=HookScope.TEST))
+        dispatcher = HookDispatcherMark.get(func)
+        assert dispatcher is not None
+        return dispatcher
 
     def register_hook_with_name(self, hook: Callable, name: str) -> Callable:
         """A helper for hooks registration."""
@@ -226,19 +212,10 @@ class HookDispatcher:
                 f"Hook '{name}' takes {len(spec.signature.parameters)} arguments but {len(signature.parameters)} is defined"
             )
 
-    def collect_statistic(self) -> dict[str, int]:
-        return {name: len(hooks) for name, hooks in self._hooks.items()}
-
     def get_all_by_name(self, name: str) -> list[Callable]:
         """Get a list of hooks registered for a name."""
         return self._hooks.get(name, [])
 
-    def is_installed(self, name: str, needle: Callable) -> bool:
-        for hook in self.get_all_by_name(name):
-            if hook is needle:
-                return True
-        return False
-
     def apply_to_container(
         self, strategy: st.SearchStrategy, container: str, context: HookContext
     ) -> st.SearchStrategy:
@@ -307,19 +284,12 @@ def apply_to_all_dispatchers(
     return strategy
 
 
-def should_skip_operation(dispatcher: HookDispatcher, context: HookContext) -> bool:
-    for hook in dispatcher.get_all_by_name("filter_operations"):
-        if not hook(context):
-            return True
-    return False
-
-
 def validate_filterable_hook(hook: str | Callable) -> None:
     if callable(hook):
         name = hook.__name__
     else:
         name = hook
-    if name in ("before_process_path", "before_load_schema", "after_load_schema", "after_init_cli_run_handlers"):
+    if name in ("before_process_path", "before_load_schema", "after_load_schema"):
         raise ValueError(f"Filters are not applicable to this hook: `{name}`")
 
 
@@ -373,11 +343,6 @@ def before_process_path(context: HookContext, path: str, methods: dict[str, Any]
     """Called before API path is processed."""
 
 
-@all_scopes
-def filter_operations(context: HookContext) -> bool | None:
-    """Decide whether testing of this particular API operation should be skipped or not."""
-
-
 @HookDispatcher.register_spec([HookScope.GLOBAL])
 def before_load_schema(context: HookContext, raw_schema: dict[str, Any]) -> None:
     """Called before schema instance is created."""
@@ -402,15 +367,7 @@ def before_init_operation(context: HookContext, operation: APIOperation) -> None
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def add_case(context: HookContext, case: Case, response: GenericResponse) -> Case | None:
-    """Creates an additional test per API operation. If this hook returns None, no additional test created.
-
-    Called with a copy of the original case object and the server's response to the original case.
-    """
-
-
-@HookDispatcher.register_spec([HookScope.GLOBAL])
-def before_call(context: HookContext, case: Case) -> None:
+def before_call(context: HookContext, case: Case, **kwargs: Any) -> None:
     """Called before every network call in CLI tests.
 
     Use cases:
@@ -420,7 +377,7 @@ def before_call(context: HookContext, case: Case) -> None:
 
 
 @HookDispatcher.register_spec([HookScope.GLOBAL])
-def after_call(context: HookContext, case: Case, response: GenericResponse) -> None:
+def after_call(context: HookContext, case: Case, response: Response) -> None:
     """Called after every network call in CLI tests.
 
     Note that you need to modify the response in-place.
@@ -434,8 +391,6 @@ def after_call(context: HookContext, case: Case, response: GenericResponse) -> N
 GLOBAL_HOOK_DISPATCHER = HookDispatcher(scope=HookScope.GLOBAL)
 dispatch = GLOBAL_HOOK_DISPATCHER.dispatch
 get_all_by_name = GLOBAL_HOOK_DISPATCHER.get_all_by_name
-is_installed = GLOBAL_HOOK_DISPATCHER.is_installed
-collect_statistic = GLOBAL_HOOK_DISPATCHER.collect_statistic
 register = GLOBAL_HOOK_DISPATCHER.register
 unregister = GLOBAL_HOOK_DISPATCHER.unregister
 unregister_all = GLOBAL_HOOK_DISPATCHER.unregister_all

schemathesis/openapi/__init__.py

@@ -0,0 +1,13 @@
+from schemathesis.openapi.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi
+from schemathesis.specs.openapi import format, media_type
+
+__all__ = [
+    "from_url",
+    "from_asgi",
+    "from_wsgi",
+    "from_file",
+    "from_path",
+    "from_dict",
+    "format",
+    "media_type",
+]