feat: hypothesis_graphql.nodes module to simplify working with custom scalars

Author: Stranger6667

README.rst

@@ -89,8 +89,8 @@ It is also possible to generate custom scalars. For example, ``Date``:
 
 .. code:: python
 
-    from hypothesis import strategies as st
-    import graphql
+    from hypothesis import strategies as st, given
+    from hypothesis_graphql import strategies as gql_st, nodes
 
     SCHEMA = """
     scalar Date
@@ -107,7 +107,7 @@ It is also possible to generate custom scalars. For example, ``Date``:
             custom_scalars={
                 # Standard scalars work out of the box, for custom ones you need
                 # to pass custom strategies that generate proper AST nodes
-                "Date": st.dates().map(lambda v: graphql.StringValueNode(value=str(v)))
+                "Date": st.dates().map(nodes.String)
             },
         )
     )
@@ -118,6 +118,19 @@ It is also possible to generate custom scalars. For example, ``Date``:
         #
         ...
 
+The ``hypothesis_graphql.nodes`` module includes a few helpers to generate various node types:
+
+- ``String`` -> ``graphql.StringValueNode``
+- ``Float`` -> ``graphql.FloatValueNode``
+- ``Int`` -> ``graphql.IntValueNode``
+- ``Object`` -> ``graphql.ObjectValueNode``
+- ``List`` -> ``graphql.ListValueNode``
+- ``Boolean`` -> ``graphql.BooleanValueNode``
+- ``Enum`` -> ``graphql.EnumValueNode``
+- ``Null`` -> ``graphql.NullValueNode`` (a constant, not a function)
+
+They exist because classes like ``graphql.StringValueNode`` can't be directly used in ``map`` calls due to kwarg-only arguments.
+
 .. |Build| image:: https://github.com/Stranger6667/hypothesis-graphql/workflows/build/badge.svg
    :target: https://github.com/Stranger6667/hypothesis-graphql/actions
 .. |Coverage| image:: https://codecov.io/gh/Stranger6667/hypothesis-graphql/branch/master/graph/badge.svg

docs/changelog.rst

@@ -4,6 +4,10 @@ Changelog
 `Unreleased`_ - TBD
 -------------------
 
+**Added**
+
+- ``hypothesis_graphql.nodes`` module to simplify working with custom scalars.
+
 `0.7.0`_ - 2022-04-26
 ---------------------
 

src/hypothesis_graphql/_strategies/factories.py

@@ -3,7 +3,7 @@
 Most of them exist to avoid using lambdas, which might become expensive in Hypothesis in some cases.
 """
 from functools import lru_cache
-from typing import Callable, List, Optional, Tuple, Type
+from typing import Callable, List, Optional, Tuple
 
 import graphql
 
@@ -52,44 +52,3 @@ def factory(value: graphql.ValueNode) -> graphql.ObjectFieldNode:
         return graphql.ObjectFieldNode(name=graphql.NameNode(value=name), value=value)
 
     return factory
-
-
-def object_value(fields: List[graphql.ObjectFieldNode]) -> graphql.ObjectValueNode:
-    return graphql.ObjectValueNode(fields=fields)
-
-
-def list_value(values: List[graphql.ValueNode]) -> graphql.ListValueNode:
-    return graphql.ListValueNode(values=values)
-
-
-# Boolean & Enum nodes have a limited set of variants, therefore caching is effective in this case
-
-
-@lru_cache()
-def boolean(value: bool) -> graphql.BooleanValueNode:
-    return graphql.BooleanValueNode(value=value)
-
-
-@lru_cache()
-def enum(value: str) -> graphql.EnumValueNode:
-    return graphql.EnumValueNode(value=value)
-
-
-# Other types of nodes are not that cache-efficient.
-# Constructors are passed as locals to optimize the byte code a little
-
-
-def string(
-    value: str, StringValueNode: Type[graphql.StringValueNode] = graphql.StringValueNode
-) -> graphql.StringValueNode:
-    return StringValueNode(value=value)
-
-
-def float_(
-    value: float, FloatValueNode: Type[graphql.FloatValueNode] = graphql.FloatValueNode
-) -> graphql.FloatValueNode:
-    return FloatValueNode(value=str(value))
-
-
-def int_(value: int, IntValueNode: Type[graphql.IntValueNode] = graphql.IntValueNode) -> graphql.IntValueNode:
-    return IntValueNode(value=str(value))

