FragmentsOnCompositeType rule

Author: dittos

graphql/core/language/source.py

@@ -5,3 +5,8 @@ class Source(object):
     def __init__(self, body, name='GraphQL'):
         self.body = body
         self.name = name
+
+    def __eq__(self, other):
+        if isinstance(other, Source):
+            return self.body == other.body and self.name == other.name
+        return False

graphql/core/language/visitor.py

@@ -101,7 +101,7 @@ def visit(root, visitor, key_map=None):
 
         result = None
         if not isinstance(node, list):
-            assert is_node(node), 'Invalid AST Node: ' + node
+            assert is_node(node), 'Invalid AST Node: ' + repr(node)
             if is_leaving:
                 result = visitor.leave(node, key, parent, path, ancestors)
             else:
@@ -146,7 +146,7 @@ def visit(root, visitor, key_map=None):
 
 
 def is_node(maybe_node):
-    return isinstance(maybe_node, object)  # FIXME
+    return hasattr(maybe_node, 'loc')  # FIXME
 
 
 class Visitor(object):

graphql/core/validation/__init__.py

@@ -9,6 +9,7 @@
     Rules.UniqueOperationNames,
     Rules.LoneAnonymousOperation,
     Rules.KnownTypeNames,
+    Rules.FragmentsOnCompositeTypes,
 ]
 
 

graphql/core/validation/rules.py

@@ -1,6 +1,8 @@
-from ..language.ast import OperationDefinition
 from ..error import GraphQLError
+from ..type.definition import is_composite_type
+from ..language.ast import OperationDefinition
 from ..language.visitor import Visitor
+from ..language.printer import print_ast
 
 
 class ValidationRule(Visitor):
@@ -59,3 +61,29 @@ def enter_NamedType(self, node, *args):
     @staticmethod
     def message(type):
         return 'Unknown type "{}".'.format(type)
+
+
+class FragmentsOnCompositeTypes(ValidationRule):
+    def enter_InlineFragment(self, node, *args):
+        type = self.context.get_type()
+        if type and not is_composite_type(type):
+            return GraphQLError(
+                self.inline_message(print_ast(node.type_condition)),
+                [node.type_condition]
+            )
+
+    def enter_FragmentDefinition(self, node, *args):
+        type = self.context.get_type()
+        if type and not is_composite_type(type):
+            return GraphQLError(
+                self.message(node.name.value, print_ast(node.type_condition)),
+                [node.type_condition]
+            )
+
+    @staticmethod
+    def inline_message(type):
+        return 'Fragment cannot condition on non composite type "{}".'.format(type)
+
+    @staticmethod
+    def message(frag_name, type):
+        return 'Fragment "{}" cannot condition on non composite type "{}".'.format(frag_name, type)

tests/core_validation/test_fragments_on_composite_types.py

@@ -0,0 +1,81 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import FragmentsOnCompositeTypes
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def error(frag_name, type_name, line, column):
+    return {
+        'message': FragmentsOnCompositeTypes.message(frag_name, type_name),
+        'locations': [SourceLocation(line, column)]
+    }
+
+
+def test_object_is_valid_fragment_type():
+    expect_passes_rule(FragmentsOnCompositeTypes, '''
+      fragment validFragment on Dog {
+        barks
+      }
+    ''')
+
+
+def test_interface_is_valid_fragment_type():
+    expect_passes_rule(FragmentsOnCompositeTypes, '''
+      fragment validFragment on Pet {
+        name
+      }
+    ''')
+
+
+def test_object_is_valid_inline_fragment_type():
+    expect_passes_rule(FragmentsOnCompositeTypes, '''
+      fragment validFragment on Pet {
+        ... on Dog {
+          barks
+        }
+      }
+    ''')
+
+
+def test_union_is_valid_fragment_type():
+    expect_passes_rule(FragmentsOnCompositeTypes, '''
+      fragment validFragment on CatOrDog {
+        __typename
+      }
+    ''')
+
+
+def test_scalar_is_invalid_fragment_type():
+    expect_fails_rule(FragmentsOnCompositeTypes, '''
+      fragment scalarFragment on Boolean {
+        bad
+      }
+    ''', [error('scalarFragment', 'Boolean', 2, 34)])
+
+
+def test_enum_is_invalid_fragment_type():
+    expect_fails_rule(FragmentsOnCompositeTypes, '''
+      fragment scalarFragment on FurColor {
+        bad
+      }
+    ''', [error('scalarFragment', 'FurColor', 2, 34)])
+
+
+def test_input_object_is_invalid_fragment_type():
+    expect_fails_rule(FragmentsOnCompositeTypes, '''
+      fragment inputFragment on ComplexInput {
+        stringField
+      }
+    ''', [error('inputFragment', 'ComplexInput', 2, 33)])
+
+
+def test_scalar_is_invalid_inline_fragment_type():
+    expect_fails_rule(FragmentsOnCompositeTypes, '''
+      fragment invalidFragment on Pet {
+        ... on String {
+          barks
+        }
+      }
+    ''', [{
+        'message': FragmentsOnCompositeTypes.inline_message('String'),
+        'locations': [SourceLocation(3, 16)]
+    }])

tests/core_validation/utils.py

@@ -8,7 +8,7 @@
     GraphQLID,
     GraphQLString,
     GraphQLBoolean,
-    GraphQLInterfaceType)
+    GraphQLInterfaceType, GraphQLEnumType, GraphQLEnumValue, GraphQLInputObjectType)
 from graphql.core.error import format_error
 
 Pet = GraphQLInterfaceType('Pet', {
@@ -17,17 +17,43 @@
     }),
 })
 
+Dog = GraphQLObjectType('Dog', {
+    'barks': GraphQLField(GraphQLBoolean),
+}, interfaces=[Pet])
+
+Cat = GraphQLObjectType('Cat', lambda: {
+    'furColor': GraphQLField(FurColor)
+}, interfaces=[Pet])
+
 Human = GraphQLObjectType('Human', {
     'name': GraphQLField(GraphQLString, {
         'surname': GraphQLArgument(GraphQLBoolean),
     })
 })
 
+FurColor = GraphQLEnumType('FurColor', {
+    'BROWN': GraphQLEnumValue(0),
+    'BLACK': GraphQLEnumValue(1),
+    'TAN': GraphQLEnumValue(2),
+    'SPOTTED': GraphQLEnumValue(3),
+})
+
+ComplexInput = GraphQLInputObjectType('ComplexInput', {
+    'stringField': GraphQLField(GraphQLString)
+})
+
+ComplicatedArgs = GraphQLObjectType('ComplicatedArgs', {
+    'complexArgField': GraphQLField(GraphQLString, {
+        'complexArg': GraphQLArgument(ComplexInput),
+    })
+})
+
 QueryRoot = GraphQLObjectType('QueryRoot', {
     'human': GraphQLField(Human, {
         'id': GraphQLArgument(GraphQLID)
     }),
     'pet': GraphQLField(Pet),
+    'complicatedArgs': GraphQLField(ComplicatedArgs),
 })
 
 default_schema = GraphQLSchema(query=QueryRoot)