fix(validate): no reusing root types

Replicates graphql/graphql-js@c008d0f

Author: Cito

src/graphql/pyutils/__init__.py

@@ -17,6 +17,7 @@
     unregister_description,
 )
 from .did_you_mean import did_you_mean
+from .format_list import or_list, and_list
 from .group_by import group_by
 from .identity_func import identity_func
 from .inspect import inspect
@@ -37,6 +38,8 @@
     "snake_to_camel",
     "cached_property",
     "did_you_mean",
+    "or_list",
+    "and_list",
     "Description",
     "group_by",
     "is_description",

src/graphql/pyutils/did_you_mean.py

@@ -1,5 +1,7 @@
 from typing import Optional, Sequence
 
+from .format_list import or_list
+
 
 __all__ = ["did_you_mean"]
 
@@ -10,20 +12,11 @@ def did_you_mean(suggestions: Sequence[str], sub_message: Optional[str] = None)
     """Given [ A, B, C ] return ' Did you mean A, B, or C?'"""
     if not suggestions or not MAX_LENGTH:
         return ""
-    parts = [" Did you mean "]
+    message = " Did you mean "
     if sub_message:
-        parts.extend([sub_message, " "])
+        message += sub_message + " "
     suggestions = suggestions[:MAX_LENGTH]
-    n = len(suggestions)
-    if n == 1:
-        parts.append(f"'{suggestions[0]}'?")
-    elif n == 2:
-        parts.append(f"'{suggestions[0]}' or '{suggestions[1]}'?")
-    else:
-        parts.extend(
-            [
-                ", ".join(f"'{s}'" for s in suggestions[:-1]),
-                f", or '{suggestions[-1]}'?",
-            ]
-        )
-    return "".join(parts)
+    suggestion_list = or_list(
+        [f"'{suggestion}'" for suggestion in suggestions[:MAX_LENGTH]]
+    )
+    return message + suggestion_list + "?"

src/graphql/pyutils/format_list.py

@@ -0,0 +1,29 @@
+from typing import Sequence
+
+
+__all__ = ["or_list", "and_list"]
+
+
+def or_list(items: Sequence[str]) -> str:
+    """Given [ A, B, C ] return 'A, B, or C'."""
+    return format_list("or", items)
+
+
+def and_list(items: Sequence[str]) -> str:
+    """Given [ A, B, C ] return 'A, B, and C'."""
+    return format_list("and", items)
+
+
+def format_list(conjunction: str, items: Sequence[str]) -> str:
+    """Given [ A, B, C ] return 'A, B, (conjunction) C'"""
+    if not items:
+        raise ValueError("Missing list items to be formatted.")
+
+    n = len(items)
+    if n == 1:
+        return items[0]
+    if n == 2:
+        return f"{items[0]} {conjunction} {items[1]}"
+
+    *all_but_last, last_item = items
+    return f"{', '.join(all_but_last)}, {conjunction} {last_item}"

src/graphql/type/validate.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from operator import attrgetter, itemgetter
 from typing import Any, Collection, Dict, List, Optional, Set, Tuple, Union, cast
 
@@ -11,7 +12,7 @@
     SchemaDefinitionNode,
     SchemaExtensionNode,
 )