src/hypothesis_graphql/_strategies/primitives.py

@@ -1,26 +1,30 @@
 """Strategies for simple types like scalars or enums."""
 from functools import lru_cache
-from typing import Tuple, Union
+from typing import Tuple, Type, Union
 
 import graphql
 from hypothesis import strategies as st
 from hypothesis.errors import InvalidArgument
 
+from .. import nodes
 from ..types import ScalarValueNode
-from . import factories
 
 MIN_INT = -(2**31)
 MAX_INT = 2**31 - 1
 
 
-STRING_STRATEGY = st.text(alphabet=st.characters(blacklist_categories=("Cs",), max_codepoint=0xFFFF)).map(
-    factories.string
-)
-INTEGER_STRATEGY = st.integers(min_value=MIN_INT, max_value=MAX_INT).map(factories.int_)
-FLOAT_STRATEGY = st.floats(allow_infinity=False, allow_nan=False).map(factories.float_)
-BOOLEAN_STRATEGY = st.booleans().map(factories.boolean)
-NULL_VALUE_NODE = graphql.NullValueNode()
-NULL_STRATEGY = st.just(NULL_VALUE_NODE)
+# `String` version without extra `str` call
+def _string(
+    value: str, StringValueNode: Type[graphql.StringValueNode] = graphql.StringValueNode
+) -> graphql.StringValueNode:
+    return StringValueNode(value=value)
+
+
+STRING_STRATEGY = st.text(alphabet=st.characters(blacklist_categories=("Cs",), max_codepoint=0xFFFF)).map(_string)
+INTEGER_STRATEGY = st.integers(min_value=MIN_INT, max_value=MAX_INT).map(nodes.Int)
+FLOAT_STRATEGY = st.floats(allow_infinity=False, allow_nan=False).map(nodes.Float)
+BOOLEAN_STRATEGY = st.booleans().map(nodes.Boolean)
+NULL_STRATEGY = st.just(nodes.Null)
 
 
 @lru_cache(maxsize=16)
@@ -69,4 +73,4 @@ def maybe_null(strategy: st.SearchStrategy, nullable: bool) -> st.SearchStrategy
 
 @lru_cache(maxsize=64)
 def enum(values: Tuple[str], nullable: bool = True) -> st.SearchStrategy[graphql.EnumValueNode]:
-    return maybe_null(st.sampled_from(values).map(factories.enum), nullable)
+    return maybe_null(st.sampled_from(values).map(nodes.Enum), nullable)

src/hypothesis_graphql/_strategies/strategy.py

@@ -10,6 +10,7 @@
 from hypothesis.errors import InvalidArgument
 from hypothesis.strategies._internal.utils import cacheable
 
+from .. import nodes
 from ..types import AstPrinter, CustomScalars, Field, InputTypeNode, InterfaceOrObject, SelectionNodes
 from . import factories, primitives
 from .ast import make_mutation, make_query
