schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/graphql/__init__.py

@@ -1 +0,0 @@
-from .loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi

schemathesis/specs/graphql/nodes.py

@@ -1,3 +1,27 @@
-# pylint: disable=unused-import
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from graphql import ValueNode
+
 # Re-export `hypothesis_graphql` helpers
-from hypothesis_graphql.nodes import Boolean, Enum, Float, Int, List, Null, Object, String
+
+__all__ = [  # noqa: F822
+    "Boolean",
+    "Enum",
+    "Float",
+    "Int",
+    "List",
+    "Null",
+    "Object",
+    "String",
+]
+
+
+def __getattr__(name: str) -> ValueNode | None:
+    if name in __all__:
+        import hypothesis_graphql.nodes
+
+        return getattr(hypothesis_graphql.nodes, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

schemathesis/specs/graphql/scalars.py

@@ -1,21 +1,86 @@
-from typing import Dict
+from __future__ import annotations
 
-import graphql
-from hypothesis import strategies as st
+from functools import lru_cache
+from typing import TYPE_CHECKING
 
-from ...exceptions import UsageError
+from schemathesis.core.errors import IncorrectUsage
 
-CUSTOM_SCALARS: Dict[str, st.SearchStrategy[graphql.ValueNode]] = {}
+if TYPE_CHECKING:
+    import graphql
+    from hypothesis import strategies as st
 
+CUSTOM_SCALARS: dict[str, st.SearchStrategy[graphql.ValueNode]] = {}
 
-def register_scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
-    """Register a new strategy for generating custom scalars.
 
-    :param str name: Scalar name. It should correspond the one used in the schema.
-    :param strategy: Hypothesis strategy you'd like to use to generate values for this scalar.
+def scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
+    r"""Register a custom Hypothesis strategy for generating GraphQL scalar values.
+
+    Args:
+        name: Scalar name that matches your GraphQL schema scalar definition
+        strategy: Hypothesis strategy that generates GraphQL AST ValueNode objects
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+        from schemathesis.graphql import nodes
+
+        # Register email scalar
+        schemathesis.graphql.scalar("Email", st.emails().map(nodes.String))
+
+        # Register positive integer scalar
+        schemathesis.graphql.scalar(
+            "PositiveInt",
+            st.integers(min_value=1).map(nodes.Int)
+        )
+
+        # Register phone number scalar
+        schemathesis.graphql.scalar(
+            "Phone",
+            st.from_regex(r"\+1-\d{3}-\d{3}-\d{4}").map(nodes.String)
+        )
+        ```
+
+    Schema usage:
+        ```graphql
+        scalar Email
+        scalar PositiveInt
+
+        type Query {
+          getUser(email: Email!, rating: PositiveInt!): User
+        }
+        ```
+
     """
+    from hypothesis.strategies import SearchStrategy
+
     if not isinstance(name, str):
-        raise UsageError(f"Scalar name {name!r} must be a string")
-    if not isinstance(strategy, st.SearchStrategy):
-        raise UsageError(f"{strategy!r} must be a Hypothesis strategy which generates AST nodes matching this scalar")
+        raise IncorrectUsage(f"Scalar name {name!r} must be a string")
+    if not isinstance(strategy, SearchStrategy):
+        raise IncorrectUsage(
+            f"{strategy!r} must be a Hypothesis strategy which generates AST nodes matching this scalar"
+        )
     CUSTOM_SCALARS[name] = strategy
+
+
+@lru_cache
+def get_extra_scalar_strategies() -> dict[str, st.SearchStrategy]:
+    """Get all extra GraphQL strategies."""
+    from hypothesis import strategies as st
+
+    from . import nodes
+
+    dates = st.dates().map(str)
+    times = st.times().map("%sZ".__mod__)
+
+    return {
+        "Date": dates.map(nodes.String),
+        "Time": times.map(nodes.String),
+        "DateTime": st.tuples(dates, times).map("T".join).map(nodes.String),
+        "IP": st.ip_addresses().map(str).map(nodes.String),
+        "IPv4": st.ip_addresses(v=4).map(str).map(nodes.String),
+        "IPv6": st.ip_addresses(v=6).map(str).map(nodes.String),
+        "BigInt": st.integers().map(nodes.Int),
+        "Long": st.integers(min_value=-(2**63), max_value=2**63 - 1).map(nodes.Int),
+        "UUID": st.uuids().map(str).map(nodes.String),
+    }