Tests for graphl batching.

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/CachingGraphQLService.cs

@@ -42,7 +42,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
             this.urlGenerator = urlGenerator;
         }
 
-        public async Task<(bool HasError, object[] Response)> QueryAsync(QueryContext context, GraphQLQuery[] queries)
+        public async Task<(bool HasError, object Response)> QueryAsync(QueryContext context, params GraphQLQuery[] queries)
         {
             Guard.NotNull(context, nameof(context));
             Guard.NotNull(queries, nameof(queries));
@@ -74,18 +74,18 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
         {
             if (string.IsNullOrWhiteSpace(query.Query))
             {
-                return (false, new { Data = new object() });
+                return (false, new { data = new object() });
             }
 
             var result = await model.ExecuteAsync(ctx, query);
 
             if (result.Errors?.Any() == true)
             {
-                return (false, new { result.Data, result.Errors });
+                return (false, new { data = result.Data, errors = result.Errors });
             }
             else
             {
-                return (false, new { result.Data });
+                return (false, new { data = result.Data });
             }
         }
 

src/Squidex.Domain.Apps.Entities/Contents/GraphQL/IGraphQLService.cs

@@ -11,8 +11,8 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 {
     public interface IGraphQLService
     {
-        Task<(bool HasError, object[] Response)> QueryAsync(QueryContext context, GraphQLQuery[] queries);
+        Task<(bool HasError, object Response)> QueryAsync(QueryContext context, params GraphQLQuery[] queries);
 
-        Task<(bool HasError, object[] Response)> QueryAsync(QueryContext context, GraphQLQuery query);
+        Task<(bool HasError, object Response)> QueryAsync(QueryContext context, GraphQLQuery query);
     }
 }

tests/Squidex.Domain.Apps.Entities.Tests/Contents/GraphQL/GraphQLQueriesTests.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Threading.Tasks;
 using FakeItEasy;
+using Newtonsoft.Json.Linq;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Infrastructure;
 using Xunit;
@@ -173,7 +174,7 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
         public async Task Should_return_single_asset_when_finding_asset()
         {
             var assetId = Guid.NewGuid();
-            var asset = CreateAsset(Guid.NewGuid());
+            var asset = CreateAsset(assetId);
 
             var query = $@"
                 query {{
@@ -713,6 +714,61 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
             AssertResult(expected, result);
         }
 
+        [Fact]
+        public async Task Should_make_multiple_queries()
+        {
+            var assetId1 = Guid.NewGuid();
+            var assetId2 = Guid.NewGuid();
+            var asset1 = CreateAsset(assetId1);
+            var asset2 = CreateAsset(assetId2);
+
+            var query1 = $@"
+                query {{
+                  findAsset(id: ""{assetId1}"") {{
+                    id
+                  }}
+                }}";
+            var query2 = $@"
+                query {{
+                  findAsset(id: ""{assetId2}"") {{
+                    id
+                  }}
+                }}";
+
+            A.CallTo(() => assetQuery.FindAssetAsync(MatchsAssetContext(), assetId1))
+                .Returns(asset1);
+            A.CallTo(() => assetQuery.FindAssetAsync(MatchsAssetContext(), assetId2))
+                .Returns(asset2);
+
+            var result = await sut.QueryAsync(context, new GraphQLQuery { Query = query1 }, new GraphQLQuery { Query = query2 });
+
+            var expected = new object[]
+            {
+                new
+                {
+                    data = new
+                    {
+                        findAsset = new
+                        {
+                            id = asset1.Id
+                        }
+                    }
+                },
+                new
+                {
+                    data = new
+                    {
+                        findAsset = new
+                        {
+                            id = asset2.Id
+                        }
+                    }
+                }
+            };
+
+            AssertResult(expected, result);
+        }
+
         [Fact]
         public async Task Should_not_return_data_when_field_not_part_of_content()
         {
@@ -742,12 +798,9 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
             var result = await sut.QueryAsync(context, new GraphQLQuery { Query = query });
 
-            var expected = new
+            var json = JToken.FromObject(result);
-            {
-                data = (object)null
-            };
 
-            AssertResult(expected, result, false);
+            Assert.Null(json["data"]);
         }
 
         private QueryContext MatchsAssetContext()

tests/Squidex.Domain.Apps.Entities.Tests/Contents/GraphQL/GraphQLTestBase.cs

@@ -13,6 +13,7 @@ using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
 using NodaTime.Extensions;
 using Squidex.Domain.Apps.Core;
 using Squidex.Domain.Apps.Core.Apps;
@@ -174,17 +175,22 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
             return asset;
         }
 
-        protected static void AssertResult(object expected, (object Data, object[] Errors) result, bool checkErrors = true)
+        protected static void AssertResult(object expected, (bool HasErrors, object Response) result, bool checkErrors = true)
         {
-            if (checkErrors && (result.Errors != null && result.Errors.Length > 0))
+            if (checkErrors && result.HasErrors)
             {
-                throw new InvalidOperationException(result.Errors[0]?.ToString());
+                throw new InvalidOperationException(NewMethod(result));
             }
 
-            var resultJson = JsonConvert.SerializeObject(new { data = result.Data }, Formatting.Indented);
+            var resultJson = JsonConvert.SerializeObject(result.Response, Formatting.Indented);
             var expectJson = JsonConvert.SerializeObject(expected, Formatting.Indented);
 
             Assert.Equal(expectJson, resultJson);
         }
+
+        private static string NewMethod((bool HasErrors, object Response) result)
+        {
+            return JsonConvert.SerializeObject(result).ToString();
+        }
     }
 }