@@ -80,7 +81,7 @@ def values(self, type_: graphql.GraphQLInputType) -> st.SearchStrategy[InputType
     def lists(self, type_: graphql.GraphQLList, nullable: bool = True) -> st.SearchStrategy[graphql.ListValueNode]:
         """Generate a `graphql.ListValueNode`."""
         strategy = st.lists(self.values(type_.of_type))
-        return primitives.maybe_null(strategy.map(factories.list_value), nullable)
+        return primitives.maybe_null(strategy.map(nodes.List), nullable)
 
     @instance_cache(lambda type_, nullable=True: (type_.name, nullable))
     def objects(
@@ -89,7 +90,7 @@ def objects(
         """Generate a `graphql.ObjectValueNode`."""
         fields = {name: field for name, field in type_.fields.items() if self.can_generate_field(field)}
         strategy = subset_of_fields(fields, force_required=True).flatmap(self.lists_of_object_fields)
-        return primitives.maybe_null(strategy.map(factories.object_value), nullable)
+        return primitives.maybe_null(strategy.map(nodes.Object), nullable)
 
     def can_generate_field(self, field: graphql.GraphQLInputField) -> bool:
         """Whether it is possible to generate values for the given field."""
@@ -199,11 +200,7 @@ def inner(draw: Any) -> List[graphql.ArgumentNode]:
                     if not isinstance(argument.type, graphql.GraphQLNonNull):
                         # If the type is nullable, then either generate `null` or skip it completely
                         if draw(st.booleans()):
-                            args.append(
-                                graphql.ArgumentNode(
-                                    name=graphql.NameNode(value=name), value=primitives.NULL_VALUE_NODE
-                                )
-                            )
+                            args.append(graphql.ArgumentNode(name=graphql.NameNode(value=name), value=nodes.Null))
                         continue
                     raise
                 args.append(draw(argument_strategy.map(factories.argument(name))))

src/hypothesis_graphql/nodes.py

@@ -0,0 +1,52 @@
+import typing
+from functools import lru_cache
+
+import graphql
+
+# These types are not cache-efficient.
+# Constructors are passed as locals to optimize the byte code a little
+
+
+def String(
+    value: typing.Any, StringValueNode: typing.Type[graphql.StringValueNode] = graphql.StringValueNode
+) -> graphql.StringValueNode:
+    return StringValueNode(value=str(value))
+
+
+def Float(
+    value: float, FloatValueNode: typing.Type[graphql.FloatValueNode] = graphql.FloatValueNode
+) -> graphql.FloatValueNode:
+    return FloatValueNode(value=str(value))
+
+
+def Int(value: int, IntValueNode: typing.Type[graphql.IntValueNode] = graphql.IntValueNode) -> graphql.IntValueNode:
+    return IntValueNode(value=str(value))
+
+
+def Object(
+    fields: typing.List[graphql.ObjectFieldNode],
+    ObjectValueNode: typing.Type[graphql.ObjectValueNode] = graphql.ObjectValueNode,
+) -> graphql.ObjectValueNode:
+    return ObjectValueNode(fields=fields)
+
+
+def List(
+    values: typing.List[graphql.ValueNode], ListValueNode: typing.Type[graphql.ListValueNode] = graphql.ListValueNode
+) -> graphql.ListValueNode:
+    return ListValueNode(values=values)
+
+
+# Boolean & Enum nodes have a limited set of variants, therefore caching is effective in this case
+
+
+@lru_cache()
+def Boolean(value: bool) -> graphql.BooleanValueNode:
+    return graphql.BooleanValueNode(value=value)
+
+
+@lru_cache()
+def Enum(value: str) -> graphql.EnumValueNode:
+    return graphql.EnumValueNode(value=value)
+
+
+Null = graphql.NullValueNode()

test/test_customization.py

@@ -5,6 +5,7 @@
 from hypothesis import strategies as st
 from hypothesis.errors import InvalidArgument
 
+from hypothesis_graphql import nodes
 from hypothesis_graphql import strategies as gql_st
 from hypothesis_graphql._strategies import factories
 
@@ -132,7 +133,7 @@ def test_custom_scalar_registered(data, validate_operation):
     schema = CUSTOM_SCALAR_TEMPLATE.format(query="getByDate(created: Date!): Int")
     expected = "EXAMPLE"
 
-    query = data.draw(gql_st.queries(schema, custom_scalars={"Date": st.just(expected).map(factories.string)}))
+    query = data.draw(gql_st.queries(schema, custom_scalars={"Date": st.just(expected).map(nodes.String)}))
     validate_operation(schema, query)
     assert f'getByDate(created: "{expected}")' in query