Added more tests

src/Core/Core.Tests/Execution/Batching/BatchQueryExecutorTests.cs

@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using HotChocolate;
 using HotChocolate.StarWars;
 using HotChocolate.Subscriptions;
+using HotChocolate.Types;
 using Microsoft.Extensions.DependencyInjection;
 using Snapshooter;
 using Snapshooter.Xunit;
@@ -150,5 +152,191 @@ mutation secondReview {
                 r => r.MatchSnapshot(new SnapshotNameExtension("1")),
                 r => r.MatchSnapshot(new SnapshotNameExtension("2")));
         }
+
+        [Fact]
+        public async Task ExecuteExportLeafList()
+        {
+            // arrange
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection
+                .AddSingleton<ISchema>(sp => SchemaBuilder.New()
+                    .AddServices(sp)
+                    .AddDirectiveType<ExportDirectiveType>()
+                    .AddQueryType(d => d.Name("Query")
+                        .Field("foo")
+                        .Argument("bar", a => a.Type<ListType<StringType>>())
+                        .Type<ListType<StringType>>()
+                        .Resolver<List<string>>(c =>
+                        {
+                            var list = c.Argument<List<string>>("bar");
+                            if (list == null)
+                            {
+                                return new List<string>
+                                {
+                                    "123",
+                                    "456"
+                                };
+                            }
+                            else
+                            {
+                                list.Add("789");
+                                return list;
+                            }
+                        }))
+                    .Create())
+                    .AddSingleton<IBatchQueryExecutor, BatchQueryExecutor>();
+
+            QueryExecutionBuilder.BuildDefault(serviceCollection);
+
+            IServiceProvider services =
+                serviceCollection.BuildServiceProvider();
+
+            var executor = services.GetService<IBatchQueryExecutor>();
+
+            // act
+            var batch = new List<IReadOnlyQueryRequest>
+            {
+                QueryRequestBuilder.New()
+                    .SetQuery(
+                        @"{
+                            foo @export(as: ""b"")
+                        }")
+                    .Create(),
+                QueryRequestBuilder.New()
+                    .SetQuery(
+                        @"{
+                            foo(bar: $b)
+                        }")
+                    .Create()
+            };
+
+            IResponseStream stream =
+                await executor.ExecuteAsync(batch, CancellationToken.None);
+
+            var results = new List<IReadOnlyQueryResult>();
+            while (!stream.IsCompleted)
+            {
+                IReadOnlyQueryResult result = await stream.ReadAsync();
+                if (result != null)
+                {
+                    results.Add(result);
+                }
+            }
+
+            Assert.Collection(results,
+                r => r.MatchSnapshot(new SnapshotNameExtension("1")),
+                r => r.MatchSnapshot(new SnapshotNameExtension("2")));
+        }
+
+        [Fact]
+        public async Task ExecuteExportObjectList()
+        {
+            // arrange
+            var serviceCollection = new ServiceCollection();
+
+            serviceCollection
+                .AddSingleton<ISchema>(sp => SchemaBuilder.New()
+                    .AddServices(sp)
+                    .AddDirectiveType<ExportDirectiveType>()
+                    .AddDocumentFromString(
+                    @"
+                    type Query {
+                        foo(f: [FooInput]) : [Foo]
+                    }
+
+                    type Foo {
+                        bar: String!
+                    }
+
+                    input FooInput {
+                        bar: String!
+                    }
+                    ")
+                    .AddResolver("Query", "foo", c =>
+                    {
+                        var list =
+                            c.Argument<List<object>>("f");
+                        if (list == null)
+                        {
+                            return new List<object>
+                            {
+                                new Dictionary<string, object>
+                                {
+                                    { "bar" , "123" }
+                                }
+                            };
+                        }
+                        else
+                        {
+                            list.Add(new Dictionary<string, object>
+                            {
+                                { "bar" , "456" }
+                            });
+                            return list;
+                        }
+                    })
+                    .Use(next => context =>
+                    {
+                        object o = context.Parent<object>();
+                        if (o is Dictionary<string, object> d
+                            && d.TryGetValue(
+                                context.ResponseName,
+                                out object v))
+                        {
+                            context.Result = v;
+                        }
+                        return next(context);
+                    })
+                    .Create())
+                    .AddSingleton<IBatchQueryExecutor, BatchQueryExecutor>();
+
+            QueryExecutionBuilder.BuildDefault(serviceCollection);
+
+            IServiceProvider services =
+                serviceCollection.BuildServiceProvider();
+
+            var executor = services.GetService<IBatchQueryExecutor>();
+
+            // act
+            var batch = new List<IReadOnlyQueryRequest>
+            {
+                QueryRequestBuilder.New()
+                    .SetQuery(
+                        @"{
+                            foo @export(as: ""b"")
+                            {
+                                bar
+                            }
+                        }")
+                    .Create(),
+                QueryRequestBuilder.New()
+                    .SetQuery(
+                        @"{
+                            foo(f: $b)
+                            {
+                                bar
+                            }
+                        }")
+                    .Create()
+            };
+
+            IResponseStream stream =
+                await executor.ExecuteAsync(batch, CancellationToken.None);
+
+            var results = new List<IReadOnlyQueryResult>();
+            while (!stream.IsCompleted)
+            {
+                IReadOnlyQueryResult result = await stream.ReadAsync();
+                if (result != null)
+                {
+                    results.Add(result);
+                }
+            }
+
+            Assert.Collection(results,
+                r => r.MatchSnapshot(new SnapshotNameExtension("1")),
+                r => r.MatchSnapshot(new SnapshotNameExtension("2")));
+        }
     }
 }

