Disable graphql cache for tests.

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

@@ -10,6 +10,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using GraphQL.Utilities;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 using Squidex.Domain.Apps.Entities.Apps;
 using Squidex.Domain.Apps.Entities.Contents.GraphQL.Types;
 using Squidex.Infrastructure;
@@ -22,14 +23,17 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
         private static readonly TimeSpan CacheDuration = TimeSpan.FromMinutes(10);
         private readonly IMemoryCache cache;
         private readonly IServiceProvider resolver;
+        private readonly GraphQLOptions options;
 
-        public CachingGraphQLService(IMemoryCache cache, IServiceProvider resolver)
+        public CachingGraphQLService(IMemoryCache cache, IServiceProvider resolver, IOptions<GraphQLOptions> options)
         {
             Guard.NotNull(cache, nameof(cache));
             Guard.NotNull(resolver, nameof(resolver));
+            Guard.NotNull(options, nameof(options));
 
             this.cache = cache;
             this.resolver = resolver;
+            this.options = options.Value;
         }
 
         public async Task<(bool HasError, object Response)> QueryAsync(Context context, params GraphQLQuery[] queries)
@@ -81,19 +85,29 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
 
         private Task<GraphQLModel> GetModelAsync(IAppEntity app)
         {
+            if (options.CacheDuration <= 0)
+            {
+                return CreateModelAsync(app);
+            }
+
             var cacheKey = CreateCacheKey(app.Id, app.Version.ToString());
 
             return cache.GetOrCreateAsync(cacheKey, async entry =>
             {
                 entry.AbsoluteExpirationRelativeToNow = CacheDuration;
 
+                return await CreateModelAsync(app);
+            });
+        }
+
+        private async Task<GraphQLModel> CreateModelAsync(IAppEntity app)
+        {
             var allSchemas = await resolver.GetRequiredService<IAppProvider>().GetSchemasAsync(app.Id);
 
             return new GraphQLModel(app,
                 allSchemas,
                 resolver.GetRequiredService<SharedTypes>(),
                 resolver.GetRequiredService<ISemanticLog>());
-            });
         }
 
         private static object CreateCacheKey(DomainId appId, string etag)

backend/src/Squidex.Domain.Apps.Entities/Contents/GraphQL/GraphQLOptions.cs

@@ -0,0 +1,14 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
+{
+    public sealed class GraphQLOptions
+    {
+        public int CacheDuration { get; set; } = 10 * 60;
+    }
+}

backend/src/Squidex/Config/Domain/QueryServices.cs

@@ -21,6 +21,8 @@ namespace Squidex.Config.Domain
         {
             var exposeSourceUrl = config.GetOptionalValue("assetStore:exposeSourceUrl", true);
 
+            services.Configure<GraphQLOptions>(config, "graphql");
+
             services.AddSingletonAs(c => ActivatorUtilities.CreateInstance<UrlGenerator>(c, exposeSourceUrl))
                 .As<IUrlGenerator>();
 

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

@@ -10,6 +10,7 @@ using System.Collections.Generic;
 using FakeItEasy;
 using GraphQL.DataLoader;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Squidex.Domain.Apps.Core;
@@ -139,52 +140,40 @@ namespace Squidex.Domain.Apps.Entities.Contents.GraphQL
             return serializer.Serialize(result);
         }
 
-        public sealed class TestServiceProvider : IServiceProvider
+        private CachingGraphQLService CreateSut()
         {
-            private readonly Dictionary<Type, object> services;
+            var cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
 
-            public TestServiceProvider(GraphQLTestBase testBase)
-            {
             var appProvider = A.Fake<IAppProvider>();
 
-                A.CallTo(() => appProvider.GetSchemasAsync(testBase.appId.Id))
+            A.CallTo(() => appProvider.GetSchemasAsync(appId.Id))
                 .Returns(new List<ISchemaEntity>
                 {
-                        testBase.schema,
-                        testBase.schemaRef1,
-                        testBase.schemaRef2,
-                        testBase.schemaInvalidName
+                    schema,
+                    schemaRef1,
+                    schemaRef2,
+                    schemaInvalidName
                 });
 
-                var dataLoaderContext = new DataLoaderContextAccessor();
-
-                var urlGenerator = new FakeUrlGenerator();
-
-                services = new Dictionary<Type, object>
-                {
-                    [typeof(IAppProvider)] = appProvider,
-                    [typeof(IAssetQueryService)] = testBase.assetQuery,
-                    [typeof(ICommandBus)] = testBase.commandBus,
-                    [typeof(IContentQueryService)] = testBase.contentQuery,
-                    [typeof(IDataLoaderContextAccessor)] = dataLoaderContext,
-                    [typeof(IUrlGenerator)] = urlGenerator,
-                    [typeof(ISemanticLog)] = A.Fake<ISemanticLog>(),
-                    [typeof(DataLoaderDocumentListener)] = new DataLoaderDocumentListener(dataLoaderContext),
-                    [typeof(SharedTypes)] = new SharedTypes(urlGenerator)
-                };
-            }
-
-            public object GetService(Type serviceType)
-            {
-                return services.GetOrDefault(serviceType);
-            }
-        }
-
-        private CachingGraphQLService CreateSut()
-        {
-            var cache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
-
-            return new CachingGraphQLService(cache, new TestServiceProvider(this));
+            var dataLoaderContext = (IDataLoaderContextAccessor)new DataLoaderContextAccessor();
+            var dataLoaderListener = new DataLoaderDocumentListener(dataLoaderContext);
+
+            var services =
+                new ServiceCollection()
+                    .AddMemoryCache()
+                    .AddSingleton(A.Fake<ISemanticLog>())
+                    .AddSingleton(appProvider)
+                    .AddSingleton(assetQuery)
+                    .AddSingleton(commandBus)
+                    .AddSingleton(contentQuery)
+                    .AddSingleton(dataLoaderContext)
+                    .AddSingleton(dataLoaderListener)
+                    .AddSingleton<SharedTypes>()
+                    .AddSingleton<IUrlGenerator,
+                        FakeUrlGenerator>()
+                    .BuildServiceProvider();
+
+            return new CachingGraphQLService(cache, services, Options.Create(new GraphQLOptions()));
         }
     }
 }

backend/tests/docker-compose.yml

@@ -18,6 +18,7 @@ services:
       - IDENTITY__ADMINCLIENTSECRET=xeLd6jFxqbXJrfmNLlO2j1apagGGGSyZJhFnIuHp4I0=
       - STORE__MONGODB__CONFIGURATION=mongodb://mongo
       - STORE__TYPE=MongoDB
+      - GRAPHQL__CACHEDURATION=0
     networks:
       - internal
     depends_on:

backend/tools/TestSuite/TestSuite.ApiTests/GraphQLTests.cs

@@ -19,7 +19,6 @@ using Xunit;
 
 namespace TestSuite.ApiTests
 {
-    [Trait("Category", "NotAutomated")]
     public sealed class GraphQLTests : IClassFixture<ContentFixture>
     {
         public ContentFixture _ { get; }