KnownTypeNames, LoneAnonymousOperation rules

Author: dittos

graphql/core/validation/__init__.py

@@ -7,6 +7,8 @@
 
 specified_rules = [
     Rules.UniqueOperationNames,
+    Rules.LoneAnonymousOperation,
+    Rules.KnownTypeNames,
 ]
 
 

graphql/core/validation/rules.py

@@ -1,3 +1,4 @@
+from ..language.ast import OperationDefinition
 from ..error import GraphQLError
 from ..language.visitor import Visitor
 
@@ -25,3 +26,36 @@ def enter_OperationDefinition(self, node, *args):
     @staticmethod
     def message(operation_name):
         return 'There can only be one operation named "{}".'.format(operation_name)
+
+
+class LoneAnonymousOperation(ValidationRule):
+    def __init__(self, context):
+        super(LoneAnonymousOperation, self).__init__(context)
+        self._op_count = 0
+
+    def enter_Document(self, node, *args):
+        n = 0
+        for definition in node.definitions:
+            if isinstance(definition, OperationDefinition):
+                n += 1
+        self._op_count = n
+
+    def enter_OperationDefinition(self, node, *args):
+        if not node.name and self._op_count > 1:
+            return GraphQLError(self.message(), [node])
+
+    @staticmethod
+    def message():
+        return 'This anonymous operation must be the only defined operation.'
+
+
+class KnownTypeNames(ValidationRule):
+    def enter_NamedType(self, node, *args):
+        type_name = node.name.value
+        type = self.context.get_schema().get_type(type_name)
+        if not type:
+            return GraphQLError(self.message(type_name), [node])
+
+    @staticmethod
+    def message(type):
+        return 'Unknown type "{}".'.format(type)

tests/core_validation/test_known_type_names.py

@@ -0,0 +1,41 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import KnownTypeNames
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def unknown_type(type_name, line, column):
+    return {
+        'message': KnownTypeNames.message(type_name),
+        'locations': [SourceLocation(line, column)]
+    }
+
+
+def test_known_type_names_are_valid():
+    expect_passes_rule(KnownTypeNames, '''
+      query Foo($var: String, $required: [String!]!) {
+        user(id: 4) {
+          pets { ... on Pet { name }, ...PetFields }
+        }
+      }
+      fragment PetFields on Pet {
+        name
+      }
+    ''')
+
+
+def test_unknown_type_names_are_invalid():
+    expect_fails_rule(KnownTypeNames, '''
+      query Foo($var: JumbledUpLetters) {
+        user(id: 4) {
+          name
+          pets { ... on Badger { name }, ...PetFields }
+        }
+      }
+      fragment PetFields on Peettt {
+        name
+      }
+    ''', [
+        unknown_type('JumbledUpLetters', 2, 23),
+        unknown_type('Badger', 5, 25),
+        unknown_type('Peettt', 8, 29),
+    ])

tests/core_validation/test_lone_anonymous_operation.py

@@ -0,0 +1,74 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import LoneAnonymousOperation
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def anon_not_alone(line, column):
+    return {
+        'message': LoneAnonymousOperation.message(),
+        'locations': [SourceLocation(line, column)]
+    }
+
+
+def test_no_operations():
+    expect_passes_rule(LoneAnonymousOperation, '''
+      fragment fragA on Type {
+        field
+      }
+    ''')
+
+
+def test_one_anon_operation():
+    expect_passes_rule(LoneAnonymousOperation, '''
+      {
+        field
+      }
+    ''')
+
+
+def test_multiple_named_operation():
+    expect_passes_rule(LoneAnonymousOperation, '''
+      query Foo {
+        field
+      }
+
+      query Bar {
+        field
+      }
+    ''')
+
+
+def test_anon_operation_with_fragment():
+    expect_passes_rule(LoneAnonymousOperation, '''
+      {
+        ...Foo
+      }
+      fragment Foo on Type {
+        field
+      }
+    ''')
+
+
+def test_multiple_anon_operations():
+    expect_fails_rule(LoneAnonymousOperation, '''
+      {
+        fieldA
+      }
+      {
+        fieldB
+      }
+    ''', [
+        anon_not_alone(2, 7),
+        anon_not_alone(5, 7),
+    ])
+
+
+def test_anon_operation_with_another_operation():
+    expect_fails_rule(LoneAnonymousOperation, '''
+      {
+        fieldA
+      }
+      mutation Foo {
+        fieldB
+      }
+    ''', [anon_not_alone(2, 7)])

tests/core_validation/utils.py

@@ -6,9 +6,17 @@
     GraphQLField,
     GraphQLArgument,
     GraphQLID,
-    GraphQLString, GraphQLBoolean)
+    GraphQLString,
+    GraphQLBoolean,
+    GraphQLInterfaceType)
 from graphql.core.error import format_error
 
+Pet = GraphQLInterfaceType('Pet', {
+    'name': GraphQLField(GraphQLString, {
+        'surname': GraphQLArgument(GraphQLBoolean),
+    }),
+})
+
 Human = GraphQLObjectType('Human', {
     'name': GraphQLField(GraphQLString, {
         'surname': GraphQLArgument(GraphQLBoolean),
@@ -18,7 +26,8 @@
 QueryRoot = GraphQLObjectType('QueryRoot', {
     'human': GraphQLField(Human, {
         'id': GraphQLArgument(GraphQLID)
-    })
+    }),
+    'pet': GraphQLField(Pet),
 })
 
 default_schema = GraphQLSchema(query=QueryRoot)