Added directive middleware integration tests (#330)

Author: michaelstaib

src/Core.Tests/Integration/Directives/ConstantDirectiveType.cs

@@ -0,0 +1,27 @@
+using ChilliCream.Testing;
+using HotChocolate.Execution;
+using HotChocolate.Types;
+using Xunit;
+
+namespace HotChocolate.Integration.Directives
+{
+    public class ConstantDirectiveType
+        : DirectiveType
+    {
+        protected override void Configure(IDirectiveTypeDescriptor descriptor)
+        {
+            descriptor.Name("constant");
+            descriptor.Argument("value").Type<StringType>();
+
+            descriptor.Location(DirectiveLocation.Object)
+                .Location(DirectiveLocation.FieldDefinition)
+                .Location(DirectiveLocation.Field);
+
+            descriptor.Middleware(next => context =>
+            {
+                context.Result = context.Directive.GetArgument<string>("value");
+                return next(context);
+            });
+        }
+    }
+}

src/Core.Tests/Integration/Directives/DirectiveIntegrationTests.cs

@@ -0,0 +1,44 @@
+using ChilliCream.Testing;
+using HotChocolate.Execution;
+using Xunit;
+
+namespace HotChocolate.Integration.Directives
+{
+    public class DirectiveIntegrationTests
+    {
+        [Fact]
+        public void UniqueDirectives_OnFieldLevel_OverwriteOnesOnObjectLevel()
+        {
+            // arrange
+            ISchema schema = CreateSchema();
+
+            // act
+            IExecutionResult result = schema.Execute("{ bar baz }");
+
+            // assert
+            result.Snapshot();
+        }
+
+        [Fact]
+        public void UniqueDirectives_FieldSelection_OverwriteTypeSystemOnes()
+        {
+            // arrange
+            ISchema schema = CreateSchema();
+
+            // act
+            IExecutionResult result = schema.Execute(
+                "{ bar baz @constant(value: \"baz\") }");
+
+            // assert
+            result.Snapshot();
+        }
+
+        private static ISchema CreateSchema()
+        {
+            return Schema.Create(
+                "type Query @constant(value: \"foo\") " +
+                "{ bar: String baz: String @constant(value: \"bar\")  }",
+                c => c.RegisterDirective<ConstantDirectiveType>());
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using HotChocolate.Types;
 
 namespace HotChocolate.Integration.StarWarsCodeFirst
 {

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

@@ -699,11 +699,15 @@ private static Schema CreateSchema(int executionDepth)
             return Schema.Create(c =>
             {
                 c.Options.MaxExecutionDepth = executionDepth;
+
                 c.RegisterServiceProvider(serviceProvider.Object);
+
                 c.RegisterDataLoader<HumanDataLoader>();
+
                 c.RegisterQueryType<QueryType>();
                 c.RegisterMutationType<MutationType>();
                 c.RegisterSubscriptionType<SubscriptionType>();
+
                 c.RegisterType<HumanType>();
                 c.RegisterType<DroidType>();
                 c.RegisterType<EpisodeType>();

src/Core.Tests/__snapshots__/UniqueDirectives_FieldSelection_OverwriteTypeSystemOnes.json

@@ -0,0 +1,7 @@
+{
+  "Data": {
+    "bar": "foo",
+    "baz": "baz"
+  },
+  "Errors": null
+}

src/Core.Tests/__snapshots__/UniqueDirectives_OnFieldLevel_OverwriteOnesOnObjectLevel.json

@@ -0,0 +1,7 @@
+{
+  "Data": {
+    "bar": "foo",
+    "baz": "bar"
+  },
+  "Errors": null
+}

src/Core/Execution/Utilities/DirectiveCollector.cs

@@ -84,24 +84,25 @@ private IReadOnlyCollection<IDirective> CollectDirectives(
             HashSet<string> processed = new HashSet<string>();
             List<IDirective> directives = new List<IDirective>();
 
-            CollectInheritedDirectives(processed, directives, field);
-            CollectSelectionDirectives(processed, directives, fieldSelection);
+            CollectTypeSystemDirectives(processed, directives, field);
+            CollectQueryDirectives(processed, directives, fieldSelection);
 
             return directives.AsReadOnly();
         }
 
-        private void CollectSelectionDirectives(
+        private void CollectQueryDirectives(
             HashSet<string> processed,
             List<IDirective> directives,
             FieldNode fieldSelection)
         {
             foreach (IDirective directive in
                 GetFieldSelectionDirectives(fieldSelection))
             {
-                if (processed.Add(directive.Name))
+                if (!processed.Add(directive.Name))
                 {
-                    directives.Add(directive);
+                    directives.Remove(directive);
                 }
+                directives.Add(directive);
             }
         }
 
@@ -122,17 +123,18 @@ private IEnumerable<IDirective> GetFieldSelectionDirectives(
             }
         }
 
-        private void CollectInheritedDirectives(
+        private void CollectTypeSystemDirectives(
             HashSet<string> processed,
             List<IDirective> directives,
             ObjectField field)
         {
             foreach (IDirective directive in field.ExecutableDirectives)
             {
-                if (processed.Add(directive.Name))
+                if (!processed.Add(directive.Name))
                 {
-                    directives.Add(directive);
+                    directives.Remove(directive);
                 }
+                directives.Add(directive);
             }
         }
     }

src/Types/Types/ObjectField.cs

@@ -127,10 +127,11 @@ private void AddExectableDirectives(
             foreach (IDirective directive in
                 directives.Where(t => t.IsExecutable))
             {
-                if (processed.Add(directive.Name))
+                if (processed.Contains(directive.Name))
                 {
-                    _executableDirectives.Add(directive);
+                    _executableDirectives.Remove(directive);
                 }
+                _executableDirectives.Add(directive);
             }
         }