schemathesis 3.28.1__py3-none-any.whl → 3.29.0__py3-none-any.whl

schemathesis/exceptions.py

@@ -552,10 +552,11 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
         message = "Connection failed"
         inner = exc.args[0]
         if isinstance(inner, MaxRetryError) and inner.reason is not None:
-            if ":" not in inner.reason.args[0]:
-                reason = inner.reason.args[0]
+            arg = str(inner.reason.args[0])
+            if ":" not in arg:
+                reason = arg
             else:
-                _, reason = inner.reason.args[0].split(":", maxsplit=1)
+                _, reason = arg.split(":", maxsplit=1)
             extra = [reason.strip()]
         else:
             extra = [" ".join(map(str, inner.args))]

schemathesis/models.py

@@ -539,7 +539,7 @@ D = TypeVar("D", bound=dict)
 
 
 @dataclass
-class OperationDefinition(Generic[P, D]):
+class OperationDefinition(Generic[D]):
     """A wrapper to store not resolved API operation definitions.
 
     To prevent recursion errors we need to store definitions without resolving references. But operation definitions
@@ -550,16 +550,8 @@ class OperationDefinition(Generic[P, D]):
     raw: D
     resolved: D
     scope: str
-    parameters: Sequence[P]
 
-    def __contains__(self, item: str | int) -> bool:
-        return item in self.resolved
-
-    def __getitem__(self, item: str | int) -> None | bool | float | str | list | dict[str, Any]:
-        return self.resolved[item]
-
-    def get(self, item: str | int, default: Any = None) -> None | bool | float | str | list | dict[str, Any]:
-        return self.resolved.get(item, default)
+    __slots__ = ("raw", "resolved", "scope")
 
 
 C = TypeVar("C", bound=Case)

schemathesis/runner/impl/core.py

@@ -615,7 +615,7 @@ def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> No
     # Hypothesis's function digest depends on the test function signature. To reflect it for the web API case,
     # we use all API operation parameters in the digest.
     extra = operation.verbose_name.encode("utf8")
-    for parameter in operation.definition.parameters:
+    for parameter in operation.iter_parameters():
         extra += parameter.serialize(operation).encode("utf8")
     test.hypothesis.inner_test._hypothesis_internal_add_digest = extra  # type: ignore
 

schemathesis/schemas.py

@@ -9,7 +9,7 @@ They give only static definitions of paths.
 
 from __future__ import annotations
 
-from collections.abc import Mapping, MutableMapping
+from collections.abc import Mapping
 from contextlib import nullcontext
 from dataclasses import dataclass, field
 from functools import lru_cache
@@ -99,20 +99,23 @@ class BaseSchema(Mapping):
     sanitize_output: bool = True
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.operations)
+        raise NotImplementedError
 
     def __getitem__(self, item: str) -> APIOperationMap:
         __tracebackhide__ = True
         try:
-            return self.operations[item]
+            return self._get_operation_map(item)
         except KeyError as exc:
             self.on_missing_operation(item, exc)
 
+    def _get_operation_map(self, key: str) -> APIOperationMap:
+        raise NotImplementedError
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raise NotImplementedError
 
     def __len__(self) -> int:
-        return len(self.operations)
+        return self.operations_count
 
     def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
@@ -155,18 +158,6 @@ class BaseSchema(Mapping):
     def validate(self) -> None:
         raise NotImplementedError
 
-    @property
-    def operations(self) -> dict[str, APIOperationMap]:
-        if not hasattr(self, "_operations"):
-            operations = self.get_all_operations()
-            self._operations = self._store_operations(operations)
-        return self._operations
-
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        raise NotImplementedError
-
     @property
     def operations_count(self) -> int:
         raise NotImplementedError
@@ -446,39 +437,34 @@ class BaseSchema(Mapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all defined API operations."""
-        assert len(self.operations) > 0, "No API operations found"
+        assert len(self) > 0, "No API operations found"
         strategies = [
-            operation.as_strategy(
+            operation.ok().as_strategy(
                 hooks=hooks,
                 auth_storage=auth_storage,
                 data_generation_method=data_generation_method,
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operations in self.operations.values()
-            for operation in operations.values()
+            for operation in self.get_all_operations(hooks=hooks)
+            if isinstance(operation, Ok)
         ]
         return combine_strategies(strategies)
 
 
 @dataclass
-class APIOperationMap(MutableMapping):
-    data: MutableMapping
-
-    def __setitem__(self, key: str, value: APIOperation) -> None:
-        self.data[key] = value
+class APIOperationMap(Mapping):
+    _schema: BaseSchema
+    _data: Mapping
 
     def __getitem__(self, item: str) -> APIOperation:
-        return self.data[item]
-
-    def __delitem__(self, key: str) -> None:
-        del self.data[key]
+        return self._data[item]
 
     def __len__(self) -> int:
-        return len(self.data)
+        return len(self._data)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self.data)
+        return iter(self._data)
 
     def as_strategy(
         self,
@@ -489,7 +475,7 @@ class APIOperationMap(MutableMapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
-        assert len(self.data) > 0, "No API operations found"
+        assert len(self._data) > 0, "No API operations found"
         strategies = [
             operation.as_strategy(
                 hooks=hooks,
@@ -498,6 +484,6 @@ class APIOperationMap(MutableMapping):
                 generation_config=generation_config,
                 **kwargs,
             )
-            for operation in self.data.values()
+            for operation in self._data.values()
         ]
         return combine_strategies(strategies)

schemathesis/specs/graphql/_cache.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...schemas import APIOperationMap
+    from ...models import APIOperation
+
+
+@dataclass
+class OperationCache:
+    _maps: dict[str, APIOperationMap] = field(default_factory=dict)
+    _operations: dict[str, APIOperation] = field(default_factory=dict)
+
+    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
+
+    def get_operation(self, key: str) -> APIOperation | None:
+        return self._operations.get(key)
+
+    def insert_operation(self, key: str, value: APIOperation) -> None:
+        self._operations[key] = value

schemathesis/specs/graphql/schemas.py

@@ -14,13 +14,12 @@ from typing import (
     cast,
     TYPE_CHECKING,
     NoReturn,
-    MutableMapping,
+    Mapping,
     Iterator,
 )
 from urllib.parse import urlsplit, urlunsplit
 
 import graphql
-from graphql import GraphQLNamedType
 from hypothesis import strategies as st
 from hypothesis.strategies import SearchStrategy
 from hypothesis_graphql import strategies as gql_st
@@ -45,6 +44,7 @@ from ...models import APIOperation, Case, CheckFunction, OperationDefinition
 from ...schemas import BaseSchema, APIOperationMap
 from ...stateful import Stateful, StatefulTest
 from ...types import Body, Cookies, Headers, NotSet, PathParameters, Query
+from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
@@ -103,9 +103,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", [])]
@@ -115,19 +143,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
 
@@ -178,26 +193,8 @@ 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_)
                 context = HookContext(operation=operation)
                 if (
                     should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
@@ -207,6 +204,32 @@ class GraphQLSchema(BaseSchema):
                     continue
                 yield Ok(operation)
 
+    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,
@@ -262,31 +285,41 @@ class GraphQLSchema(BaseSchema):
 
 
 @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:

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

schemathesis/specs/openapi/_hypothesis.py

@@ -431,6 +431,8 @@ def _build_custom_formats(
     custom_formats = {**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
     if generation_config.headers.strategy is not None:
         custom_formats[HEADER_FORMAT] = generation_config.headers.strategy
+    elif not generation_config.allow_x00:
+        custom_formats[HEADER_FORMAT] = header_values(blacklist_characters="\n\r\x00")
     return custom_formats
 
 

schemathesis/specs/openapi/links.py

@@ -9,6 +9,8 @@ from dataclasses import dataclass, field
 from difflib import get_close_matches
 from typing import TYPE_CHECKING, Any, Generator, NoReturn, Sequence, Union
 
+from jsonschema import RefResolver
+
 from ...constants import NOT_SET
 from ...internal.copy import fast_deepcopy
 from ...models import APIOperation, Case
@@ -154,14 +156,17 @@ class Link(StatefulTest):
 
 def get_links(response: GenericResponse, operation: APIOperation, field: str) -> Sequence[Link]:
     """Get `x-links` / `links` definitions from the schema."""
-    responses = operation.definition.resolved["responses"]
+    responses = operation.definition.raw["responses"]
     if str(response.status_code) in responses:
-        response_definition = responses[str(response.status_code)]
+        definition = responses[str(response.status_code)]
     elif response.status_code in responses:
-        response_definition = responses[response.status_code]
+        definition = responses[response.status_code]
     else:
-        response_definition = responses.get("default", {})
-    links = response_definition.get(field, {})
+        definition = responses.get("default", {})
+    if not definition:
+        return []
+    _, definition = operation.schema.resolver.resolve_in_scope(definition, operation.definition.scope)  # type: ignore[attr-defined]
+    links = definition.get(field, {})
     return [Link.from_definition(name, definition, operation) for name, definition in links.items()]
 
 
@@ -201,7 +206,7 @@ class OpenAPILink(Direction):
             # Therefore the container is empty, otherwise it will be at least an empty object
             if container is None:
                 message = f"No such parameter in `{case.operation.method.upper()} {case.operation.path}`: `{name}`."
-                possibilities = [param.name for param in case.operation.definition.parameters]
+                possibilities = [param.name for param in case.operation.iter_parameters()]
                 matches = get_close_matches(name, possibilities)
                 if matches:
                     message += f" Did you mean `{matches[0]}`?"
@@ -223,7 +228,7 @@ def get_container(case: Case, location: str | None, name: str) -> dict[str, Any]
     if location:
         container_name = LOCATION_TO_CONTAINER[location]
     else:
-        for param in case.operation.definition.parameters:
+        for param in case.operation.iter_parameters():
             if param.name == name:
                 container_name = LOCATION_TO_CONTAINER[param.location]
                 break
@@ -248,7 +253,8 @@ def normalize_parameter(parameter: str, expression: str) -> tuple[str | None, st
 
 
 def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenAPILink], None, None]:
-    for status_code, definition in operation.definition.resolved["responses"].items():
+    for status_code, definition in operation.definition.raw["responses"].items():
+        definition = operation.schema.resolver.resolve_all(definition)  # type: ignore[attr-defined]
         for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
             yield status_code, OpenAPILink(name, status_code, link_definition, operation)
 
@@ -275,6 +281,7 @@ def _get_response_by_status_code(responses: dict[StatusCode, dict[str, Any]], st
 
 
 def add_link(
+    resolver: RefResolver,
     responses: dict[StatusCode, dict[str, Any]],
     links_field: str,
     parameters: dict[str, str] | None,
@@ -284,6 +291,8 @@ def add_link(
     name: str | None = None,
 ) -> None:
     response = _get_response_by_status_code(responses, status_code)
+    if "$ref" in response:
+        _, response = resolver.resolve(response["$ref"])
     links_definition = response.setdefault(links_field, {})
     new_link: dict[str, str | dict[str, str]] = {}
     if parameters is not None:
@@ -297,8 +306,8 @@ def add_link(
         name = name or f"{target.method.upper()} {target.path}"
         # operationId is a dict lookup which is more efficient than using `operationRef`, since it
         # doesn't involve reference resolving when we will look up for this target during testing.
-        if "operationId" in target.definition.resolved:
-            new_link["operationId"] = target.definition.resolved["operationId"]
+        if "operationId" in target.definition.raw:
+            new_link["operationId"] = target.definition.raw["operationId"]
         else:
             new_link["operationRef"] = target.operation_reference
     # The name is arbitrary, so we don't really case what it is,

schemathesis/specs/openapi/references.py

@@ -65,10 +65,13 @@ class InliningResolver(jsonschema.RefResolver):
 
     def resolve_all(self, item: JSONType, recursion_level: int = 0) -> JSONType:
         """Recursively resolve all references in the given object."""
+        resolve = self.resolve_all
         if isinstance(item, dict):
             ref = item.get("$ref")
-            if ref is not None and isinstance(ref, str):
-                with self.resolving(ref) as resolved:
+            if isinstance(ref, str):
+                url, resolved = self.resolve(ref)
+                self.push_scope(url)
+                try:
                     # If the next level of recursion exceeds the limit, then we need to copy it explicitly
                     # In other cases, this method create new objects for mutable types (dict & list)
                     next_recursion_level = recursion_level + 1
@@ -76,10 +79,18 @@ class InliningResolver(jsonschema.RefResolver):
                         copied = fast_deepcopy(resolved)
                         remove_optional_references(copied)
                         return copied
-                    return self.resolve_all(resolved, next_recursion_level)
-            return {key: self.resolve_all(sub_item, recursion_level) for key, sub_item in item.items()}
+                    return resolve(resolved, next_recursion_level)
+                finally:
+                    self.pop_scope()
+            return {
+                key: resolve(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
+                for key, sub_item in item.items()
+            }
         if isinstance(item, list):
-            return [self.resolve_all(sub_item, recursion_level) for sub_item in item]
+            return [
+                self.resolve_all(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
+                for sub_item in item
+            ]
         return item
 
     def resolve_in_scope(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any]]:
@@ -89,7 +100,7 @@ class InliningResolver(jsonschema.RefResolver):
         if "$ref" in definition:
             self.push_scope(scope)
             try:
-                new_scope, definition = fast_deepcopy(self.resolve(definition["$ref"]))
+                new_scope, definition = self.resolve(definition["$ref"])
             finally:
                 self.pop_scope()
             scopes.append(new_scope)