Added more validation rules. (#214)

- #111 - #116 - #113
ChilliCream · Aug 21, 2018 · 62afad5 · 62afad5
1 parent f129c5e
commit 62afad5
Show file tree

Hide file tree

Showing 17 changed files with 722 additions and 188 deletions.
diff --git a/src/Benchmark.Tests/Resources/IntrospectionQuery.graphql b/src/Benchmark.Tests/Resources/IntrospectionQuery.graphql
@@ -1,84 +1,65 @@
-query IntrospectionQuery {
-  __schema {
-    queryType {
-      name
-    }
-    mutationType {
-      name
-    }
-    subscriptionType {
-      name
-    }
-    types {
-      ...FullType
+  query IntrospectionQuery {
+    __schema {
+      queryType { name }
+      mutationType { name }
+      subscriptionType { name }
+      types {
+        ...FullType
+      }
+      directives {
+        name
+        description
+        args {
+          ...InputValue
+        }
+        onOperation
+        onFragment
+        onField
+      }
     }
-    directives {
+  }
+
+  fragment FullType on __Type {
+    kind
+    name
+    description
+    fields(includeDeprecated: true) {
       name
       description
-      locations
       args {
         ...InputValue
       }
+      type {
+        ...TypeRef
+      }
+      isDeprecated
+      deprecationReason
     }
-  }
-}
-
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args {
+    inputFields {
       ...InputValue
     }
-    type {
+    interfaces {
+      ...TypeRef
+    }
+    enumValues(includeDeprecated: true) {
+      name
+      description
+      isDeprecated
+      deprecationReason
+    }
+    possibleTypes {
       ...TypeRef
     }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields {
-    ...InputValue
-  }
-  interfaces {
-    ...TypeRef
   }
-  enumValues(includeDeprecated: true) {
+
+  fragment InputValue on __InputValue {
     name
     description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes {
-    ...TypeRef
-  }
-}
-
-fragment InputValue on __InputValue {
-  name
-  description
-  type {
-    ...TypeRef
-  }
-  defaultValue
-}
-
-fragment InputValue on __ObjectType {
-  name
-  description
-  type {
-    ...TypeRef
+    type { ...TypeRef }
+    defaultValue
   }
-  defaultValue
-  Bla
-}
 
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
+  fragment TypeRef on __Type {
     kind
     name
     ofType {
@@ -90,20 +71,7 @@ fragment TypeRef on __Type {
         ofType {
           kind
           name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
         }
       }
     }
   }
-}
diff --git a/src/Core.Tests/Validation/ArgumentNamesRuleTests.cs b/src/Core.Tests/Validation/ArgumentNamesRuleTests.cs
@@ -0,0 +1,114 @@
+using HotChocolate.Language;
+using Xunit;
+
+namespace HotChocolate.Validation
+{
+    public class ArgumentNamesRuleTests
+        : ValidationTestBase
+    {
+        public ArgumentNamesRuleTests()
+            : base(new ArgumentNamesRule())
+        {
+        }
+
+        [Fact]
+        public void ArgOnRequiredArg()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                fragment argOnRequiredArg on Dog {
+                    doesKnowCommand(dogCommand: SIT)
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+        [Fact]
+        public void ArgOnOptional()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                fragment argOnOptional on Dog {
+                    isHousetrained(atOtherHomes: true) @include(if: true)
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+        [Fact]
+        public void InvalidFieldArgName()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                fragment invalidArgName on Dog {
+                    doesKnowCommand(command: CLEAN_UP_HOUSE)
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(
+                    $"The argument `command` does not exist.", t.Message));
+        }
+
+        [Fact]
+        public void InvalidDirectiveArgName()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                fragment invalidArgName on Dog {
+                    isHousetrained(atOtherHomes: true) @include(unless: false)
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(
+                    $"The argument `unless` does not exist.", t.Message));
+        }
+
+        [Fact]
+        public void ArgumentOrderDoesNotMatter()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                fragment multipleArgs on Arguments {
+                    multipleReqs(x: 1, y: 2)
+                }
+
+                fragment multipleArgsReverseOrder on Arguments {
+                    multipleReqs(y: 1, x: 2)
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+    }
+}
diff --git a/src/Core.Tests/Validation/FragmentNameUniquenessRuleTests.cs b/src/Core.Tests/Validation/FragmentNameUniquenessRuleTests.cs
@@ -0,0 +1,79 @@
+using HotChocolate.Language;
+using Xunit;
+
+namespace HotChocolate.Validation
+{
+    public class FragmentNameUniquenessRuleTests
+        : ValidationTestBase
+    {
+        public FragmentNameUniquenessRuleTests()
+            : base(new FragmentNameUniquenessRule())
+        {
+        }
+
+        [Fact]
+        public void UniqueFragments()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...fragmentOne
+                        ...fragmentTwo
+                    }
+                }
+
+                fragment fragmentOne on Dog {
+                    name
+                }
+
+                fragment fragmentTwo on Dog {
+                    owner {
+                        name
+                    }
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+        [Fact]
+        public void DuplicateFragments()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...fragmentOne
+                    }
+                }
+
+                fragment fragmentOne on Dog {
+                    name
+                }
+
+                fragment fragmentOne on Dog {
+                    owner {
+                        name
+                    }
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(
+                    "There are multiple fragments with the name `fragmentOne`.",
+                    t.Message));
+        }
+    }
+}