Generate error per duplicate schema def + Extend tests

Replicates graphql/graphql-js@3217802

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.0rc2 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.0rc2. All parts of the API are covered by an extensive test
-suite of currently 1539 unit tests.
+suite of currently 1547 unit tests.
 
 
 ## Documentation

graphql/type/introspection.py

@@ -216,6 +216,7 @@ def name(type_, _info):
     def description(type_, _info):
         return getattr(type_, 'description', None)
 
+    # noinspection PyPep8Naming
     @staticmethod
     def fields(type_, _info, includeDeprecated=False):
         if is_object_type(type_) or is_interface_type(type_):
@@ -235,6 +236,7 @@ def possible_types(type_, info):
         if is_abstract_type(type_):
             return info.schema.get_possible_types(type_)
 
+    # noinspection PyPep8Naming
     @staticmethod
     def enum_values(type_, _info, includeDeprecated=False):
         if is_enum_type(type_):

graphql/utilities/extend_schema.py

@@ -446,8 +446,8 @@ def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
             # correctly typed values, that would throw immediately while
             # type system validation with validate_schema() will produce
             # more actionable results.
-            type_ = operation_type.type
-            operation_types[operation] = ast_builder.build_type(type_)
+            operation_types[operation] = ast_builder.build_type(
+                operation_type.type)
 
     # Then, incorporate schema definition and all schema extensions.
     for schema_extension in schema_extensions:
@@ -461,8 +461,8 @@ def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
                 # correctly typed values, that would throw immediately while
                 # type system validation with validate_schema() will produce
                 # more actionable results.
-                type_ = operation_type.type
-                operation_types[operation] = ast_builder.build_type(type_)
+                operation_types[operation] = ast_builder.build_type(
+                    operation_type.type)
 
     schema_extension_ast_nodes = (
         schema.extension_ast_nodes or cast(Tuple[SchemaExtensionNode], ())
@@ -472,8 +472,7 @@ def resolve_type(type_ref: NamedTypeNode) -> GraphQLNamedType:
     # that any type not directly referenced by a value will get created.
     types = list(map(extend_named_type, schema.type_map.values()))
     # do the same with new types
-    types.extend(ast_builder.build_type(type_)
-                 for type_ in type_definition_map.values())
+    types.extend(map(ast_builder.build_type, type_definition_map.values()))
 
     # Then produce and return a Schema with these types.
     return GraphQLSchema(  # type: ignore

graphql/validation/rules/lone_schema_definition.py

@@ -1,19 +1,18 @@
-from typing import List
-
 from ...error import GraphQLError
 from ...language import SchemaDefinitionNode
 from . import SDLValidationRule, SDLValidationContext
 
 __all__ = [
     'LoneSchemaDefinition',
-    'schema_definition_alone_message', 'cannot_define_schema_within_extension']
+    'schema_definition_not_alone_message',
+    'cannot_define_schema_within_extension_message']
 
 
-def schema_definition_alone_message():
+def schema_definition_not_alone_message():
     return 'Must provide only one schema definition.'
 
 
-def cannot_define_schema_within_extension():
+def cannot_define_schema_within_extension_message():
     return 'Cannot define a new schema within a schema extension.'
 
 
@@ -29,16 +28,14 @@ def __init__(self, context: SDLValidationContext) -> None:
         self.already_defined = old_schema and (
             old_schema.ast_node or old_schema.query_type or
             old_schema.mutation_type or old_schema.subscription_type)
-        self.schema_nodes: List[SchemaDefinitionNode] = []
+        self.schema_definitions_count = 0
 
     def enter_schema_definition(self, node: SchemaDefinitionNode, *_args):
         if self.already_defined:
             self.report_error(GraphQLError(
-                cannot_define_schema_within_extension(), [node]))
+                cannot_define_schema_within_extension_message(), node))
         else:
-            self.schema_nodes.append(node)
-
-    def leave_document(self, *_args):
-        if len(self.schema_nodes) > 1:
-            self.report_error(GraphQLError(
-                schema_definition_alone_message(), self.schema_nodes))
+            if self.schema_definitions_count:
+                self.report_error(GraphQLError(
+                    schema_definition_not_alone_message(), node))
+            self.schema_definitions_count += 1

tests/utilities/test_build_ast_schema.py

@@ -726,26 +726,6 @@ def allows_to_disable_sdl_validation():
 
 def describe_failures():
 
-    def allows_only_a_single_schema_definition():
-        body = dedent("""
-            schema {
-              query: Hello
-            }
-
-            schema {
-              query: Hello
-            }
-
-            type Hello {
-              bar: Bar
-            }
-            """)
-        doc = parse(body)
-        with raises(TypeError) as exc_info:
-            build_ast_schema(doc)
-        msg = str(exc_info.value)
-        assert msg == 'Must provide only one schema definition.'
-
     def allows_only_a_single_query_type():
         body = dedent("""
             schema {
@@ -754,7 +734,7 @@ def allows_only_a_single_query_type():
             }
 
             type Hello {
-              bar: Bar
+              bar: String
             }
 
             type Yellow {
@@ -776,7 +756,7 @@ def allows_only_a_single_mutation_type():
             }
 
             type Hello {
-              bar: Bar
+              bar: String
             }
 
             type Yellow {
@@ -797,7 +777,7 @@ def allows_only_a_single_subscription_type():
               subscription: Yellow
             }
             type Hello {
-              bar: Bar
+              bar: String
             }
 
             type Yellow {

tests/utilities/test_extend_schema.py

@@ -1096,21 +1096,6 @@ def does_not_automatically_include_common_root_type_names():
                 """)
             assert schema.mutation_type is None
 
