feat: Support for using default values of arguments and input fields

Ref: #71

Author: Stranger6667

docs/changelog.rst

@@ -4,6 +4,10 @@ Changelog
 `Unreleased`_ - TBD
 -------------------
 
+**Added**
+
+- Support for using default values of arguments and input fields. `#71`_
+
 **Fixed**
 
 - Duplicated inline fragments that may miss aliases. `#69`_
@@ -166,6 +170,7 @@ Invalid queries:
 .. _0.3.1: https://github.com/stranger6667/hypothesis-graphql/compare/v0.3.0...v0.3.1
 .. _0.3.0: https://github.com/stranger6667/hypothesis-graphql/compare/v0.2.0...v0.3.0
 
+.. _#71: https://github.com/Stranger6667/hypothesis-graphql/71
 .. _#69: https://github.com/Stranger6667/hypothesis-graphql/69
 .. _#57: https://github.com/Stranger6667/hypothesis-graphql/57
 .. _#51: https://github.com/Stranger6667/hypothesis-graphql/51

src/hypothesis_graphql/_strategies/primitives.py

@@ -1,6 +1,6 @@
 """Strategies for simple types like scalars or enums."""
 from functools import lru_cache
-from typing import Tuple, Type, Union
+from typing import Optional, Tuple, Type, TypeVar, Union
 
 import graphql
 from hypothesis import strategies as st
@@ -9,6 +9,7 @@
 from .. import nodes
 from ..types import ScalarValueNode
 
+T = TypeVar("T")
 MIN_INT = -(2**31)
 MAX_INT = 2**31 - 1
 
@@ -28,49 +29,86 @@ def _string(
 
 
 @lru_cache(maxsize=16)
-def scalar(type_name: str, nullable: bool = True) -> st.SearchStrategy[ScalarValueNode]:
+def scalar(
+    type_name: str, nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[ScalarValueNode]:
     if type_name == "Int":
-        return int_(nullable)
+        return int_(nullable, default)
     if type_name == "Float":
-        return float_(nullable)
+        return float_(nullable, default)
     if type_name == "String":
-        return string(nullable)
+        return string(nullable, default)
     if type_name == "ID":
-        return id_(nullable)
+        return id_(nullable, default)
     if type_name == "Boolean":
-        return boolean(nullable)
+        return boolean(nullable, default)
     raise InvalidArgument(
         f"Scalar {type_name!r} is not supported. "
         "Provide a Hypothesis strategy via the `custom_scalars` argument to generate it."
     )
 
 
-def int_(nullable: bool = True) -> st.SearchStrategy[graphql.IntValueNode]:
-    return maybe_null(INTEGER_STRATEGY, nullable)
+def int_(nullable: bool = True, default: Optional[graphql.ValueNode] = None) -> st.SearchStrategy[graphql.IntValueNode]:
+    return maybe_default(maybe_null(INTEGER_STRATEGY, nullable), default=default)
 
 
-def float_(nullable: bool = True) -> st.SearchStrategy[graphql.FloatValueNode]:
-    return maybe_null(FLOAT_STRATEGY, nullable)
+def float_(
+    nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[graphql.FloatValueNode]:
+    return maybe_default(maybe_null(FLOAT_STRATEGY, nullable), default=default)
 
 
-def string(nullable: bool = True) -> st.SearchStrategy[graphql.StringValueNode]:
-    return maybe_null(STRING_STRATEGY, nullable)
+def string(
+    nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[graphql.StringValueNode]:
+    return maybe_default(
+        maybe_null(STRING_STRATEGY, nullable),
+        default=default,
+    )
 
 
-def id_(nullable: bool = True) -> st.SearchStrategy[Union[graphql.StringValueNode, graphql.IntValueNode]]:
-    return string(nullable) | int_(nullable)
+def id_(
+    nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[Union[graphql.StringValueNode, graphql.IntValueNode]]:
+    return maybe_default(string(nullable) | int_(nullable), default=default)
 
 
-def boolean(nullable: bool = True) -> st.SearchStrategy[graphql.BooleanValueNode]:
-    return maybe_null(BOOLEAN_STRATEGY, nullable)
+def boolean(
+    nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[graphql.BooleanValueNode]:
+    return maybe_default(maybe_null(BOOLEAN_STRATEGY, nullable), default=default)
 
 
-def maybe_null(strategy: st.SearchStrategy, nullable: bool) -> st.SearchStrategy:
+def maybe_null(strategy: st.SearchStrategy[T], nullable: bool) -> st.SearchStrategy[T]:
     if nullable:
         strategy |= NULL_STRATEGY
     return strategy
 
 
+def custom(
+    strategy: st.SearchStrategy, nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy:
+    return maybe_default(maybe_null(strategy, nullable), default=default)
+
+
+def maybe_default(
+    strategy: st.SearchStrategy[T], *, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[T]:
+    if default is not None:
+        strategy |= st.just(default)
+    return strategy
+
+
 @lru_cache(maxsize=64)
-def enum(values: Tuple[str], nullable: bool = True) -> st.SearchStrategy[graphql.EnumValueNode]:
-    return maybe_null(st.sampled_from(values).map(nodes.Enum), nullable)
+def enum(
+    values: Tuple[str], nullable: bool = True, default: Optional[graphql.ValueNode] = None
+) -> st.SearchStrategy[graphql.EnumValueNode]:
+    return maybe_default(maybe_null(st.sampled_from(values).map(nodes.Enum), nullable), default=default)
+
+
+def list_(
+    strategy: st.SearchStrategy[graphql.ListValueNode],
+    nullable: bool = True,
+    default: Optional[graphql.ValueNode] = None,
+) -> st.SearchStrategy[graphql.ListValueNode]:
+    return maybe_default(maybe_null(strategy.map(nodes.List), nullable), default=default)

src/hypothesis_graphql/_strategies/strategy.py

@@ -50,7 +50,9 @@ class GraphQLStrategy:
     # This is a per-method cache without limits as they are proportionate to the schema size
     _cache: Dict[str, Dict] = attr.ib(factory=dict)
 
-    def values(self, type_: graphql.GraphQLInputType) -> st.SearchStrategy[InputTypeNode]:
+    def values(
+        self, type_: graphql.GraphQLInputType, default: Optional[graphql.ValueNode] = None
+    ) -> st.SearchStrategy[InputTypeNode]:
         """Generate value nodes of a type, that corresponds to the input type.
 
         They correspond to all `GraphQLInputType` variants:
@@ -67,23 +69,25 @@ def values(self, type_: graphql.GraphQLInputType) -> st.SearchStrategy[InputType
         if isinstance(type_, graphql.GraphQLScalarType):
             type_name = type_.name
             if type_name in self.custom_scalars:
-                return primitives.maybe_null(self.custom_scalars[type_name], nullable)
-            return primitives.scalar(type_name, nullable)
+                return primitives.custom(self.custom_scalars[type_name], nullable, default=default)
+            return primitives.scalar(type_name, nullable, default=default)
         if isinstance(type_, graphql.GraphQLEnumType):
             values = tuple(type_.values)
-            return primitives.enum(values, nullable)
+            return primitives.enum(values, nullable, default=default)
         # Types with children
         if isinstance(type_, graphql.GraphQLList):
-            return self.lists(type_, nullable)
+            return self.lists(type_, nullable, default=default)
         if isinstance(type_, graphql.GraphQLInputObjectType):
             return self.objects(type_, nullable)
         raise TypeError(f"Type {type_.__class__.__name__} is not supported.")
 
-    @instance_cache(lambda type_, nullable=True: (make_type_name(type_), nullable))
-    def lists(self, type_: graphql.GraphQLList, nullable: bool = True) -> st.SearchStrategy[graphql.ListValueNode]:
+    @instance_cache(lambda type_, nullable=True, default=None: (make_type_name(type_), nullable, default))
+    def lists(
+        self, type_: graphql.GraphQLList, nullable: bool = True, default: Optional[graphql.ValueNode] = None
+    ) -> st.SearchStrategy[graphql.ListValueNode]:
         """Generate a `graphql.ListValueNode`."""
         strategy = st.lists(self.values(type_.of_type))
-        return primitives.maybe_null(strategy.map(nodes.List), nullable)
+        return primitives.list_(strategy, nullable, default=default)
 
     @instance_cache(lambda type_, nullable=True: (type_.name, nullable))
     def objects(
@@ -113,11 +117,16 @@ def can_generate_field(self, field: graphql.GraphQLInputField) -> bool:
         )
 
     def lists_of_object_fields(
-        self, items: List[Tuple[str, Field]]
+        self, items: List[Tuple[str, graphql.GraphQLInputField]]
     ) -> st.SearchStrategy[List[graphql.ObjectFieldNode]]:
-        return st.tuples(*(self.values(field.type).map(factories.object_field(name)) for name, field in items)).map(
-            list
-        )
+        return st.tuples(
+            *(
+                self.values(field.type, field.ast_node.default_value if field.ast_node is not None else None).map(
+                    factories.object_field(name)
+                )
+                for name, field in items
+            )
+        ).map(list)
 
     @instance_cache(lambda interface, implementations: (interface.name, tuple(impl.name for impl in implementations)))
     def interfaces(
@@ -202,8 +211,9 @@ def list_of_arguments(
         def inner(draw: Any) -> List[graphql.ArgumentNode]:
             args = []
             for name, argument in arguments.items():
+                default = argument.ast_node.default_value if argument.ast_node is not None else None
                 try:
-                    argument_strategy = self.values(argument.type)
+                    argument_strategy = self.values(argument.type, default=default)
                 except InvalidArgument:
                     if not isinstance(argument.type, graphql.GraphQLNonNull):
                         # If the type is nullable, then either generate `null` or skip it completely
@@ -305,8 +315,8 @@ def add_alias(frag: graphql.InlineFragmentNode) -> graphql.InlineFragmentNode:
 
 
 def subset_of_fields(
-    fields: Dict[str, Field], *, force_required: bool = False
-) -> st.SearchStrategy[List[Tuple[str, Field]]]:
+    fields: Dict[str, graphql.GraphQLInputField], *, force_required: bool = False
+) -> st.SearchStrategy[List[Tuple[str, graphql.GraphQLInputField]]]:
     """A helper to select a subset of fields."""
     field_pairs = sorted(fields.items())
     # if we need to always generate required fields, then return them and extend with a subset of optional fields

test/test_queries.py

@@ -4,6 +4,7 @@
 from hypothesis import assume, find, given, settings
 from hypothesis import strategies as st
 
+from hypothesis_graphql import nodes
 from hypothesis_graphql import strategies as gql_st
 from hypothesis_graphql._strategies.strategy import GraphQLStrategy
 from hypothesis_graphql.cache import cached_build_schema
@@ -372,3 +373,83 @@ def test(query):
         assert query == "DocumentNode"
 
     test()
+
+
+@pytest.mark.parametrize(
+    "type_name, default",
+    (
+        ("String!", '"foo"'),
+        ("[String!]", '["foo"]'),
+        ("[String!]!", '["foo"]'),
+        ("String", "null"),
+        ("ID!", "4432841242"),
+        ("ID!", '"Foo"'),
+        ("[ID!]", '["Foo"]'),
+        ("[ID!]", '["Foo", 42]'),
+        ("Int!", "4432841"),
+        ("[Int!]", "[4432841]"),
+        ("Float!", "4432841242.123"),
+        ("[Float!]", "[4432841242.123]"),
+        ("Date!", '"2022-04-27"'),
+        ("[Date!]", '["2022-04-27"]'),
+        # These are kind of useless, but covers some code path
+        ("Boolean!", "true"),
+        ("Color", "null"),
+        ("Color!", "GREEN"),
+        ("[Color!]", "[GREEN]"),
+        ("[Color!]", "null"),
+    ),
+)
+@pytest.mark.parametrize(
+    "format_kwargs",
+    (
+        lambda x: {
+            "inner_type_name": x["type_name"],
+            "inner_default": x["default"],
+            "outer_type_name": x["type_name"],
+            "outer_default": x["default"],
+        },
+        lambda x: {
+            "inner_type_name": x["type_name"],
+            "inner_default": x["default"],
+            "outer_type_name": "InputData!",
+            "outer_default": f'{{ inner: {x["default"]} }}',
+        },
+    ),
+)
+def test_default_values(validate_operation, type_name, default, format_kwargs):
+    # When the input schema contains nodes with default values
+    schema = """
+scalar Date
+
+enum Color {{
+  RED
+  GREEN
+  BLUE
+}}
+
+input InputData {{
+  inner: {inner_type_name} = {inner_default},
+}}
+
+type Query {{
+  getValue(arg: {outer_type_name} = {outer_default}): Int!
+}}
+    """.format(
+        **format_kwargs({"type_name": type_name, "default": default})
+    )
+    strategy = gql_st.queries(schema, custom_scalars={"Date": st.just("2022-04-26").map(nodes.String)})
+    # Then these default values should be used in generated queries
+
+    all_valid = True
+
+    def validate_and_find(query):
+        nonlocal all_valid
+        try:
+            validate_operation(schema, query)
+        except AssertionError:
+            all_valid = False
+        return default in query
+
+    find(strategy, validate_and_find)
+    assert all_valid