Improve coverage in type package

Author: Cito

Diff for: src/graphql/pyutils/inspect.py

@@ -120,10 +120,21 @@ def inspect_recursive(value: Any, seen_values: List) -> str:
         type_ = "generator"
     else:
         # stringify (only) the well-known GraphQL types
-        from ..type import GraphQLNamedType, GraphQLScalarType, GraphQLWrappingType
+        from ..type import (
+            GraphQLDirective,
+            GraphQLNamedType,
+            GraphQLScalarType,
+            GraphQLWrappingType,
+        )
 
         if isinstance(
-            value, (GraphQLNamedType, GraphQLScalarType, GraphQLWrappingType)
+            value,
+            (
+                GraphQLDirective,
+                GraphQLNamedType,
+                GraphQLScalarType,
+                GraphQLWrappingType,
+            ),
         ):
             return str(value)
         try:

Diff for: src/graphql/type/scalars.py

@@ -47,10 +47,7 @@ def serialize_int(output_value: Any) -> int:
             output_value = ""
             raise ValueError
         else:
-            num = int(output_value)
-            float_value = float(output_value)
-            if num != float_value:
-                raise ValueError
+            num = int(output_value)  # raises ValueError if not an integer
     except (OverflowError, ValueError, TypeError):
         raise GraphQLError(
             "Int cannot represent non-integer value: " + inspect(output_value)
@@ -245,11 +242,11 @@ def serialize_id(output_value: Any) -> str:
 
 
 def coerce_id(input_value: Any) -> str:
-    if not isinstance(input_value, str) and not is_integer(input_value):
-        raise GraphQLError("ID cannot represent value: " + inspect(input_value))
-    if isinstance(input_value, float):
-        input_value = int(input_value)
-    return str(input_value)
+    if isinstance(input_value, str):
+        return input_value
+    if is_integer(input_value):
+        return str(input_value)
+    raise GraphQLError("ID cannot represent value: " + inspect(input_value))
 
 
 def parse_id_literal(value_node, _variables=None) -> str:

Diff for: src/graphql/type/validate.py

@@ -171,7 +171,7 @@ def validate_name(self, node: Any, name: Optional[str] = None) -> None:
                 name = node.name
             name = cast(str, name)
             ast_node = node.ast_node
-        except AttributeError:
+        except AttributeError:  # pragma: no cover
             pass
         else:
             error = is_valid_name_error(name, ast_node)
@@ -185,8 +185,8 @@ def validate_types(self) -> None:
             # Ensure all provided types are in fact GraphQL type.
             if not is_named_type(type_):
                 self.report_error(
-                    f"Expected GraphQL named type but got: {inspect(type)}.",
-                    type_.ast_node if type_ else None,
+                    f"Expected GraphQL named type but got: {inspect(type_)}.",
+                    type_.ast_node if is_named_type(type_) else None,
                 )
                 continue
 
@@ -543,7 +543,7 @@ def get_all_sub_nodes(
     result: List[Node] = []
     for ast_node in get_all_nodes(obj):
         sub_nodes = getter(ast_node)
-        if sub_nodes:
+        if sub_nodes:  # pragma: no cover
             result.extend(sub_nodes)
     return result
 

Diff for: tests/pyutils/test_inspect.py

@@ -7,6 +7,7 @@
 
 from graphql.pyutils import inspect, Undefined
 from graphql.type import (
+    GraphQLDirective,
     GraphQLField,
     GraphQLInt,
     GraphQLList,
@@ -328,6 +329,8 @@ def inspect_graphql_types():
             "TestObjectType", {"test": GraphQLField(GraphQLString)}
         )
         assert inspect(test_object_type) == "TestObjectType"
+        test_directive = GraphQLDirective("TestDirective", [])
+        assert inspect(test_directive) == "@TestDirective"
 
     def custom_inspect():
         class TestClass:

Diff for: tests/type/test_schema.py

@@ -1,7 +1,13 @@
 from pytest import raises  # type: ignore
 
-from graphql.language import DirectiveLocation, TypeDefinitionNode, TypeExtensionNode
-from graphql.pyutils import dedent
+from graphql.language import (
+    DirectiveLocation,
+    SchemaDefinitionNode,
+    SchemaExtensionNode,
+    TypeDefinitionNode,
+    TypeExtensionNode,
+)
+from graphql.pyutils import dedent, FrozenList
 from graphql.type import (
     GraphQLArgument,
     GraphQLBoolean,
@@ -312,6 +318,26 @@ def configures_the_schema_to_have_no_errors():
                 assert GraphQLSchema(assume_valid=True).validation_errors == []
 
     def describe_ast_nodes():
+        def accepts_a_scalar_type_with_ast_node_and_extension_ast_nodes():
+            ast_node = SchemaDefinitionNode()
+            extension_ast_nodes = [SchemaExtensionNode()]
+            schema = GraphQLSchema(
+                GraphQLObjectType("Query", {}),
+                ast_node=ast_node,
+                extension_ast_nodes=extension_ast_nodes,
+            )
+            assert schema.ast_node is ast_node
+            assert isinstance(schema.extension_ast_nodes, FrozenList)
+            assert schema.extension_ast_nodes == extension_ast_nodes
+            extension_ast_nodes = schema.extension_ast_nodes
+            schema = GraphQLSchema(
+                GraphQLObjectType("Query", {}),
+                ast_node=None,
+                extension_ast_nodes=extension_ast_nodes,
+            )
+            assert schema.ast_node is None
+            assert schema.extension_ast_nodes is extension_ast_nodes
+
         def rejects_a_schema_with_an_incorrect_ast_node():
             with raises(TypeError) as exc_info:
                 # noinspection PyTypeChecker

Diff for: tests/type/test_validation.py

@@ -54,6 +54,8 @@
     fields={"val": GraphQLInputField(GraphQLString, default_value="hello")},
 )
 
+SomeDirective = GraphQLDirective("SomeDirective", [DirectiveLocation.QUERY])
+
 
 def with_modifiers(
     types: List[GraphQLNamedType],
@@ -392,22 +394,51 @@ def rejects_a_schema_extended_with_invalid_root_types():
             },
         ]
 
+    def rejects_a_schema_whose_types_are_incorrectly_type():
+        # invalid schema cannot be built with Python
+        with raises(TypeError) as exc_info:
+            # noinspection PyTypeChecker
+            GraphQLSchema(
+                SomeObjectType,
+                types=[{"name": "SomeType"}, SomeDirective],  # type: ignore
+            )
+        assert str(exc_info.value) == (
+            "Schema types must be specified"
+            " as a collection of GraphQLNamedType instances."
+        )
+        # construct invalid schema manually
+        schema = GraphQLSchema(SomeObjectType)
+        schema.type_map = {
+            "SomeType": {"name": "SomeType"},  # type: ignore
+            "SomeDirective": SomeDirective,  # type: ignore
+        }
+        assert validate_schema(schema) == [
+            {"message": "Expected GraphQL named type but got: {'name': 'SomeType'}."},
+            {"message": "Expected GraphQL named type but got: @SomeDirective."},
+        ]
+
     def rejects_a_schema_whose_directives_are_incorrectly_typed():
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
+            # noinspection PyTypeChecker
             GraphQLSchema(
-                SomeObjectType, directives=[cast(GraphQLDirective, "SomeDirective")]
+                SomeObjectType,
+                directives=[None, "SomeDirective", SomeScalarType],  # type: ignore
             )
         assert str(exc_info.value) == (
             "Schema directives must be specified"
             " as a collection of GraphQLDirective instances."
         )
-
+        # construct invalid schema manually
         schema = GraphQLSchema(SomeObjectType)
-        schema.directives = FrozenList([cast(GraphQLDirective, "SomeDirective")])
-
-        msg = validate_schema(schema)[0].message
-        assert msg == "Expected directive but got: 'SomeDirective'."
+        schema.directives = FrozenList(
+            [None, "SomeDirective", SomeScalarType]  # type: ignore
+        )
+        assert validate_schema(schema) == [
+            {"message": "Expected directive but got: None."},
+            {"message": "Expected directive but got: 'SomeDirective'."},
+            {"message": "Expected directive but got: SomeScalar."},
+        ]
 
 
 def describe_type_system_objects_must_have_fields():
@@ -532,6 +563,7 @@ def rejects_a_union_type_with_empty_types():
             union BadUnion
             """
         )
+
         schema = extend_schema(
             schema,
             parse(
@@ -542,10 +574,10 @@ def rejects_a_union_type_with_empty_types():
                 """
             ),
         )