-from ..pyutils import inspect
+from ..pyutils import and_list, inspect
 from ..utilities.type_comparators import is_equal_type, is_type_sub_type_of
 from .definition import (
     GraphQLEnumType,
@@ -105,19 +106,37 @@ def validate_root_types(self) -> None:
         schema = self.schema
         if not schema.query_type:
             self.report_error("Query root type must be provided.", schema.ast_node)
+        root_types_map: Dict[GraphQLObjectType, List[OperationType]] = defaultdict(list)
+
         for operation_type in OperationType:
             root_type = schema.get_root_type(operation_type)
-            if root_type and not is_object_type(root_type):
-                operation_type_str = operation_type.value.capitalize()
-                root_type_str = inspect(root_type)
-                if_provided_str = (
-                    "" if operation_type == operation_type.QUERY else " if provided"
+            if root_type:
+                if is_object_type(root_type):
+                    root_types_map[root_type].append(operation_type)
+                else:
+                    operation_type_str = operation_type.value.capitalize()
+                    root_type_str = inspect(root_type)
+                    if_provided_str = (
+                        "" if operation_type == operation_type.QUERY else " if provided"
+                    )
+                    self.report_error(
+                        f"{operation_type_str} root type must be Object type"
+                        f"{if_provided_str}, it cannot be {root_type_str}.",
+                        get_operation_type_node(schema, operation_type)
+                        or root_type.ast_node,
+                    )
+        for root_type, operation_types in root_types_map.items():
+            if len(operation_types) > 1:
+                operation_list = and_list(
+                    [operation_type.value for operation_type in operation_types]
                 )
                 self.report_error(
-                    f"{operation_type_str} root type must be Object type"
-                    f"{if_provided_str}, it cannot be {root_type_str}.",
-                    get_operation_type_node(schema, operation_type)
-                    or root_type.ast_node,
+                    "All root types must be different,"
+                    f" '{root_type.name}' type is used as {operation_list} root types.",
+                    [
+                        get_operation_type_node(schema, operation_type)
+                        for operation_type in operation_types
+                    ],
                 )
 
     def validate_directives(self) -> None:

tests/pyutils/test_format_list.py

@@ -0,0 +1,39 @@
+from pytest import raises
+
+from graphql.pyutils import and_list, or_list
+
+
+def describe_and_list():
+    def does_not_accept_an_empty_list():
+        with raises(ValueError):
+            and_list([])
+
+    def handles_single_item():
+        assert and_list(["A"]) == "A"
+
+    def handles_two_items():
+        assert and_list(["A", "B"]) == "A and B"
+
+    def handles_three_items():
+        assert and_list(["A", "B", "C"]) == "A, B, and C"
+
+    def handles_more_than_five_items():
+        assert and_list(["A", "B", "C", "D", "E", "F"]) == "A, B, C, D, E, and F"
+
+
+def describe_or_list():
+    def does_not_accept_an_empty_list():
+        with raises(ValueError):
+            or_list([])
+
+    def handles_single_item():
+        assert or_list(["A"]) == "A"
+
+    def handles_two_items():
+        assert or_list(["A", "B"]) == "A or B"
+
+    def handles_three_items():
+        assert or_list(["A", "B", "C"]) == "A, B, or C"
+
+    def handles_more_than_five_items():
+        assert or_list(["A", "B", "C", "D", "E", "F"]) == "A, B, C, D, E, or F"

tests/type/test_validation.py

@@ -454,6 +454,80 @@ def rejects_a_schema_whose_directives_are_incorrectly_typed():
         ]
 
 
+def describe_type_system_root_types_must_all_be_different_if_provided():
+    def accepts_a_schema_with_different_root_types():
+        schema = build_schema(
+            """
+            type SomeObject1 {
+              field: String
+            }
+
+            type SomeObject2 {
+              field: String
+            }
+
+            type SomeObject3 {
+              field: String
+            }
+
+            schema {
+              query: SomeObject1
+              mutation: SomeObject2
+              subscription: SomeObject3
+            }
+            """
+        )
+        assert validate_schema(schema) == []
+
+    def rejects_a_schema_where_the_same_type_is_used_for_multiple_root_types():
+        schema = build_schema(
+            """
+            type SomeObject {
+              field: String
+            }
+
+            type UniqueObject {
+              field: String
+            }
+
+            schema {
+              query: SomeObject
+              mutation: UniqueObject
+              subscription: SomeObject
+            }
+            """
+        )
+        assert validate_schema(schema) == [
+            {
+                "message": "All root types must be different, 'SomeObject' type"
+                " is used as query and subscription root types.",
+                "locations": [(11, 22), (13, 29)],
+            }
+        ]
+
+    def rejects_a_schema_where_the_same_type_is_used_for_all_root_types():
+        schema = build_schema(
+            """
+            type SomeObject {
+              field: String
+            }
+
+            schema {
+              query: SomeObject
+              mutation: SomeObject
+              subscription: SomeObject
+            }
+            """
+        )
+        assert validate_schema(schema) == [
+            {
+                "message": "All root types must be different, 'SomeObject' type"
+                " is used as query, mutation, and subscription root types.",
+                "locations": [(7, 22), (8, 25), (9, 29)],
+            }
+        ]
+
+
 def describe_type_system_objects_must_have_fields():
     def accepts_an_object_type_with_fields_object():
         schema = build_schema(