Use type hints in schema validation tests

Replicates graphql/graphql-js@0786b6b

Author: Cito

tests/type/test_validation.py

@@ -1,4 +1,5 @@
-from typing import cast
+from functools import partial
+from typing import cast, List, Union
 
 from pytest import mark, raises
 
@@ -8,15 +9,19 @@
     GraphQLEnumValue,
     GraphQLField,
     GraphQLInputField,
+    GraphQLInputType,
     GraphQLInputObjectType,
     GraphQLInterfaceType,
     GraphQLList,
+    GraphQLNamedType,
     GraphQLNonNull,
     GraphQLObjectType,
+    GraphQLOutputType,
     GraphQLScalarType,
     GraphQLSchema,
     GraphQLString,
     GraphQLUnionType,
+    GraphQLWrappingType,
     validate_schema,
     GraphQLArgument,
     GraphQLDirective,
@@ -56,7 +61,10 @@ def _get(value):
 )
 
 
-def with_modifiers(types):
+def with_modifiers(
+    types: List[GraphQLNamedType]
+) -> List[Union[GraphQLNamedType, GraphQLWrappingType]]:
+    types = cast(List[Union[GraphQLNamedType, GraphQLWrappingType]], types)
     return (
         types
         + [GraphQLList(t) for t in types]
@@ -65,7 +73,7 @@ def with_modifiers(types):
     )
 
 
-output_types = with_modifiers(
+output_types: List[GraphQLOutputType] = with_modifiers(
     [
         GraphQLString,
         SomeScalarType,
@@ -76,13 +84,19 @@ def with_modifiers(types):
     ]
 )
 
-not_output_types = with_modifiers([SomeInputObjectType])
+not_output_types: List[GraphQLInputType] = with_modifiers([SomeInputObjectType])
 
-input_types = with_modifiers(
+input_types: List[GraphQLInputType] = with_modifiers(
     [GraphQLString, SomeScalarType, SomeEnumType, SomeInputObjectType]
 )
 
-not_input_types = with_modifiers([SomeObjectType, SomeUnionType, SomeInterfaceType])
+not_input_types: List[GraphQLOutputType] = with_modifiers(
+    [SomeObjectType, SomeUnionType, SomeInterfaceType]
+)
+
+parametrize_type = partial(
+    mark.parametrize("type_", ids=lambda type_: type_.__class__.__name__)
+)
 
 
 def schema_with_field_type(type_):
@@ -763,7 +777,7 @@ def schema_with_enum(name):
 
 
 def describe_type_system_object_fields_must_have_output_types():
-    def _schema_with_object_field_of_type(field_type):
+    def _schema_with_object_field_of_type(field_type: GraphQLOutputType):
         BadObjectType = GraphQLObjectType(
             "BadObject", {"badField": GraphQLField(field_type)}
         )
@@ -772,7 +786,7 @@ def _schema_with_object_field_of_type(field_type):
             types=[SomeObjectType],
         )
 
-    @mark.parametrize("type_", output_types)
+    @parametrize_type(output_types)
     def accepts_an_output_type_as_an_object_field_type(type_):
         schema = _schema_with_object_field_of_type(type_)
         assert validate_schema(schema) == []
@@ -784,15 +798,15 @@ def rejects_an_empty_object_field_type():
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
-    @mark.parametrize("type_", not_output_types)
+    @parametrize_type(not_output_types)
     def rejects_a_non_output_type_as_an_object_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
             _schema_with_object_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
-    @mark.parametrize("type_", [int, float, str])
+    @parametrize_type([int, float, str])
     def rejects_a_non_type_value_as_an_object_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
@@ -1042,7 +1056,7 @@ def rejects_object_implementing_extended_interface_due_to_type_mismatch():
 
 
 def describe_type_system_interface_fields_must_have_output_types():
-    def _schema_with_interface_field_of_type(field_type):
+    def _schema_with_interface_field_of_type(field_type: GraphQLOutputType):
         BadInterfaceType = GraphQLInterfaceType(
             "BadInterface", {"badField": GraphQLField(field_type)}
         )
@@ -1056,7 +1070,7 @@ def _schema_with_interface_field_of_type(field_type):
             types=[BadImplementingType, SomeObjectType],
         )
 
