schemathesis 3.25.5__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/generation/targets.py

@@ -0,0 +1,69 @@
+"""Support for Targeted Property-Based Testing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Sequence
+
+from schemathesis.core.registries import Registry
+from schemathesis.core.transport import Response
+from schemathesis.generation.case import Case
+
+
+@dataclass
+class TargetContext:
+    case: Case
+    response: Response
+
+    __slots__ = ("case", "response")
+
+
+TargetFunction = Callable[[TargetContext], float]
+
+TARGETS = Registry[TargetFunction]()
+target = TARGETS.register
+
+
+@target
+def response_time(ctx: TargetContext) -> float:
+    """Response time as a metric to maximize."""
+    return ctx.response.elapsed
+
+
+class TargetMetricCollector:
+    """Collect multiple observations for target metrics."""
+
+    __slots__ = ("targets", "observations")
+
+    def __init__(self, targets: list[TargetFunction] | None = None) -> None:
+        self.targets = targets or []
+        self.observations: dict[str, list[float]] = {target.__name__: [] for target in self.targets}
+
+    def reset(self) -> None:
+        """Reset all collected observations."""
+        for target in self.targets:
+            self.observations[target.__name__].clear()
+
+    def store(self, case: Case, response: Response) -> None:
+        """Calculate target metrics & store them."""
+        context = TargetContext(case=case, response=response)
+        for target in self.targets:
+            self.observations[target.__name__].append(target(context))
+
+    def maximize(self) -> None:
+        """Give feedback to the Hypothesis engine, so it maximizes the aggregated metrics."""
+        import hypothesis
+
+        for target in self.targets:
+            # Currently aggregation is just a sum
+            metric = sum(self.observations[target.__name__])
+            hypothesis.target(metric, label=target.__name__)
+
+
+def run(targets: Sequence[TargetFunction], case: Case, response: Response) -> None:
+    import hypothesis
+
+    context = TargetContext(case=case, response=response)
+    for target in targets:
+        value = target(context)
+        hypothesis.target(value, label=target.__name__)

schemathesis/graphql/__init__.py

@@ -0,0 +1,15 @@
+from schemathesis.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi
+
+from ..specs.graphql import nodes
+from ..specs.graphql.scalars import scalar
+
+__all__ = [
+    "from_url",
+    "from_asgi",
+    "from_wsgi",
+    "from_file",
+    "from_path",
+    "from_dict",
+    "nodes",
+    "scalar",
+]

schemathesis/graphql/checks.py

@@ -0,0 +1,115 @@
+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", "code", "case_id", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        type_name: str,
+        title: str = "Unexpected GraphQL Response",
+        message: str,
+        code: str = "graphql_unexpected_response",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.type_name = type_name
+        self.title = title
+        self.message = message
+        self.code = code
+        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", "code", "case_id", "_unique_key_cache", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        message: str,
+        errors: list[GraphQLFormattedError],
+        title: str = "GraphQL client error",
+        code: str = "graphql_client_error",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.errors = errors
+        self.title = title
+        self.message = message
+        self.code = code
+        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", "code", "case_id", "_unique_key_cache", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        message: str,
+        errors: list[GraphQLFormattedError],
+        title: str = "GraphQL server error",
+        code: str = "graphql_server_error",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.errors = errors
+        self.title = title
+        self.message = message
+        self.code = code
+        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

@@ -1,20 +1,23 @@
 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, DefaultDict, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
 
-from .types import GenericTest
-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 schemathesis.generation.case import Case
+    from schemathesis.schemas import APIOperation, BaseSchema
+
+HookDispatcherMark = Mark["HookDispatcher"](attr_name="hook_dispatcher")
 
 
 @unique
@@ -29,6 +32,8 @@ class RegisteredHook:
     signature: inspect.Signature
     scopes: list[HookScope]
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
 
 @dataclass
 class HookContext:
@@ -40,9 +45,57 @@ 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
+    filter_set = FilterSet()
+
+    def register(hook: str | Callable) -> Callable:
+        nonlocal filter_set
+
+        if filter_used:
+            validate_filterable_hook(hook)
+
+        if isinstance(hook, str):
+
+            def decorator(func: Callable) -> Callable:
+                hook_name = cast(str, hook)
+                if filter_used:
+                    validate_filterable_hook(hook)
+                func.filter_set = filter_set  # type: ignore[attr-defined]
+                return dispatcher.register_hook_with_name(func, hook_name)
+
+            init_filter_set(decorator)
+            return decorator
+
+        hook.filter_set = filter_set  # type: ignore[attr-defined]
+        init_filter_set(register)
+        return dispatcher.register_hook_with_name(hook, hook.__name__)
+
+    def init_filter_set(target: Callable) -> FilterSet:
+        nonlocal filter_used
+
+        filter_used = False
+        filter_set = FilterSet()
+
+        def include(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.include(*args, **kwargs)
+
+        def exclude(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.exclude(*args, **kwargs)
+
+        attach_filter_chain(target, "apply_to", include)
+        attach_filter_chain(target, "skip_for", exclude)
+        return filter_set
+
+    filter_set = init_filter_set(register)
+    return register
 
 
 @dataclass
@@ -53,9 +106,12 @@ class HookDispatcher:
     """
 
     scope: HookScope
-    _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
+    def __post_init__(self) -> None:
+        self.register = to_filterable_hook(self)  # type: ignore[method-assign]
+
     def register(self, hook: str | Callable) -> Callable:
         """Register a new hook.
 
@@ -78,26 +134,7 @@ class HookDispatcher:
             def hook(context, strategy):
                 ...
         """
-        if isinstance(hook, str):
-
-            def decorator(func: Callable) -> Callable:
-                hook_name = cast(str, hook)
-                return self.register_hook_with_name(func, hook_name)
-
-            return decorator
-        return self.register_hook_with_name(hook, hook.__name__)
-
-    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
+        raise NotImplementedError
 
     def apply(self, hook: Callable, *, name: str | None = None) -> Callable[[Callable], Callable]:
         """Register hook to run only on one test function.
@@ -122,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
@@ -130,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."""
@@ -173,31 +212,30 @@ 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:
         for hook in self.get_all_by_name(f"before_generate_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             strategy = hook(context, strategy)
         for hook in self.get_all_by_name(f"filter_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.filter(hook)
         for hook in self.get_all_by_name(f"map_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.map(hook)
         for hook in self.get_all_by_name(f"flatmap_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.flatmap(hook)
         return strategy
@@ -205,6 +243,8 @@ class HookDispatcher:
     def dispatch(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
         """Run all hooks for the given name."""
         for hook in self.get_all_by_name(name):
+            if _should_skip_hook(hook, context):
+                continue
             hook(context, *args, **kwargs)
 
     def unregister(self, hook: Callable) -> None:
@@ -224,6 +264,11 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
+def _should_skip_hook(hook: Callable, ctx: HookContext) -> bool:
+    filter_set = getattr(hook, "filter_set", None)
+    return filter_set is not None and ctx.operation is not None and not filter_set.match(ctx)
+
+
 def apply_to_all_dispatchers(
     operation: APIOperation,
     context: HookContext,
@@ -239,11 +284,13 @@ 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"):
+        raise ValueError(f"Filters are not applicable to this hook: `{name}`")
 
 
 all_scopes = HookDispatcher.register_spec(list(HookScope))
@@ -296,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."""
@@ -325,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:
@@ -343,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.
@@ -357,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",
+]