Add fragments on composite types validation rule

Author: joemcbride

README.md

@@ -147,7 +147,7 @@ Console.Writeline(result);
 - [x] Arguments of correct type
 - [x] Default values of correct type
 - [x] Fields on correct type
-- [ ] Fragments on composite type
+- [x] Fragments on composite types
 - [x] Known argument names
 - [x] Known directives
 - [x] Known fragment names

src/GraphQL.Tests/GraphQL.Tests.csproj

@@ -79,6 +79,7 @@
     <Compile Include="Types\QueryArgumentTests.cs" />
     <Compile Include="Utilities\AstPrinterTests.cs" />
     <Compile Include="Validation\FieldsOnCorrectTypeTests.cs" />
+    <Compile Include="Validation\FragmentsOnCompositeTypesTests.cs" />
     <Compile Include="Validation\KnownDirectivesTests.cs" />
     <Compile Include="Validation\NoUnusedFragmentsTests.cs" />
     <Compile Include="Utilities\SchemaPrinterTests.cs" />

src/GraphQL.Tests/Validation/FragmentsOnCompositeTypesTests.cs

@@ -0,0 +1,124 @@
+using GraphQL.Validation.Rules;
+
+namespace GraphQL.Tests.Validation
+{
+    public class FragmentsOnCompositeTypesTests : ValidationTestBase<FragmentsOnCompositeTypes, ValidationSchema>
+    {
+        [Fact]
+        public void object_is_valid_fragment_type()
+        {
+            ShouldPassRule(@"
+              fragment validFragment on Dog {
+                barks
+              }
+            ");
+        }
+
+        [Fact]
+        public void interface_is_valid_fragment_type()
+        {
+            ShouldPassRule(@"
+              fragment validFragment on Pet {
+                name
+              }
+            ");
+        }
+
+        [Fact]
+        public void object_is_valid_inline_fragment_type()
+        {
+            ShouldPassRule(@"
+              fragment validFragment on Pet {
+                ... on Dog {
+                  barks
+                }
+              }
+            ");
+        }
+
+        [Fact]
+        public void inline_fragment_without_type_is_valid()
+        {
+            ShouldPassRule(@"
+              fragment validFragment on Pet {
+                ... {
+                  name
+                }
+              }
+            ");
+        }
+
+        [Fact]
+        public void union_is_valid_fragment_type()
+        {
+            ShouldPassRule(@"
+              fragment validFragment on CatOrDog {
+                __typename
+              }
+            ");
+        }
+
+        [Fact]
+        public void scalar_is_invalid_fragment_type()
+        {
+            ShouldFailRule(_ =>
+            {
+                _.Query = @"
+                  fragment scalarFragment on Boolean {
+                    bad
+                  }
+                ";
+                error(_, "scalarFragment", "Boolean", 2, 46);
+            });
+        }
+
+        [Fact]
+        public void enum_is_invalid_fragment_type()
+        {
+            ShouldFailRule(_ =>
+            {
+                _.Query = @"
+                  fragment scalarFragment on FurColor {
+                    bad
+                  }
+                ";
+                error(_, "scalarFragment", "FurColor", 2, 46);
+            });
+        }
+
+        [Fact]
+        public void input_object_is_invalid_fragment_type()
+        {
+            ShouldFailRule(_ =>
+            {
+                _.Query = @"
+                  fragment inputFragment on ComplexInput {
+                    stringField
+                  }
+                ";
+                error(_, "inputFragment", "ComplexInput", 2, 45);
+            });
+        }
+
+        [Fact]
+        public void scalar_is_invalid_inline_fragment_type()
+        {
+            ShouldFailRule(_ =>
+            {
+                _.Query = @"
+                  fragment invalidFragment on Pet {
+                    ... on String {
+                      barks
+                    }
+                  }
+                ";
+                _.Error(Rule.InlineFragmentOnNonCompositeErrorMessage("String"), 3, 28);
+            });
+        }
+
+        private void error(ValidationTestConfig _, string fragName, string typeName, int line, int column)
+        {
+            _.Error(Rule.FragmentOnNonCompositeErrorMessage(fragName, typeName), line, column);
+        }
+    }
+}

src/GraphQL/GraphQL.csproj

@@ -161,6 +161,7 @@
     <Compile Include="Validation\Rules\ArgumentsOfCorrectType.cs" />
     <Compile Include="Validation\Rules\DefaultValuesOfCorrectType.cs" />
     <Compile Include="Validation\Rules\FieldsOnCorrectType.cs" />
+    <Compile Include="Validation\Rules\FragmentsOnCompositeTypes.cs" />
     <Compile Include="Validation\Rules\KnownArgumentNames.cs" />
     <Compile Include="Validation\Rules\KnownFragmentNames.cs" />
     <Compile Include="Validation\Rules\KnownDirectives.cs" />

src/GraphQL/GraphQLExtensions.cs

@@ -16,6 +16,13 @@ public static string TrimGraphQLTypes(this string name)
             return Regex.Replace(name, "[\\[!\\]]", "").Trim();
         }
 
+        public static bool IsCompositeType(this GraphType type)
+        {
+            return type is ObjectGraphType ||
+                   type is InterfaceGraphType ||
+                   type is UnionGraphType;
+        }
+
         public static bool IsLeafType(this GraphType type, ISchema schema)
         {
             var namedType = type.GetNamedType(schema);

src/GraphQL/Validation/DocumentValidator.cs

@@ -56,6 +56,7 @@ public static List<IValidationRule> CoreRules()
                 new UniqueOperationNames(),
                 new LoneAnonymousOperation(),
                 new KnownTypeNames(),
+                new FragmentsOnCompositeTypes(),
                 new VariablesAreInputTypes(),
                 new ScalarLeafs(),
                 new FieldsOnCorrectType(),

src/GraphQL/Validation/Rules/FragmentsOnCompositeTypes.cs

@@ -0,0 +1,54 @@
+using GraphQL.Language;
+
+namespace GraphQL.Validation.Rules
+{
+    /// <summary>
+    /// Fragments on composite type
+    /// 
+    /// Fragments use a type condition to determine if they apply, since fragments
+    /// can only be spread into a composite type (object, interface, or union), the
+    /// type condition must also be a composite type.
+    /// </summary>
+    public class FragmentsOnCompositeTypes : IValidationRule
+    {
+        public string InlineFragmentOnNonCompositeErrorMessage(string type)
+        {
+            return $"Fragment cannot condition on non composite type \"{type}\".";
+        }
+
+        public string FragmentOnNonCompositeErrorMessage(string fragName, string type)
+        {
+            return $"Fragment \"{fragName}\" cannot condition on non composite type \"{type}\".";
+        }
+
+        public INodeVisitor Validate(ValidationContext context)
+        {
+            return new EnterLeaveListener(_ =>
+            {
+                _.Match<InlineFragment>(node =>
+                {
+                    var type = context.TypeInfo.GetLastType();
+                    if (node.Type != null && type != null && !type.IsCompositeType())
+                    {
+                        context.ReportError(new ValidationError(
+                            "5.4.1.3",
+                            InlineFragmentOnNonCompositeErrorMessage(context.Print(node.Type)),
+                            node.Type));
+                    }
+                });
+
+                _.Match<FragmentDefinition>(node =>
+                {
+                    var type = context.TypeInfo.GetLastType();
+                    if (type != null && !type.IsCompositeType())
+                    {
+                        context.ReportError(new ValidationError(
+                            "5.4.1.3",
+                            FragmentOnNonCompositeErrorMessage(node.Name, context.Print(node.Type)),
+                            node.Type));
+                    }
+                });
+            });
+        }
+    }
+}