Tests: Improve type coverage

Replicates graphql/graphql-js@e45fb12

Author: Cito

tests/execution/test_directives.py

@@ -1,7 +1,7 @@
-from graphql import GraphQLSchema
-from graphql.execution import execute
+from graphql.execution import execute, ExecutionResult
 from graphql.language import parse
-from graphql.type import GraphQLObjectType, GraphQLField, GraphQLString
+from graphql.pyutils import AwaitableOrValue
+from graphql.type import GraphQLObjectType, GraphQLField, GraphQLSchema, GraphQLString
 
 schema = GraphQLSchema(
     GraphQLObjectType(
@@ -19,7 +19,7 @@ def b(self, *_args):
         return "b"
 
 
-def execute_test_query(query):
+def execute_test_query(query: str) -> AwaitableOrValue[ExecutionResult]:
     document = parse(query)
     return execute(schema, document, RootValue())
 

tests/execution/test_executor.py

@@ -112,7 +112,7 @@ def e(self, _info):
             f = "Fish"
 
             # Called only by DataType::pic static resolver
-            def pic(self, _info, size):
+            def pic(self, _info, size: int):
                 return f"Pic of size: {size}"
 
             def deep(self, _info):

tests/execution/test_lists.py

@@ -1,5 +1,6 @@
 from collections import namedtuple
 from gc import collect
+from typing import Any
 
 from pytest import mark  # type: ignore
 
@@ -10,6 +11,7 @@
     GraphQLList,
     GraphQLNonNull,
     GraphQLObjectType,
+    GraphQLOutputType,
     GraphQLSchema,
     GraphQLString,
 )
@@ -44,18 +46,20 @@ def get_response(test_type, test_data):
     )
 
 
-def check_response(response, expected):
+def check_response(response: Any, expected: Any) -> None:
     if not response.errors:
         response = response.data
     assert response == expected
 
 
-def check(test_type, test_data, expected):
+def check(test_type: GraphQLOutputType, test_data: Any, expected: Any) -> None:
 
     check_response(get_response(test_type, test_data), expected)
 
 
-async def check_async(test_type, test_data, expected):
+async def check_async(
+    test_type: GraphQLOutputType, test_data: Any, expected: Any
+) -> None:
     check_response(await get_response(test_type, test_data), expected)
 
     # Note: When Array values are rejected asynchronously,

tests/execution/test_nonnull.py

@@ -1,10 +1,12 @@
 import re
 from inspect import isawaitable
+from typing import Any, Awaitable, cast
 
 from pytest import mark  # type: ignore
 
-from graphql.execution import execute
+from graphql.execution import execute, ExecutionResult
 from graphql.language import parse
+from graphql.pyutils import AwaitableOrValue
 from graphql.type import (
     GraphQLArgument,
     GraphQLField,
@@ -95,22 +97,25 @@ async def promiseNonNullNest(self, _info):
 )
 
 
-def execute_query(query, root_value):
+def execute_query(query: str, root_value: Any) -> AwaitableOrValue[ExecutionResult]:
     return execute(schema=schema, document=parse(query), root_value=root_value)
 
 
 # avoids also doing any nests
-def patch(data):
+def patch(data: str) -> str:
     return re.sub(
         r"\bsyncNonNull\b", "promiseNonNull", re.sub(r"\bsync\b", "promise", data)
     )
 
 
-async def execute_sync_and_async(query, root_value):
+async def execute_sync_and_async(query: str, root_value: Any) -> ExecutionResult:
     sync_result = execute_query(query, root_value)
     if isawaitable(sync_result):
-        sync_result = await sync_result
-    async_result = await execute_query(patch(query), root_value)
+        sync_result = await cast(Awaitable[ExecutionResult], sync_result)
+    sync_result = cast(ExecutionResult, sync_result)
+    async_result = await cast(
+        Awaitable[ExecutionResult], execute_query(patch(query), root_value)
+    )
 
     assert repr(async_result) == patch(repr(sync_result))
     return sync_result
@@ -254,12 +259,16 @@ def describe_nulls_a_complex_tree_of_nullable_fields_each():
 
         @mark.asyncio
         async def returns_null():
-            result = await execute_query(query, NullingData())
+            result = await cast(
+                Awaitable[ExecutionResult], execute_query(query, NullingData())
+            )
             assert result == (data, None)
 
         @mark.asyncio
         async def throws():
