Finalized Validation Rules

README.md

@@ -188,7 +188,7 @@ dotnet new graphql-server
 
 ## Features
 
-We currently support the following parts of the current [draft spec](http://facebook.github.io/graphql/draft/) of GraphQL.
+We currently support the following parts of the current [June 2018 specification](http://facebook.github.io/graphql/June2018/) of GraphQL.
 
 ### Types
 
@@ -210,33 +210,35 @@ We currently support the following parts of the current [draft spec](http://face
 
 - [x] Skip
 - [x] Continue
-- [ ] Deprecated
+- [ ] _Deprecated_ (in development - 0.5.0)
 
 ### Validation
 
-- [ ] [Validation](https://github.com/ChilliCream/hotchocolate/projects/3)
+- [x] [_Validation_](https://github.com/ChilliCream/hotchocolate/projects/3)
 
 ### Execution
 
 - [x] Query
 - [x] Mutation
-- [ ] Subscription
+- [ ] _Subscription_ (in development - 0.5.0)
 
 ### Introspection
 
 - Fields
-  - [x] __typename
-  - [x] __type
-  - [x] __schema
 
-- __Schema
+  - [x] \_\_typename
+  - [x] \_\_type
+  - [x] \_\_schema
+
+- \_\_Schema
+
   - [x] types
   - [x] queryType
   - [x] mutationType
   - [x] subscriptionType
   - [x] directives
 
-- __Type
+- \_\_Type
   - [x] kind
   - [x] name
   - [x] fields
@@ -254,6 +256,7 @@ Moreover, we are working on the following parts that are not defined in the spec
 - [x] Date
 - [ ] Time
 - [ ] URL
+- [ ] UUID
 - [x] Decimal
 - [x] Short (Int16)
 - [x] Long (Int64)
@@ -264,8 +267,8 @@ Moreover, we are working on the following parts that are not defined in the spec
 - [ ] Export
 - [ ] Defer
 - [ ] Stream
-- [ ] Custom Schema Directives
-- [ ] Custom Execution Directives
+- [ ] _Custom Schema Directives_ (in development - 0.5.0)
+- [ ] _Custom Execution Directives_ (in development - 0.5.0)
 
 ### Execution Engine
 
@@ -280,6 +283,7 @@ Moreover, we are working on the following parts that are not defined in the spec
 ## Supported Frameworks
 
 - [ ] ASP.NET Classic
+
   - [ ] Get
   - [ ] Post
 

src/Core.Tests/Integration/StarWarsCodeFirst/StarWarsCodeFirstTests.cs

@@ -460,6 +460,28 @@ query op($ep: [Episode!]!)
             Assert.Equal(Snapshot.Current(), Snapshot.New(result));
         }
 
+        [Fact]
+        public void ConditionalInlineFragment()
+        {
+            // arrange
+            Schema schema = CreateSchema();
+            string query = @"
+            {
+                heroes(episodes: [EMPIRE]) {
+                    name
+                    ... @include(if: true) {
+                        height
+                    }
+                }
+            }";
+
+            // act
+            IExecutionResult result = schema.Execute(query);
+
+            // assert
+            Assert.Equal(Snapshot.Current(), Snapshot.New(result));
+        }
+
         private static Schema CreateSchema()
         {
             CharacterRepository repository = new CharacterRepository();

src/Core.Tests/Types/FloatTypeTests.cs

@@ -11,7 +11,7 @@ public class FloatTypeTests
             new FloatValueNode("1.000000E+000");
 
         protected override IValueNode GetWrongValueNode =>
-            new IntValueNode("1");
+            new StringValueNode("1");
 
         protected override double GetValue => 1.0d;
 
@@ -54,5 +54,34 @@ public void ParseValue_Float_Min()
             // assert
             Assert.Equal("-3.402823E+038", literal.Value);
         }
+
+        [Fact]
+        public void IsInstanceOfType_IntValueNode()
+        {
+            // arrange
+            FloatType type = new FloatType();
+            IntValueNode input = new IntValueNode("123");
+
+            // act
+            bool result = type.IsInstanceOfType(input);
+
+            // assert
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void ParseLiteral_IntValueNode()
+        {
+            // arrange
+            FloatType type = new FloatType();
+            IntValueNode input = new IntValueNode("123");
+
+            // act
+            object result = type.ParseLiteral(input);
+
+            // assert
+            Assert.IsType<double>(result);
+            Assert.Equal(123d, result);
+        }
     }
 }

src/Core.Tests/Validation/DirectivesAreDefinedRuleTests.cs

@@ -0,0 +1,59 @@
+using HotChocolate.Language;
+using Xunit;
+
+namespace HotChocolate.Validation
+{
+    public class DirectivesAreDefinedRuleTests
+        : ValidationTestBase
+    {
+        public DirectivesAreDefinedRuleTests()
+            : base(new DirectivesAreDefinedRule())
+        {
+        }
+
+        [Fact]
+        public void SupportedDirective()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        name @skip(if: true)
+                    }
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+        [Fact]
+        public void UnsupportedDirective()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        name @foo(bar: true)
+                    }
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(
+                    "The specified directive `foo` " +
+                    "is not supported by the current schema.",
+                    t.Message));
+        }
+    }
+}

src/Core.Tests/Validation/FragmentSpreadIsPossibleRuleTests.cs

@@ -0,0 +1,114 @@
+using HotChocolate.Language;
+using Xunit;
+
+namespace HotChocolate.Validation
+{
+    public class FragmentSpreadIsPossibleRuleTests
+        : ValidationTestBase
+    {
+        public FragmentSpreadIsPossibleRuleTests()
+            : base(new FragmentSpreadIsPossibleRule())
+        {
+        }
+
+        [Fact]
+        public void FragmentDoesNotMatchType()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...fragmentDoesNotMatchType
+                    }
+                }
+
+                fragment fragmentDoesNotMatchType on Human {
+                    name
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(t.Message,
+                    "The parent type does not match the type condition on " +
+                    "the fragment `fragmentDoesNotMatchType`."));
+        }
+
+        [Fact]
+        public void InterfaceTypeDoesMatch()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...interfaceTypeDoesMatch
+                    }
+                }
+
+                fragment interfaceTypeDoesMatch on Pet {
+                    name
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+        [Fact]
+        public void UnionTypeDoesMatch()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...unionTypeDoesMatch
+                    }
+                }
+
+                fragment unionTypeDoesMatch on CatOrDog {
+                    name
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+
+         [Fact]
+        public void ObjectTypeDoesMatch()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...objectTypeDoesMatch
+                    }
+                }
+
+                fragment objectTypeDoesMatch on Dog {
+                    name
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+    }
+}

src/Core.Tests/Validation/FragmentSpreadTargetDefinedRuleTests.cs

@@ -0,0 +1,62 @@
+using HotChocolate.Language;
+using Xunit;
+
+namespace HotChocolate.Validation
+{
+    public class FragmentSpreadTargetDefinedRuleTests
+        : ValidationTestBase
+    {
+        public FragmentSpreadTargetDefinedRuleTests()
+            : base(new FragmentSpreadTargetDefinedRule())
+        {
+        }
+
+        [Fact]
+        public void UndefinedFragment()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...undefinedFragment
+                    }
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.True(result.HasErrors);
+            Assert.Collection(result.Errors,
+                t => Assert.Equal(t.Message,
+                    "The specified fragment `undefinedFragment` does not exist."));
+        }
+
+        [Fact]
+        public void DefinedFragment()
+        {
+            // arrange
+            Schema schema = ValidationUtils.CreateSchema();
+            DocumentNode query = Parser.Default.Parse(@"
+                {
+                    dog {
+                        ...definedFragment
+                    }
+                }
+
+                fragment definedFragment on Dog
+                {
+                    barkVolume
+                }
+            ");
+
+            // act
+            QueryValidationResult result = Rule.Validate(schema, query);
+
+            // assert
+            Assert.False(result.HasErrors);
+        }
+    }
+}