src/Core/Core.Tests/Execution/Batching/__snapshots__/BatchQueryExecutorTests.ExecuteExportLeafList_1.snap

@@ -0,0 +1,11 @@
+{
+  "Data": {
+    "foo": [
+      "123",
+      "456"
+    ]
+  },
+  "Extensions": {},
+  "Errors": [],
+  "ContextData": {}
+}

src/Core/Core.Tests/Execution/Batching/__snapshots__/BatchQueryExecutorTests.ExecuteExportLeafList_2.snap

@@ -0,0 +1,12 @@
+{
+  "Data": {
+    "foo": [
+      "123",
+      "456",
+      "789"
+    ]
+  },
+  "Extensions": {},
+  "Errors": [],
+  "ContextData": {}
+}

src/Core/Core.Tests/Execution/Batching/__snapshots__/BatchQueryExecutorTests.ExecuteExportObjectList_1.snap

@@ -0,0 +1,12 @@
+{
+  "Data": {
+    "foo": [
+      {
+        "bar": "123"
+      }
+    ]
+  },
+  "Extensions": {},
+  "Errors": [],
+  "ContextData": {}
+}

src/Core/Core.Tests/Execution/Batching/__snapshots__/BatchQueryExecutorTests.ExecuteExportObjectList_2.snap

@@ -0,0 +1,15 @@
+{
+  "Data": {
+    "foo": [
+      {
+        "bar": "123"
+      },
+      {
+        "bar": "456"
+      }
+    ]
+  },
+  "Extensions": {},
+  "Errors": [],
+  "ContextData": {}
+}

src/Core/Core/Execution/Utilities/DirectiveContext.cs

@@ -75,6 +75,9 @@ public IImmutableDictionary<string, object> ScopedContextData
             set => _middlewareContext.ScopedContextData = value;
         }
 
+        public NameString ResponseName =>
+            _middlewareContext.ResponseName;
+
         public T Argument<T>(NameString name) =>
             _middlewareContext.Argument<T>(name);
 

src/Core/Core/Execution/Utilities/ResolverContext.cs

@@ -48,6 +48,8 @@ internal partial class ResolverContext
 
         public FieldNode FieldSelection => _fieldSelection.Selection;
 
+        NameString IResolverContext.ResponseName => _fieldSelection.ResponseName;
+
         public string ResponseName => _fieldSelection.ResponseName;
 
         public IImmutableStack<object> Source { get; private set; }

src/Core/Types/Resolvers/IResolverContext.cs

@@ -45,6 +45,12 @@ public interface IResolverContext
         /// </summary>
         FieldNode FieldSelection { get; }
 
+        /// <summary>
+        /// Gets the name that the field will have in the response map.
+        /// </summary>
+        /// <value></value>
+        NameString ResponseName { get; }
+
         /// <summary>
         /// Gets the source stack containing all previous resolver results
         /// of the current execution path.