+
         assert validate_schema(schema) == [
             {
-                "message": "Union type BadUnion must define one or more"
-                " member types.",
+                "message": "Union type BadUnion must define one or more member types.",
                 "locations": [(6, 13), (4, 17)],
             }
         ]
@@ -931,12 +963,12 @@ def rejects_with_relevant_locations_for_a_non_output_type():
 
 def describe_type_system_objects_can_only_implement_unique_interfaces():
     def rejects_an_object_implementing_a_non_type_values():
-        schema = GraphQLSchema(
-            query=GraphQLObjectType(
-                "BadObject", {"f": GraphQLField(GraphQLString)}, interfaces=[]
-            )
+        query_type = GraphQLObjectType(
+            "BadObject", {"f": GraphQLField(GraphQLString)}, interfaces=[]
         )
-        schema.query_type.interfaces.append(None)  # type: ignore
+        # noinspection PyTypeChecker
+        query_type.interfaces.append(None)
+        schema = GraphQLSchema(query_type)
 
         assert validate_schema(schema) == [
             {
@@ -1921,6 +1953,24 @@ def rejects_an_interface_with_a_differently_typed_interface_field():
             }
         ]
 
+    def accepts_an_interface_with_a_subtyped_interface_field_interface():
+        schema = build_schema(
+            """
+            type Query {
+              test: ChildInterface
+            }
+
+            interface ParentInterface {
+              field: ParentInterface
+            }
+
+            interface ChildInterface implements ParentInterface {
+              field: ChildInterface
+            }
+            """
+        )
+        assert validate_schema(schema) == []
+
     def accepts_an_interface_with_a_subtyped_interface_field_union():
         schema = build_schema(
             """
@@ -1967,6 +2017,25 @@ def rejects_an_interface_implementing_a_non_interface_type():
             "BadInterface interfaces must be specified as a collection"
             " of GraphQLInterfaceType instances."
         )
+        # therefore we construct the invalid schema manually
+        some_input_obj = GraphQLInputObjectType(
+            "SomeInputObject", {"field": GraphQLInputField(GraphQLString)}
+        )
+        bad_interface = GraphQLInterfaceType(
+            "BadInterface", {"field": GraphQLField(GraphQLString)}
+        )
+        # noinspection PyTypeChecker
+        bad_interface.interfaces.append(some_input_obj)
+        schema = GraphQLSchema(
+            GraphQLObjectType("Query", {"field": GraphQLField(GraphQLString)}),
+            types=[bad_interface],
+        )
+        assert validate_schema(schema) == [
+            {
+                "message": "Type BadInterface must only implement Interface types,"
+                " it cannot implement SomeInputObject.",
+            }
+        ]
 
     def rejects_an_interface_missing_an_interface_argument():
         schema = build_schema(