-            result = await execute_query(query, ThrowingData())
+            result = await cast(
+                Awaitable[ExecutionResult], execute_query(query, ThrowingData())
+            )
             assert result == (
                 data,
                 [
@@ -384,7 +393,9 @@ def describe_nulls_first_nullable_after_long_chain_of_non_null_fields():
 
         @mark.asyncio
         async def returns_null():
-            result = await execute_query(query, NullingData())
+            result = await cast(
+                Awaitable[ExecutionResult], execute_query(query, NullingData())
+            )
             assert result == (
                 data,
                 [
@@ -445,7 +456,9 @@ async def returns_null():
 
         @mark.asyncio
         async def throws():
-            result = await execute_query(query, ThrowingData())
+            result = await cast(
+                Awaitable[ExecutionResult], execute_query(query, ThrowingData())
+            )
             assert result == (
                 data,
                 [

tests/execution/test_resolve.py

@@ -1,7 +1,9 @@
 from collections import ChainMap
+from typing import Any, Optional
 
 from graphql import graphql_sync
 from graphql.error import GraphQLError
+from graphql.execution import ExecutionResult
 from graphql.language import SourceLocation
 from graphql.type import (
     GraphQLArgument,
@@ -16,7 +18,7 @@
 
 
 def describe_execute_resolve_function():
-    def _test_schema(test_field):
+    def _test_schema(test_field: GraphQLField) -> GraphQLSchema:
         return GraphQLSchema(GraphQLObjectType("Query", {"test": test_field}))
 
     def default_function_accesses_attributes():
@@ -68,7 +70,7 @@ class Adder:
             def __init__(self, num):
                 self._num = num
 
-            def test(self, info, addend1):
+            def test(self, info, addend1: int):
                 return self._num + addend1 + info.context.addend2
 
         root_value = Adder(700)
@@ -137,7 +139,7 @@ def transforms_arguments_using_out_names():
             )
         )
 
-        def execute(source, root_value=None):
+        def execute(source: str, root_value: Optional[Any] = None) -> ExecutionResult:
             return graphql_sync(schema=schema, source=source, root_value=root_value)
 
         assert execute("{ test }") == ({"test": "[None, {}]"}, None)

tests/execution/test_schema.py

@@ -19,7 +19,7 @@ def executes_using_a_schema():
         class Article:
 
             # noinspection PyShadowingBuiltins
-            def __init__(self, id):
+            def __init__(self, id: int):
                 self.id = id
                 self.isPublished = True
                 self.author = JohnSmith()
@@ -77,7 +77,7 @@ def __init__(self, id):
                 "article": GraphQLField(
                     BlogArticle,
                     args={"id": GraphQLArgument(GraphQLID)},
-                    resolve=lambda obj, info, id: Article(id),
+                    resolve=lambda _obj, _info, id: Article(id),
                 ),
                 "feed": GraphQLField(
                     GraphQLList(BlogArticle),
@@ -90,19 +90,19 @@ def __init__(self, id):
 
         # noinspection PyPep8Naming,PyMethodMayBeStatic
         class Author:
-            def pic(self, info_, width, height):
+            def pic(self, info_, width: int, height: int) -> "Pic":
                 return Pic(123, width, height)
 
             @property
-            def recentArticle(self):
+            def recentArticle(self) -> Article:
                 return Article(1)
 
         class JohnSmith(Author):
             id = 123
             name = "John Smith"
 
         class Pic:
-            def __init__(self, uid, width, height):
+            def __init__(self, uid: int, width: int, height: int):
                 self.url = f"cdn://{uid}"
                 self.width = f"{width}"
                 self.height = f"{height}"

tests/star_wars_data.py

@@ -5,7 +5,7 @@
 demo.
 """
 
-from typing import Awaitable, Collection, Iterator
+from typing import Awaitable, Collection, Dict, Iterator, Optional
 
 __all__ = ["get_droid", "get_friends", "get_hero", "get_human", "get_secret_backstory"]
 
@@ -80,7 +80,13 @@ def __init__(self, id, name, friends, appearsIn, primaryFunction):
     id="1004", name="Wilhuff Tarkin", friends=["1001"], appearsIn=[4], homePlanet=None
 )
 
-human_data = {"1000": luke, "1001": vader, "1002": han, "1003": leia, "1004": tarkin}
+human_data: Dict[str, Human] = {
+    "1000": luke,
+    "1001": vader,
+    "1002": han,
+    "1003": leia,
+    "1004": tarkin,
+}
 
 threepio = Droid(
     id="2000",
@@ -98,17 +104,17 @@ def __init__(self, id, name, friends, appearsIn, primaryFunction):
     primaryFunction="Astromech",
 )
 
-droid_data = {"2000": threepio, "2001": artoo}
+droid_data: Dict[str, Droid] = {"2000": threepio, "2001": artoo}
 
 
 # noinspection PyShadowingBuiltins
-async def get_character(id: str) -> Character:
+async def get_character(id: str) -> Optional[Character]:
     """Helper function to get a character by ID."""
     # We use an async function just to illustrate that GraphQL-core supports it.
-    return human_data.get(id) or droid_data.get(id)  # type: ignore
+    return human_data.get(id) or droid_data.get(id)
 
 
-def get_friends(character: Character) -> Iterator[Awaitable[Character]]:
+def get_friends(character: Character) -> Iterator[Awaitable[Optional[Character]]]:
     """Allows us to query for a character's friends."""
     # Notice that GraphQL-core accepts iterators of awaitables.
     return map(get_character, character.friends)
@@ -124,15 +130,15 @@ def get_hero(episode: int) -> Character:
 
 
 # noinspection PyShadowingBuiltins
-def get_human(id: str) -> Human:
+def get_human(id: str) -> Optional[Human]:
     """Allows us to query for the human with the given id."""
-    return human_data.get(id)  # type: ignore
+    return human_data.get(id)
 
 
 # noinspection PyShadowingBuiltins
-def get_droid(id: str) -> Droid:
+def get_droid(id: str) -> Optional[Droid]:
     """Allows us to query for the droid with the given id."""
-    return droid_data.get(id)  # type: ignore
+    return droid_data.get(id)
 
 
 # noinspection PyUnusedLocal

tests/test_star_wars_introspection.py

@@ -1,9 +1,11 @@
+from typing import Any
+
 from graphql import graphql_sync
 
 from .star_wars_schema import star_wars_schema
 
 
-def query_star_wars(source):
+def query_star_wars(source: str) -> Any:
     result = graphql_sync(star_wars_schema, source)
     assert result.errors is None
     return result.data

tests/test_star_wars_validation.py

@@ -1,10 +1,13 @@
+from typing import List
+
+from graphql.error import GraphQLError
 from graphql.language import parse, Source
 from graphql.validation import validate
 
 from .star_wars_schema import star_wars_schema
 
 
-def validation_errors(query):
+def validation_errors(query: str) -> List[GraphQLError]:
     """Helper function to test a query and the expected response."""
     source = Source(query, "StarWars.graphql")
     ast = parse(source)