schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/specs/graphql/schemas.py

@@ -1,37 +1,34 @@
 from __future__ import annotations
 
 import enum
+import time
 from dataclasses import dataclass, field
 from difflib import get_close_matches
 from enum import unique
+from types import SimpleNamespace
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Generator,
+    Iterator,
+    Mapping,
+    NoReturn,
     Sequence,
     TypeVar,
     cast,
-    TYPE_CHECKING,
-    NoReturn,
-    MutableMapping,
-    Iterator,
 )
 from urllib.parse import urlsplit, urlunsplit
 
 import graphql
-import requests
-from graphql import GraphQLNamedType
 from hypothesis import strategies as st
-from hypothesis.strategies import SearchStrategy
 from hypothesis_graphql import strategies as gql_st
 from requests.structures import CaseInsensitiveDict
 
-from ..openapi.constants import LOCATION_TO_CONTAINER
 from ... import auths
-from ...auths import AuthStorage
 from ...checks import not_a_server_error
-from ...constants import NOT_SET
-from ...exceptions import OperationSchemaError, OperationNotFound
+from ...constants import NOT_SET, SCHEMATHESIS_TEST_CASE_HEADER
+from ...exceptions import OperationNotFound, OperationSchemaError
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import (
     GLOBAL_HOOK_DISPATCHER,
@@ -41,13 +38,19 @@ from ...hooks import (
     should_skip_operation,
 )
 from ...internal.result import Ok, Result
-from ...models import APIOperation, Case, CheckFunction, OperationDefinition
-from ...schemas import BaseSchema, APIOperationMap
-from ...stateful import Stateful, StatefulTest
+from ...models import APIOperation, Case, OperationDefinition
+from ...schemas import APIOperationMap, BaseSchema
 from ...types import Body, Cookies, Headers, NotSet, PathParameters, Query
+from ..openapi.constants import LOCATION_TO_CONTAINER
+from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from ...auths import AuthStorage
+    from ...internal.checks import CheckFunction
+    from ...stateful import Stateful, StatefulTest
     from ...transports.responses import GenericResponse
 
 
@@ -59,39 +62,18 @@ class RootType(enum.Enum):
 
 @dataclass(repr=False)
 class GraphQLCase(Case):
-    def as_requests_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
-        final_headers = self._get_headers(headers)
+    def __hash__(self) -> int:
+        return hash(self.as_curl_command({SCHEMATHESIS_TEST_CASE_HEADER: "0"}))
+
+    def _get_url(self, base_url: str | None) -> str:
         base_url = self._get_base_url(base_url)
         # Replace the path, in case if the user provided any path parameters via hooks
         parts = list(urlsplit(base_url))
         parts[2] = self.formatted_path
-        kwargs: dict[str, Any] = {
-            "method": self.method,
-            "url": urlunsplit(parts),
-            "headers": final_headers,
-            "cookies": self.cookies,
-            "params": self.query,
-        }
-        # There is no direct way to have bytes here, but it is a useful pattern to support.
-        # It also unifies GraphQLCase with its Open API counterpart where bytes may come from external examples
-        if isinstance(self.body, bytes):
-            kwargs["data"] = self.body
-            # Assume that the payload is JSON, not raw GraphQL queries
-            kwargs["headers"].setdefault("Content-Type", "application/json")
-        else:
-            kwargs["json"] = {"query": self.body}
-        return kwargs
-
-    def as_werkzeug_kwargs(self, headers: dict[str, str] | None = None) -> dict[str, Any]:
-        final_headers = self._get_headers(headers)
-        return {
-            "method": self.method,
-            "path": self.operation.schema.get_full_path(self.formatted_path),
-            # Convert to a regular dictionary, as we use `CaseInsensitiveDict` which is not supported by Werkzeug
-            "headers": dict(final_headers),
-            "query_string": self.query,
-            "json": {"query": self.body},
-        }
+        return urlunsplit(parts)
+
+    def _get_body(self) -> Body | NotSet:
+        return self.body if isinstance(self.body, (NotSet, bytes)) else {"query": self.body}
 
     def validate_response(
         self,
@@ -100,20 +82,15 @@ class GraphQLCase(Case):
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
     ) -> None:
         checks = checks or (not_a_server_error,)
         checks += additional_checks
         checks = tuple(check for check in checks if check not in excluded_checks)
-        return super().validate_response(response, checks, code_sample_style=code_sample_style)
-
-    def call_asgi(
-        self,
-        app: Any = None,
-        base_url: str | None = None,
-        headers: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> requests.Response:
-        return super().call_asgi(app=app, base_url=base_url, headers=headers, **kwargs)
+        return super().validate_response(
+            response, checks, code_sample_style=code_sample_style, headers=headers, transport_kwargs=transport_kwargs
+        )
 
 
 C = TypeVar("C", bound=Case)
@@ -136,9 +113,37 @@ class GraphQLOperationDefinition(OperationDefinition):
 
 @dataclass
 class GraphQLSchema(BaseSchema):
+    _operation_cache: OperationCache = field(default_factory=OperationCache)
+
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}>"
 
+    def __iter__(self) -> Iterator[str]:
+        schema = self.client_schema
+        for operation_type in (
+            schema.query_type,
+            schema.mutation_type,
+        ):
+            if operation_type is not None:
+                yield operation_type.name
+
+    def _get_operation_map(self, key: str) -> APIOperationMap:
+        cache = self._operation_cache
+        map = cache.get_map(key)
+        if map is not None:
+            return map
+        schema = self.client_schema
+        for root_type, operation_type in (
+            (RootType.QUERY, schema.query_type),
+            (RootType.MUTATION, schema.mutation_type),
+        ):
+            if operation_type and operation_type.name == key:
+                map = APIOperationMap(self, {})
+                map._data = FieldMap(map, root_type, operation_type)
+                cache.insert_map(key, map)
+                return map
+        raise KeyError(key)
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raw_schema = self.raw_schema["__schema"]
         type_names = [type_def["name"] for type_def in raw_schema.get("types", [])]
@@ -148,19 +153,6 @@ class GraphQLSchema(BaseSchema):
             message += f". Did you mean `{matches[0]}`?"
         raise OperationNotFound(message=message, item=item) from exc
 
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        output: dict[str, APIOperationMap] = {}
-        for result in operations:
-            if isinstance(result, Ok):
-                operation = result.ok()
-                definition = cast(GraphQLOperationDefinition, operation.definition)
-                type_name = definition.type_.name if isinstance(definition.type_, GraphQLNamedType) else "Unknown"
-                for_type = output.setdefault(type_name, APIOperationMap(FieldMap()))
-                for_type[definition.field_name] = operation
-        return output
-
     def get_full_path(self, path: str) -> str:
         return self.base_path
 
@@ -202,7 +194,7 @@ class GraphQLSchema(BaseSchema):
         return 0
 
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         schema = self.client_schema
         for root_type, operation_type in (
@@ -211,26 +203,10 @@ class GraphQLSchema(BaseSchema):
         ):
             if operation_type is None:
                 continue
-            for field_name, definition in operation_type.fields.items():
-                operation: APIOperation = APIOperation(
-                    base_url=self.get_base_url(),
-                    path=self.base_path,
-                    verbose_name=f"{operation_type.name}.{field_name}",
-                    method="POST",
-                    app=self.app,
-                    schema=self,
-                    # Parameters are not yet supported
-                    definition=GraphQLOperationDefinition(
-                        raw=definition,
-                        resolved=definition,
-                        scope="",
-                        parameters=[],
-                        type_=operation_type,
-                        field_name=field_name,
-                        root_type=root_type,
-                    ),
-                    case_cls=GraphQLCase,
-                )
+            for field_name, field_ in operation_type.fields.items():
+                operation = self._build_operation(root_type, operation_type, field_name, field_)
+                if self._should_skip(operation):
+                    continue
                 context = HookContext(operation=operation)
                 if (
                     should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
@@ -240,6 +216,40 @@ class GraphQLSchema(BaseSchema):
                     continue
                 yield Ok(operation)
 
+    def _should_skip(
+        self,
+        operation: APIOperation,
+        _ctx_cache: SimpleNamespace = SimpleNamespace(operation=None),
+    ) -> bool:
+        _ctx_cache.operation = operation
+        return not self.filter_set.match(_ctx_cache)
+
+    def _build_operation(
+        self,
+        root_type: RootType,
+        operation_type: graphql.GraphQLObjectType,
+        field_name: str,
+        field: graphql.GraphQlField,
+    ) -> APIOperation:
+        return APIOperation(
+            base_url=self.get_base_url(),
+            path=self.base_path,
+            verbose_name=f"{operation_type.name}.{field_name}",
+            method="POST",
+            app=self.app,
+            schema=self,
+            # Parameters are not yet supported
+            definition=GraphQLOperationDefinition(
+                raw=field,
+                resolved=field,
+                scope="",
+                type_=operation_type,
+                field_name=field_name,
+                root_type=root_type,
+            ),
+            case_cls=GraphQLCase,
+        )
+
     def get_case_strategy(
         self,
         operation: APIOperation,
@@ -259,7 +269,9 @@ class GraphQLSchema(BaseSchema):
             **kwargs,
         )
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         return []
 
     def get_stateful_tests(
@@ -286,39 +298,53 @@ class GraphQLSchema(BaseSchema):
             cookies=cookies,
             query=query,
             body=body,
-            media_type=media_type,
+            media_type=media_type or "application/json",
+            generation_time=0.0,
         )
 
     def get_tags(self, operation: APIOperation) -> list[str] | None:
         return None
 
+    def validate(self) -> None:
+        return None
+
 
 @dataclass
-class FieldMap(MutableMapping):
+class FieldMap(Mapping):
     """Container for accessing API operations.
 
     Provides a more specific error message if API operation is not found.
     """
 
-    data: dict[str, APIOperation] = field(default_factory=dict)
-
-    def __setitem__(self, key: str, value: APIOperation) -> None:
-        self.data[key] = value
+    _parent: APIOperationMap
+    _root_type: RootType
+    _operation_type: graphql.GraphQLObjectType
 
-    def __delitem__(self, key: str) -> None:
-        del self.data[key]
+    __slots__ = ("_parent", "_root_type", "_operation_type")
 
     def __len__(self) -> int:
-        return len(self.data)
+        return len(self._operation_type.fields)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.data)
+        return iter(self._operation_type.fields)
+
+    def _init_operation(self, field_name: str) -> APIOperation:
+        schema = cast(GraphQLSchema, self._parent._schema)
+        cache = schema._operation_cache
+        operation = cache.get_operation(field_name)
+        if operation is not None:
+            return operation
+        operation_type = self._operation_type
+        field_ = operation_type.fields[field_name]
+        operation = schema._build_operation(self._root_type, operation_type, field_name, field_)
+        cache.insert_operation(field_name, operation)
+        return operation
 
     def __getitem__(self, item: str) -> APIOperation:
         try:
-            return self.data[item]
+            return self._init_operation(item)
         except KeyError as exc:
-            field_names = [operation.definition.field_name for operation in self.data.values()]  # type: ignore[attr-defined]
+            field_names = list(self._operation_type.fields)
             matches = get_close_matches(item, field_names)
             message = f"`{item}` field not found"
             if matches:
@@ -337,6 +363,7 @@ def get_case_strategy(
     generation_config: GenerationConfig | None = None,
     **kwargs: Any,
 ) -> Any:
+    start = time.monotonic()
     definition = cast(GraphQLOperationDefinition, operation.definition)
     strategy_factory = {
         RootType.QUERY: gql_st.queries,
@@ -351,6 +378,7 @@ def get_case_strategy(
         custom_scalars=custom_scalars,
         print_ast=_noop,  # type: ignore
         allow_x00=generation_config.allow_x00,
+        allow_null=generation_config.graphql_allow_null,
         codec=generation_config.codec,
     )
     strategy = apply_to_all_dispatchers(operation, hook_context, hooks, strategy, "body").map(graphql.print_ast)
@@ -369,6 +397,8 @@ def get_case_strategy(
         body=body,
         operation=operation,
         data_generation_method=data_generation_method,
+        generation_time=time.monotonic() - start,
+        media_type="application/json",
     )  # type: ignore
     context = auths.AuthContext(
         operation=operation,

schemathesis/specs/graphql/validation.py

@@ -1,5 +1,4 @@
-from typing import Any, cast, List
-
+from typing import Any, List, cast
 
 from ... import failures
 from ...exceptions import get_grouped_graphql_error, get_unexpected_graphql_response_error

schemathesis/specs/openapi/__init__.py

@@ -1,3 +1,4 @@
 from .formats import register_string_format as format
 from .formats import unregister_string_format
 from .loaders import from_aiohttp, from_asgi, from_dict, from_file, from_path, from_pytest_fixture, from_uri, from_wsgi
+from .media_types import register_media_type as media_type

schemathesis/specs/openapi/_cache.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Tuple
+
+if TYPE_CHECKING:
+    from ...models import APIOperation
+    from ...schemas import APIOperationMap
+
+
+@dataclass
+class OperationCacheEntry:
+    path: str
+    method: str
+    # The resolution scope of the operation
+    scope: str
+    # Parent path item
+    path_item: dict[str, Any]
+    # Unresolved operation definition
+    operation: dict[str, Any]
+    __slots__ = ("path", "method", "scope", "path_item", "operation")
+
+
+# During traversal, we need to keep track of the scope, path, and method
+TraversalKey = Tuple[str, str, str]
+OperationId = str
+Reference = str
+
+
+@dataclass
+class OperationCache:
+    """Cache for Open API operations.
+
+    This cache contains multiple levels to avoid unnecessary parsing of the schema.
+    """
+
+    # Cache to avoid schema traversal on every access
+    _id_to_definition: dict[OperationId, OperationCacheEntry] = field(default_factory=dict)
+    # Map map between 1st & 2nd level cache keys
+    # Even though 1st level keys could be directly mapped to Python objects in memory, we need to keep them separate
+    # to ensure a single owner of the operation instance.
+    _id_to_operation: dict[OperationId, int] = field(default_factory=dict)
+    _traversal_key_to_operation: dict[TraversalKey, int] = field(default_factory=dict)
+    _reference_to_operation: dict[Reference, int] = field(default_factory=dict)
+    # The actual operations
+    _operations: list[APIOperation] = field(default_factory=list)
+    # Cache for operation maps
+    _maps: dict[str, APIOperationMap] = field(default_factory=dict)
+
+    @property
+    def known_operation_ids(self) -> list[str]:
+        return list(self._id_to_definition)
+
+    @property
+    def has_ids_to_definitions(self) -> bool:
+        return bool(self._id_to_definition)
+
+    def _append_operation(self, operation: APIOperation) -> int:
+        idx = len(self._operations)
+        self._operations.append(operation)
+        return idx
+
+    def insert_definition_by_id(
+        self,
+        operation_id: str,
+        path: str,
+        method: str,
+        scope: str,
+        path_item: dict[str, Any],
+        operation: dict[str, Any],
+    ) -> None:
+        """Insert a new operation definition into cache."""
+        self._id_to_definition[operation_id] = OperationCacheEntry(
+            path=path, method=method, scope=scope, path_item=path_item, operation=operation
+        )
+
+    def get_definition_by_id(self, operation_id: str) -> OperationCacheEntry:
+        """Get an operation definition by its ID."""
+        # TODO: Avoid KeyError in the future
+        return self._id_to_definition[operation_id]
+
+    def insert_operation(
+        self,
+        operation: APIOperation,
+        *,
+        traversal_key: TraversalKey,
+        operation_id: str | None = None,
+        reference: str | None = None,
+    ) -> None:
+        """Insert a new operation into cache by one or multiple keys."""
+        idx = self._append_operation(operation)
+        self._traversal_key_to_operation[traversal_key] = idx
+        if operation_id is not None:
+            self._id_to_operation[operation_id] = idx
+        if reference is not None:
+            self._reference_to_operation[reference] = idx
+
+    def get_operation_by_id(self, operation_id: str) -> APIOperation | None:
+        """Get an operation by its ID."""
+        idx = self._id_to_operation.get(operation_id)
+        if idx is not None:
+            return self._operations[idx]
+        return None
+
+    def get_operation_by_reference(self, reference: str) -> APIOperation | None:
+        """Get an operation by its reference."""
+        idx = self._reference_to_operation.get(reference)
+        if idx is not None:
+            return self._operations[idx]
+        return None
+
+    def get_operation_by_traversal_key(self, key: TraversalKey) -> APIOperation | None:
+        """Get an operation by its traverse key."""
+        idx = self._traversal_key_to_operation.get(key)
+        if idx is not None:
+            return self._operations[idx]
+        return None
+
+    def get_map(self, key: str) -> APIOperationMap | None:
+        return self._maps.get(key)
+
+    def insert_map(self, key: str, value: APIOperationMap) -> None:
+        self._maps[key] = value