-        def does_not_allow_overriding_schema_within_an_extension():
-            sdl = """
-                schema {
-                  mutation: Mutation
-                }
-
-                type Mutation {
-                  doSomething: String
-                }
-                """
-            with raises(TypeError) as exc_info:
-                extend_test_schema(sdl)
-            assert str(exc_info.value).startswith(
-                'Cannot define a new schema within a schema extension.')
-
         def adds_schema_definition_missing_in_the_original_schema():
             schema = GraphQLSchema(
                 directives=[FooDirective],

tests/validation/test_known_directives.py

@@ -130,7 +130,7 @@ def with_misplaced_directives():
     def describe_within_sdl():
 
         def with_directive_defined_inside_sdl():
-            expect_sdl_errors("""
+            assert expect_sdl_errors("""
                 type Query {
                   foo: String @test
                 }
@@ -139,23 +139,56 @@ def with_directive_defined_inside_sdl():
                 """) == []
 
         def with_standard_directive():
-            expect_sdl_errors("""
+            assert expect_sdl_errors("""
                 type Query {
                   foo: String @deprecated
                 }
                 """) == []
 
         def with_overridden_standard_directive():
-            expect_sdl_errors("""
+            assert expect_sdl_errors("""
                 schema @deprecated {
                   query: Query
                 }
                 directive @deprecated on SCHEMA
                 """) == []
 
-        # noinspection PyShadowingNames
+        def with_directive_defined_in_schema_extension():
+            schema = build_schema("""
+                type Query {
+                  foo: String
+                }
+                """)
+            assert expect_sdl_errors("""
+                directive @test on OBJECT
+
+                extend type Query @test
+                """, schema) == []
+
+        def with_directive_used_in_schema_extension():
+            schema = build_schema("""
+                directive @test on OBJECT
+
+                type Query {
+                  foo: String
+                }
+                """)
+            assert expect_sdl_errors("""
+                extend type Query @test
+                """, schema) == []
+
+        def with_unknown_directive_in_schema_extension():
+            schema = build_schema("""
+                type Query {
+                  foo: String
+                }
+                """)
+            assert expect_sdl_errors("""
+                extend type Query @unknown
+                """, schema) == [unknown_directive('unknown', 2, 35)]
+
         def with_well_placed_directives():
-            expect_sdl_errors("""
+            assert expect_sdl_errors("""
                 type MyObj implements MyInterface @onObject {
                   myField(myArg: Int @onArgumentDefinition): String @onFieldDefinition
                 }
@@ -196,9 +229,8 @@ def with_well_placed_directives():
                 """,  # noqa
                 schema_with_sdl_directives) == []
 
-        # noinspection PyShadowingNames
         def with_misplaced_directives():
-            expect_sdl_errors("""
+            assert expect_sdl_errors("""
                 type MyObj implements MyInterface @onInterface {
                   myField(myArg: Int @onInputFieldDefinition): String @onInputFieldDefinition
                 }

tests/validation/test_lone_schema_definition.py

@@ -0,0 +1,131 @@
+from functools import partial
+
+from graphql.utilities import build_schema
+from graphql.validation.rules.lone_schema_definition import (
+    LoneSchemaDefinition, schema_definition_not_alone_message,
+    cannot_define_schema_within_extension_message)
+
+from .harness import expect_sdl_errors_from_rule
+
+expect_sdl_errors = partial(
+    expect_sdl_errors_from_rule, LoneSchemaDefinition)
+
+
+def schema_definition_not_alone(line, column):
+    return {
+        'message': schema_definition_not_alone_message(),
+        'locations': [(line, column)]}
+
+
+def cannot_define_schema_within_extension(line, column):
+    return {
+        'message': cannot_define_schema_within_extension_message(),
+        'locations': [(line, column)]}
+
+
+def describe_validate_schema_definition_should_be_alone():
+
+    def no_schema():
+        assert expect_sdl_errors("""
+            type Query {
+              foo: String
+            }
+            """) == []
+
+    def one_schema_definition():
+        assert expect_sdl_errors("""
+            schema {
+              query: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+            """) == []
+
+    def multiple_schema_definitions():
+        assert expect_sdl_errors("""
+            schema {
+              query: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+
+            schema {
+              mutation: Foo
+            }
+
+            schema {
+              subscription: Foo
+            }
+            """) == [
+            schema_definition_not_alone(10, 13),
+            schema_definition_not_alone(14, 13)]
+
+    def define_schema_in_schema_extension():
+        schema = build_schema("""
+            type Foo {
+              foo: String
+            }
+            """)
+
+        assert expect_sdl_errors("""
+            schema {
+              query: Foo
+            }
+            """, schema) == []
+
+    def redefine_schema_in_schema_extension():
+        schema = build_schema("""
+            schema {
+              query: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+            """)
+
+        assert expect_sdl_errors("""
+            schema {
+              mutation: Foo
+            }
+            """, schema) == [
+            cannot_define_schema_within_extension(2, 13)]
+
+    def redefine_implicit_schema_in_schema_extension():
+        schema = build_schema("""
+            type Query {
+              fooField: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+            """)
+
+        assert expect_sdl_errors("""
+            schema {
+              mutation: Foo
+            }
+            """, schema) == [
+            cannot_define_schema_within_extension(2, 13)]
+
+    def extend_schema_in_schema_extension():
+        schema = build_schema("""
+            type Query {
+              fooField: Foo
+            }
+
+            type Foo {
+              foo: String
+            }
+            """)
+
+        assert expect_sdl_errors("""
+            extend schema {
+              mutation: Foo
+            }
+            """, schema) == []