-    @mark.parametrize("type_", output_types)
+    @parametrize_type(output_types)
     def accepts_an_output_type_as_an_interface_field_type(type_):
         schema = _schema_with_interface_field_of_type(type_)
         assert validate_schema(schema) == []
@@ -1068,15 +1082,15 @@ def rejects_an_empty_interface_field_type():
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
-    @mark.parametrize("type_", not_output_types)
+    @parametrize_type(not_output_types)
     def rejects_a_non_output_type_as_an_interface_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
             _schema_with_interface_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
-    @mark.parametrize("type_", [int, float, str])
+    @parametrize_type([int, float, str])
     def rejects_a_non_type_value_as_an_interface_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
@@ -1128,7 +1142,7 @@ def accepts_an_interface_not_implemented_by_at_least_one_object():
 
 
 def describe_type_system_field_arguments_must_have_input_types():
-    def _schema_with_arg_of_type(arg_type):
+    def _schema_with_arg_of_type(arg_type: GraphQLInputType):
         BadObjectType = GraphQLObjectType(
             "BadObject",
             {
@@ -1141,7 +1155,7 @@ def _schema_with_arg_of_type(arg_type):
             GraphQLObjectType("Query", {"f": GraphQLField(BadObjectType)})
         )
 
-    @mark.parametrize("type_", input_types)
+    @parametrize_type(input_types)
     def accepts_an_input_type_as_a_field_arg_type(type_):
         schema = _schema_with_arg_of_type(type_)
         assert validate_schema(schema) == []
@@ -1153,15 +1167,15 @@ def rejects_an_empty_field_arg_type():
         msg = str(exc_info.value)
         assert msg == "Argument type must be a GraphQL input type."
 
-    @mark.parametrize("type_", not_input_types)
+    @parametrize_type(not_input_types)
     def rejects_a_non_input_type_as_a_field_arg_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
             _schema_with_arg_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Argument type must be a GraphQL input type."
 
-    @mark.parametrize("type_", [int, float, str])
+    @parametrize_type([int, float, str])
     def rejects_a_non_type_value_as_a_field_arg_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
@@ -1191,7 +1205,7 @@ def rejects_a_non_input_type_as_a_field_arg_with_locations():
 
 
 def describe_type_system_input_object_fields_must_have_input_types():
-    def _schema_with_input_field_of_type(input_field_type):
+    def _schema_with_input_field_of_type(input_field_type: GraphQLInputType):
         BadInputObjectType = GraphQLInputObjectType(
             "BadInputObject", {"badField": GraphQLInputField(input_field_type)}
         )
@@ -1207,7 +1221,7 @@ def _schema_with_input_field_of_type(input_field_type):
             )
         )
 
-    @mark.parametrize("type_", input_types)
+    @parametrize_type(input_types)
     def accepts_an_input_type_as_an_input_fieldtype(type_):
         schema = _schema_with_input_field_of_type(type_)
         assert validate_schema(schema) == []
@@ -1219,15 +1233,15 @@ def rejects_an_empty_input_field_type():
         msg = str(exc_info.value)
         assert msg == "Input field type must be a GraphQL input type."
 
-    @mark.parametrize("type_", not_input_types)
+    @parametrize_type(not_input_types)
     def rejects_a_non_input_type_as_an_input_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
             _schema_with_input_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Input field type must be a GraphQL input type."
 
-    @mark.parametrize("type_", [int, float, str])
+    @parametrize_type([int, float, str])
     def rejects_a_non_type_value_as_an_input_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info: