Improve coverage of the entire codebase

Replicates graphql/graphql-js@4fcef75

Author: Cito

src/graphql/execution/execute.py

@@ -1048,9 +1048,9 @@ def assert_valid_execution_arguments(
     # Variables, if provided, must be a dictionary.
     if not (raw_variable_values is None or isinstance(raw_variable_values, dict)):
         raise TypeError(
-            "Variables must be provided as a dictionary where each property is a"
-            " variable value. Perhaps look to see if an unparsed JSON string was"
-            " provided."
+            "Variable values must be provided as a dictionary"
+            " with variable names as keys. Perhaps look to see"
+            " if an unparsed JSON string was provided."
         )
 
 

src/graphql/language/visitor.py

@@ -3,6 +3,7 @@
     Any,
     Callable,
     Collection,
+    Dict,
     List,
     NamedTuple,
     Optional,
@@ -23,6 +24,7 @@
     "SKIP",
     "REMOVE",
     "IDLE",
+    "QUERY_DOCUMENT_KEYS",
 ]
 
 
@@ -32,7 +34,7 @@
 BREAK, SKIP, REMOVE, IDLE = True, False, Ellipsis, None
 
 # Default map from visitor kinds to their traversable node attributes:
-QUERY_DOCUMENT_KEYS = {
+QUERY_DOCUMENT_KEYS: Dict[str, Tuple[str, ...]] = {
     "name": (),
     "document": ("definitions",),
     "operation_definition": (

tests/execution/test_abstract.py

@@ -372,6 +372,42 @@ def returning_invalid_value_from_resolve_type_yields_useful_error():
             ],
         )
 
+    def missing_both_resolve_type_and_is_type_of_yields_useful_error():
+        foo_interface = GraphQLInterfaceType(
+            "FooInterface", {"bar": GraphQLField(GraphQLString)}
+        )
+
+        foo_object = GraphQLObjectType(
+            "FooObject",
+            {"bar": GraphQLField(GraphQLString)},
+            interfaces=[foo_interface],
+        )
+
+        schema = GraphQLSchema(
+            GraphQLObjectType(
+                "Query",
+                {"foo": GraphQLField(foo_interface, resolve=lambda *_args: "dummy")},
+            ),
+            types=[foo_object],
+        )
+
+        result = graphql_sync(schema, "{ foo { bar } }")
+
+        assert result == (
+            {"foo": None},
+            [
+                {
+                    "message": "Abstract type 'FooInterface' must resolve to an"
+                    " Object type at runtime for field 'Query.foo' with value 'dummy',"
+                    " received 'None'. Either the 'FooInterface' type should provide"
+                    " a 'resolve_type' function or each possible type"
+                    " should provide an 'is_type_of' function.",
+                    "locations": [(1, 3)],
+                    "path": ["foo"],
+                }
+            ],
+        )
+
     def resolve_type_allows_resolving_with_type_name():
         PetType = GraphQLInterfaceType(
             "Pet",

tests/execution/test_executor.py

@@ -24,7 +24,6 @@
 
 
 def describe_execute_handles_basic_execution_tasks():
-
     # noinspection PyTypeChecker
     def throws_if_no_document_is_provided():
         schema = GraphQLSchema(
@@ -45,6 +44,39 @@ def throws_if_no_schema_is_provided():
 
         assert str(exc_info.value) == "Expected None to be a GraphQL schema."
 
+    def throws_on_invalid_variables():
+        schema = GraphQLSchema(
+            GraphQLObjectType(
+                "Type",
+                {
+                    "fieldA": GraphQLField(
+                        GraphQLString, args={"argA": GraphQLArgument(GraphQLInt)}
+                    )
+                },
+            )
+        )
+        document = parse(
+            """
+            query ($a: Int) {
+              fieldA(argA: $a)
+            }
+            """
+        )
+        variable_values = "{'a': 1}"
+
+        with raises(TypeError) as exc_info:
+            assert execute(
+                schema=schema,
+                document=document,
+                variable_values=variable_values,  # type: ignore
+            )
+
+        assert str(exc_info.value) == (
+            "Variable values must be provided as a dictionary"
+            " with variable names as keys. Perhaps look to see"
+            " if an unparsed JSON string was provided."
+        )
+
     def accepts_positional_arguments():
         schema = GraphQLSchema(
             GraphQLObjectType(
@@ -59,7 +91,6 @@ def accepts_positional_arguments():
 
     @mark.asyncio
     async def executes_arbitrary_code():
-
         # noinspection PyMethodMayBeStatic,PyMethodMayBeStatic
         class Data:
             def a(self, _info):
@@ -80,7 +111,7 @@ def e(self, _info):
             f = "Fish"
 
             # Called only by DataType::pic static resolver
-            def pic(self, _info, size=50):
+            def pic(self, _info, size):
                 return f"Pic of size: {size}"
 
             def deep(self, _info):
@@ -766,6 +797,17 @@ class Data:
 
         assert result == ({"a": "b"}, None)
 
+    def ignores_missing_sub_selections_on_fields():
+        some_type = GraphQLObjectType("SomeType", {"b": GraphQLField(GraphQLString)})
+        schema = GraphQLSchema(
+            GraphQLObjectType("Query", {"a": GraphQLField(some_type)})
+        )
+        document = parse("{ a }")
+        root_value = {"a": {"b": "c"}}
+
+        result = execute(schema, document, root_value)
+        assert result == ({"a": {}}, None)
+
     def does_not_include_illegal_fields_in_output():
         schema = GraphQLSchema(
             GraphQLObjectType("Q", {"a": GraphQLField(GraphQLString)})
@@ -804,7 +846,8 @@ def does_not_include_arguments_that_were_not_set():
             None,
         )
 
-    def fails_when_an_is_type_of_check_is_not_met():
+    @mark.asyncio
+    async def fails_when_is_type_of_check_is_not_met():
         class Special:
             value: str
 
@@ -817,10 +860,20 @@ class NotSpecial:
             def __init__(self, value):
                 self.value = value
 
+        def is_type_of_special(obj, _info):
+            is_special = isinstance(obj, Special)
+            if not _info.context["async"]:
+                return is_special
+
+            async def async_is_special():
+                return is_special
+
+            return async_is_special()
+
         SpecialType = GraphQLObjectType(
             "SpecialType",
             {"value": GraphQLField(GraphQLString)},
-            is_type_of=lambda obj, _info: isinstance(obj, Special),
+            is_type_of=is_type_of_special,
         )
 
         schema = GraphQLSchema(
@@ -832,7 +885,8 @@ def __init__(self, value):
         document = parse("{ specials { value } }")
         root_value = {"specials": [Special("foo"), NotSpecial("bar")]}
 
-        result = execute(schema, document, root_value)
+        result = execute(schema, document, root_value, {"async": False})
+        assert not isinstance(result, Awaitable)
         assert result == (
             {"specials": [{"value": "foo"}, None]},
             [
@@ -845,6 +899,11 @@ def __init__(self, value):
             ],
         )
 
+        async_result = execute(schema, document, root_value, {"async": True})
+        assert isinstance(async_result, Awaitable)
+        awaited_result = await async_result
+        assert awaited_result == result
+
     def executes_ignoring_invalid_non_executable_definitions():
         schema = GraphQLSchema(
             GraphQLObjectType("Query", {"foo": GraphQLField(GraphQLString)})

tests/execution/test_mutations.py

@@ -133,6 +133,12 @@ async def evaluates_mutations_serially():
             None,
         )
 
+    def does_not_include_illegal_mutation_fields_in_output():
+        document = parse("mutation { thisIsIllegalDoNotIncludeMe }")
+
+        result = execute(schema=schema, document=document)
+        assert result == ({}, None)
+
     @mark.asyncio
     async def evaluates_mutations_correctly_in_presence_of_a_failed_mutation():
         document = parse(

tests/execution/test_nonnull.py

@@ -540,8 +540,8 @@ def describe_handles_non_null_argument():
 
         # noinspection PyPep8Naming
         def _resolve(_obj, _info, cannotBeNull):
-            if isinstance(cannotBeNull, str):
-                return f"Passed: {cannotBeNull}"
+            assert isinstance(cannotBeNull, str)
+            return f"Passed: {cannotBeNull}"
 
         schema_with_non_null_arg = GraphQLSchema(
             GraphQLObjectType(

tests/execution/test_union_interface.py

@@ -375,6 +375,42 @@ def executes_interface_types_with_inline_fragment():
             None,
         )
 
+    def executes_interface_types_with_named_fragments():
+        document = parse(
+            """
+            {
+              __typename
+              name
+              friends {
+                __typename
+                name
+                ...DogBarks
+                ...CatMeows
+              }
+            }
+
+            fragment  DogBarks on Dog {
+              barks
+            }
+
+            fragment  CatMeows on Cat {
+              meows
+            }
+            """
+        )
+
+        assert execute(schema=schema, document=document, root_value=john) == (
+            {
+                "__typename": "Person",
+                "name": "John",
+                "friends": [
+                    {"__typename": "Person", "name": "Liz"},
+                    {"__typename": "Dog", "name": "Odie", "barks": True},
+                ],
+            },
+            None,
+        )
+
     def allows_fragment_conditions_to_be_abstract_types():
         document = parse(
             """

tests/execution/test_variables.py

@@ -20,15 +20,16 @@
     GraphQLString,
 )
 
+
+def parse_serialized_value(value: str) -> str:
+    assert value == "SerializedValue"
+    return "DeserializedValue"
+
+
 TestComplexScalar = GraphQLScalarType(
     name="ComplexScalar",
-    serialize=lambda value: "SerializedValue" if value == "DeserializedValue" else None,
-    parse_value=lambda value: "DeserializedValue"
-    if value == "SerializedValue"
-    else None,
-    parse_literal=lambda ast, _variables=None: "DeserializedValue"
-    if ast.value == "SerializedValue"
-    else None,
+    parse_value=lambda value: parse_serialized_value(value),
+    parse_literal=lambda ast, _variables=None: parse_serialized_value(ast.value),
 )
 
 

tests/fixtures/schema_kitchen_sink.graphql

@@ -135,6 +135,7 @@ extend input InputType @onInputObject
 This is a description of the `@skip` directive
 """
 directive @skip(
+  """This is a description of the `if` argument"""
   if: Boolean! @onArgumentDefinition
 ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT