Tests simplified.

tests/Squidex.Domain.Apps.Read.Tests/Apps/CachingAppProviderTests.cs

@@ -65,7 +65,7 @@ namespace Squidex.Domain.Apps.Read.Apps
         public async Task Should_also_retrieve_app_by_name_if_retrieved_by_id_before()
         {
             A.CallTo(() => repository.FindAppAsync(appId.Id))
-                .Returns(Task.FromResult(appV1));
+                .Returns(appV1);
 
             await ProvideAppByIdAsync(appV1);
             await ProvideAppByNameAsync(appV1);
@@ -78,7 +78,7 @@ namespace Squidex.Domain.Apps.Read.Apps
         public async Task Should_also_retrieve_app_by_id_if_retrieved_by_name_before()
         {
             A.CallTo(() => repository.FindAppAsync(appId.Name))
-                .Returns(Task.FromResult(appV1));
+                .Returns(appV1);
 
             await ProvideAppByNameAsync(appV1);
             await ProvideAppByIdAsync(appV1);

tests/Squidex.Domain.Apps.Read.Tests/Contents/ContentQueryServiceTests.cs

@@ -54,7 +54,8 @@ namespace Squidex.Domain.Apps.Read.Contents
         [Fact]
         public async Task Should_return_schema_from_id_if_string_is_guid()
         {
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(schema);
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false))
+                .Returns(schema);
 
             var result = await sut.FindSchemaAsync(app, schemaId.ToString());
 
@@ -64,7 +65,8 @@ namespace Squidex.Domain.Apps.Read.Contents
         [Fact]
         public async Task Should_return_schema_from_name_if_string_not_guid()
         {
-            A.CallTo(() => schemas.FindSchemaByNameAsync(appId, "my-schema")).Returns(schema);
+            A.CallTo(() => schemas.FindSchemaByNameAsync(appId, "my-schema"))
+                .Returns(schema);
 
             var result = await sut.FindSchemaAsync(app, "my-schema");
 
@@ -74,7 +76,8 @@ namespace Squidex.Domain.Apps.Read.Contents
         [Fact]
         public async Task Should_throw_if_schema_not_found()
         {
-            A.CallTo(() => schemas.FindSchemaByNameAsync(appId, "my-schema")).Returns(Task.FromResult<ISchemaEntity>(null));
+            A.CallTo(() => schemas.FindSchemaByNameAsync(appId, "my-schema"))
+                .Returns((ISchemaEntity)null);
 
             await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.FindSchemaAsync(app, "my-schema"));
         }
@@ -82,12 +85,16 @@ namespace Squidex.Domain.Apps.Read.Contents
         [Fact]
         public async Task Should_return_content_from_repository_and_transform()
         {
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult(schema));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false))
-            A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId)).Returns(content);
+                .Returns(schema);
+            A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId))
+                .Returns(content);
 
-            A.CallTo(() => schema.ScriptQuery).Returns("<script-query>");
+            A.CallTo(() => schema.ScriptQuery)
+                .Returns("<script-query>");
 
-            A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<script-query>")).Returns(transformedData);
+            A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<query-script>"))
+                .Returns(transformedData);
 
             var result = await sut.FindContentAsync(app, schemaId.ToString(), user, contentId);
 
@@ -99,8 +106,10 @@ namespace Squidex.Domain.Apps.Read.Contents
         [Fact]
         public async Task Should_throw_if_content_to_find_does_not_exist()
         {
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult(schema));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false))
-            A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId)).Returns(Task.FromResult<IContentEntity>(null));
+                .Returns(schema);
+            A.CallTo(() => contentRepository.FindContentAsync(app, schema, contentId))
+                .Returns((IContentEntity)null);
 
             await Assert.ThrowsAsync<DomainObjectNotFoundException>(async () => await sut.FindContentAsync(app, schemaId.ToString(), user, contentId));
         }
@@ -110,13 +119,18 @@ namespace Squidex.Domain.Apps.Read.Contents
         {
             var ids = new HashSet<Guid>();
 
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult(schema));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false))
-            A.CallTo(() => contentRepository.QueryAsync(app, schema, false, ids, A<ODataUriParser>.Ignored)).Returns(Task.FromResult<IReadOnlyList<IContentEntity>>(new List<IContentEntity> { content }));
+                .Returns(schema);
-            A.CallTo(() => contentRepository.CountAsync(app, schema, false, ids, A<ODataUriParser>.Ignored)).Returns(123);
+            A.CallTo(() => contentRepository.QueryAsync(app, schema, false, ids, A<ODataUriParser>.Ignored))
+                .Returns(new List<IContentEntity> { content });
+            A.CallTo(() => contentRepository.CountAsync(app, schema, false, ids, A<ODataUriParser>.Ignored))
+                .Returns(123);
 
-            A.CallTo(() => schema.ScriptQuery).Returns("<script-query>");
+            A.CallTo(() => schema.ScriptQuery)
+                .Returns("<script-query>");
 
-            A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<script-query>")).Returns(transformedData);
+            A.CallTo(() => scriptEngine.Transform(A<ScriptContext>.That.Matches(x => x.User == user && x.ContentId == contentId && ReferenceEquals(x.Data, data)), "<query-script>"))
+                .Returns(transformedData);
 
             var result = await sut.QueryWithCountAsync(app, schemaId.ToString(), user, ids, null);
 

tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs

@@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Read.Contents
 
             var allSchemas = new List<ISchemaEntity> { schema };
 
-            A.CallTo(() => schemaRepository.QueryAllAsync(appId)).Returns(Task.FromResult<IReadOnlyList<ISchemaEntity>>(allSchemas));
+            A.CallTo(() => schemaRepository.QueryAllAsync(appId)).Returns(allSchemas);
 
             sut = new CachingGraphQLService(cache, assetRepository, contentQuery, new FakeUrlGenerator(), schemaRepository);
         }
@@ -116,7 +116,7 @@ namespace Squidex.Domain.Apps.Read.Contents
             var assets = new List<IAssetEntity> { asset };
 
             A.CallTo(() => assetRepository.QueryAsync(app.Id, null, null, "my-query", 30, 5))
-                .Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(assets));
+                .Returns(assets);
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -181,7 +181,7 @@ namespace Squidex.Domain.Apps.Read.Contents
                 }}";
 
             A.CallTo(() => assetRepository.FindAssetAsync(assetId))
-                .Returns(Task.FromResult(asset));
+                .Returns(asset);
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -255,7 +255,7 @@ namespace Squidex.Domain.Apps.Read.Contents
             var contents = new List<IContentEntity> { content };
 
             A.CallTo(() => contentQuery.QueryWithCountAsync(app, schema.Id.ToString(), user, null, "?$top=30&$skip=5"))
-                .Returns(Task.FromResult((schema, 0L, (IReadOnlyList<IContentEntity>)contents)));
+                .Returns((schema, 0L, (IReadOnlyList<IContentEntity>)contents));
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -356,7 +356,7 @@ namespace Squidex.Domain.Apps.Read.Contents
                 }}";
 
             A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId))
-                .Returns(Task.FromResult((schema, content)));
+                .Returns((schema, content));
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -440,10 +440,10 @@ namespace Squidex.Domain.Apps.Read.Contents
             var refContents = new List<IContentEntity> { contentRef };
 
             A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId))
-                .Returns(Task.FromResult((schema, content)));
+                .Returns((schema, content));
 
             A.CallTo(() => contentQuery.QueryWithCountAsync(app, schema.Id.ToString(), user, A<HashSet<Guid>>.That.Matches(x => x.Contains(contentRefId)), null))
-                .Returns(Task.FromResult((schema, 0L, (IReadOnlyList<IContentEntity>)refContents)));
+                .Returns((schema, 0L, (IReadOnlyList<IContentEntity>)refContents));
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -500,10 +500,10 @@ namespace Squidex.Domain.Apps.Read.Contents
             var refAssets = new List<IAssetEntity> { assetRef };
 
             A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId))
-                .Returns(Task.FromResult((schema, content)));
+                .Returns((schema, content));
 
             A.CallTo(() => assetRepository.QueryAsync(app.Id, null, A<HashSet<Guid>>.That.Matches(x => x.Contains(assetRefId)), null, int.MaxValue, 0))
-                .Returns(Task.FromResult<IReadOnlyList<IAssetEntity>>(refAssets));
+                .Returns(refAssets);
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 
@@ -559,7 +559,7 @@ namespace Squidex.Domain.Apps.Read.Contents
                 }}";
 
             A.CallTo(() => contentQuery.FindContentAsync(app, schema.Id.ToString(), user, contentId))
-                .Returns(Task.FromResult((schema, content)));
+                .Returns((schema, content));
 
             var result = await sut.QueryAsync(app, user, new GraphQLQuery { Query = query });
 

tests/Squidex.Domain.Apps.Read.Tests/Schemas/CachingSchemaProviderTests.cs

@@ -68,7 +68,7 @@ namespace Squidex.Domain.Apps.Read.Schemas
         public async Task Should_also_retrieve_schema_by_name_if_retrieved_by_id_before()
         {
             A.CallTo(() => repository.FindSchemaAsync(schemaId.Id, false))
-                .Returns(Task.FromResult(schemaV1));
+                .Returns(schemaV1);
 
             await ProvideSchemaById(schemaV1);
             await ProvideSchemaByName(schemaV1);
@@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Read.Schemas
         public async Task Should_also_retrieve_schema_by_id_if_retrieved_by_name_before()
         {
             A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name))
-                .Returns(Task.FromResult(schemaV1));
+                .Returns(schemaV1);
 
             await ProvideSchemaByName(schemaV1);
             await ProvideSchemaById(schemaV1);

tests/Squidex.Domain.Apps.Read.Tests/Webhooks/WebhookDequeuerTests.cs

@@ -89,7 +89,7 @@ namespace Squidex.Domain.Apps.Read.Webhooks
         private void SetupSender(IWebhookEventEntity @event, string requestDump, WebhookResult requestResult, TimeSpan requestTime)
         {
             A.CallTo(() => webhookSender.SendAsync(@event.Job))
-                .Returns(Task.FromResult((requestDump, requestResult, requestTime)));
+                .Returns((requestDump, requestResult, requestTime));
         }
 
         private void SetupPendingEvents(IWebhookEventEntity @event)

tests/Squidex.Domain.Apps.Read.Tests/Webhooks/WebhookEnqueuerTests.cs

@@ -77,7 +77,7 @@ namespace Squidex.Domain.Apps.Read.Webhooks
             var webhook2 = CreateWebhook(2);
 
             A.CallTo(() => webhookRepository.QueryByAppAsync(appId.Id))
-                .Returns(Task.FromResult<IReadOnlyList<IWebhookEntity>>(new List<IWebhookEntity> { webhook1, webhook2 }));
+                .Returns(new List<IWebhookEntity> { webhook1, webhook2 });
 
             await sut.On(@event);
 

tests/Squidex.Domain.Apps.Write.Tests/Apps/AppCommandHandlerTests.cs

@@ -50,7 +50,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId });
 
             A.CallTo(() => appRepository.FindAppAsync(AppName))
-                .Returns(Task.FromResult(A.Dummy<IAppEntity>()));
+                .Returns(A.Dummy<IAppEntity>());
 
             await TestCreate(app, async _ =>
             {
@@ -66,7 +66,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId });
 
             A.CallTo(() => appRepository.FindAppAsync(AppName))
-                .Returns(Task.FromResult<IAppEntity>(null));
+                .Returns((IAppEntity)null);
 
             await TestCreate(app, async _ =>
             {
@@ -84,7 +84,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
             A.CallTo(() => userResolver.FindByIdAsync(contributorId))
-                .Returns(Task.FromResult<IUser>(null));
+                .Returns((IUser)null);
 
             await TestUpdate(app, async _ =>
             {
@@ -105,7 +105,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
             A.CallTo(() => userResolver.FindByIdAsync(A<string>.Ignored))
-                .Returns(Task.FromResult(A.Dummy<IUser>()));
+                .Returns(A.Dummy<IUser>());
 
             await TestUpdate(app, async _ =>
             {
@@ -121,7 +121,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
             A.CallTo(() => userResolver.FindByIdAsync(contributorId))
-                .Returns(Task.FromResult<IUser>(null));
+                .Returns((IUser)null);
 
             await TestUpdate(app, async _ =>
             {
@@ -140,7 +140,7 @@ namespace Squidex.Domain.Apps.Write.Apps
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
             A.CallTo(() => userResolver.FindByIdAsync(contributorId))
-                .Returns(Task.FromResult(A.Dummy<IUser>()));
+                .Returns(A.Dummy<IUser>());
 
             await TestUpdate(app, async _ =>
             {

tests/Squidex.Domain.Apps.Write.Tests/Assets/AssetCommandHandlerTests.cs

@@ -114,7 +114,7 @@ namespace Squidex.Domain.Apps.Write.Assets
         private void SetupImageInfo()
         {
             A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(stream))
-                .Returns(Task.FromResult(image));
+                .Returns(image);
         }
 
         private void SetupStore(long version, Guid commitId)

tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentCommandHandlerTests.cs

@@ -58,16 +58,17 @@ namespace Squidex.Domain.Apps.Write.Contents
 
             A.CallTo(() => app.LanguagesConfig).Returns(languagesConfig);
             A.CallTo(() => app.PartitionResolver).Returns(languagesConfig.ToResolver());
-            A.CallTo(() => appProvider.FindAppByIdAsync(AppId)).Returns(Task.FromResult(app));
+            A.CallTo(() => appProvider.FindAppByIdAsync(AppId)).Returns(app);
 
             A.CallTo(() => schema.SchemaDef).Returns(schemaDef);
-            A.CallTo(() => schemas.FindSchemaByIdAsync(SchemaId, false)).Returns(Task.FromResult(schema));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(SchemaId, false)).Returns(schema);
         }
 
         [Fact]
         public async Task Create_should_throw_exception_if_data_is_not_valid()
         {
-            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored)).Returns(invalidData);
+            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored))
+                .Returns(invalidData);
 
             var context = CreateContextForCommand(new CreateContent { ContentId = contentId, Data = invalidData, User = user });
 
@@ -80,8 +81,10 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Create_should_create_content()
         {
-            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored)).Returns(data);
+            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored))
-            A.CallTo(() => schema.ScriptCreate).Returns("<create-script>");
+                .Returns(data);
+            A.CallTo(() => schema.ScriptCreate)
+                .Returns("<create-script>");
 
             var context = CreateContextForCommand(new CreateContent { ContentId = contentId, Data = data, User = user });
 
@@ -113,8 +116,10 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Update_should_update_domain_object()
         {
-            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored)).Returns(data);
+            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored))
-            A.CallTo(() => schema.ScriptUpdate).Returns("<update-script>");
+                .Returns(data);
+            A.CallTo(() => schema.ScriptUpdate)
+                .Returns("<update-script>");
 
             CreateContent();
 
@@ -133,7 +138,8 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Patch_should_throw_exception_if_data_is_not_valid()
         {
-            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored)).Returns(invalidData);
+            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored))
+                .Returns(invalidData);
 
             CreateContent();
 
@@ -148,8 +154,10 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Patch_should_update_domain_object()
         {
-            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored)).Returns(data);
+            A.CallTo(() => scriptEngine.ExecuteAndTransform(A<ScriptContext>.Ignored, A<string>.Ignored, A<string>.Ignored))
-            A.CallTo(() => schema.ScriptUpdate).Returns("<update-script>");
+                .Returns(data);
+            A.CallTo(() => schema.ScriptUpdate)
+                .Returns("<update-script>");
 
             var patch = new NamedContentData().AddField("my-field", new ContentFieldData().SetValue(3));
 
@@ -172,7 +180,8 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Publish_should_publish_domain_object()
         {
-            A.CallTo(() => schema.ScriptPublish).Returns("<publish-script>");
+            A.CallTo(() => schema.ScriptPublish)
+                .Returns("<publish-script>");
 
             CreateContent();
 
@@ -189,7 +198,8 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Unpublish_should_unpublish_domain_object()
         {
-            A.CallTo(() => schema.ScriptUnpublish).Returns("<unpublish-script>");
+            A.CallTo(() => schema.ScriptUnpublish)
+                .Returns("<unpublish-script>");
 
             CreateContent();
 
@@ -206,7 +216,8 @@ namespace Squidex.Domain.Apps.Write.Contents
         [Fact]
         public async Task Delete_should_update_domain_object()
         {
-            A.CallTo(() => schema.ScriptDelete).Returns("<delete-script>");
+            A.CallTo(() => schema.ScriptDelete)
+                .Returns("<delete-script>");
 
             CreateContent();
 

tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaCommandHandlerTests.cs

@@ -44,7 +44,7 @@ namespace Squidex.Domain.Apps.Write.Schemas
             var context = CreateContextForCommand(new CreateSchema { Name = SchemaName, SchemaId = SchemaId });
 
             A.CallTo(() => schemas.FindSchemaByNameAsync(AppId, SchemaName))
-                .Returns(Task.FromResult(A.Dummy<ISchemaEntity>()));
+                .Returns(A.Dummy<ISchemaEntity>());
 
             await TestCreate(schema, async _ =>
             {
@@ -60,7 +60,7 @@ namespace Squidex.Domain.Apps.Write.Schemas
             var context = CreateContextForCommand(new CreateSchema { Name = SchemaName, SchemaId = SchemaId });
 
             A.CallTo(() => schemas.FindSchemaByNameAsync(AppId, SchemaName))
-                .Returns(Task.FromResult<ISchemaEntity>(null));
+                .Returns((ISchemaEntity)null);
 
             await TestCreate(schema, async _ =>
             {

tests/Squidex.Domain.Apps.Write.Tests/Webhooks/WebhookCommandMiddlewareTests.cs

@@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Write.Webhooks
         {
             var context = CreateContextForCommand(new CreateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId });
 
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult(A.Fake<ISchemaEntity>()));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(A.Fake<ISchemaEntity>());
 
             await TestCreate(webhook, async _ =>
             {
@@ -66,7 +66,7 @@ namespace Squidex.Domain.Apps.Write.Webhooks
         {
             var context = CreateContextForCommand(new CreateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId });
 
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult<ISchemaEntity>(null));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns((ISchemaEntity)null);
 
             await Assert.ThrowsAsync<ValidationException>(async () =>
             {
@@ -82,7 +82,7 @@ namespace Squidex.Domain.Apps.Write.Webhooks
         {
             var context = CreateContextForCommand(new UpdateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId });
 
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult(A.Fake<ISchemaEntity>()));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(A.Fake<ISchemaEntity>());
 
             CreateWebhook();
 
@@ -99,7 +99,7 @@ namespace Squidex.Domain.Apps.Write.Webhooks
         {
             var context = CreateContextForCommand(new UpdateWebhook { Schemas = webhookSchemas, Url = url, WebhookId = webhookId });
 
-            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns(Task.FromResult<ISchemaEntity>(null));
+            A.CallTo(() => schemas.FindSchemaByIdAsync(schemaId, false)).Returns((ISchemaEntity)null);
 
             CreateWebhook();
 

tests/Squidex.Infrastructure.Tests/CQRS/Commands/DefaultDomainObjectRepositoryTests.cs

@@ -75,7 +75,7 @@ namespace Squidex.Infrastructure.CQRS.Commands
         public async Task Should_throw_exception_when_event_store_returns_no_events()
         {
             A.CallTo(() => eventStore.GetEventsAsync(streamName))
-                .Returns(Task.FromResult<IReadOnlyList<StoredEvent>>(new List<StoredEvent>()));
+                .Returns(new List<StoredEvent>());
 
             await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.LoadAsync(domainObject, -1));
         }
@@ -96,7 +96,7 @@ namespace Squidex.Infrastructure.CQRS.Commands
             };
 
             A.CallTo(() => eventStore.GetEventsAsync(streamName))
-                .Returns(Task.FromResult<IReadOnlyList<StoredEvent>>(events));
+                .Returns(events);
 
             A.CallTo(() => eventDataFormatter.Parse(eventData1))
                 .Returns(new Envelope<IEvent>(event1));
@@ -124,7 +124,7 @@ namespace Squidex.Infrastructure.CQRS.Commands
             };
 
             A.CallTo(() => eventStore.GetEventsAsync(streamName))
-                .Returns(Task.FromResult<IReadOnlyList<StoredEvent>>(events));
+                .Returns(events);
 
             A.CallTo(() => eventDataFormatter.Parse(eventData1))
                 .Returns(new Envelope<IEvent>(event1));

tests/Squidex.Infrastructure.Tests/CQRS/Events/EventReceiverTests.cs

@@ -127,7 +127,7 @@ namespace Squidex.Infrastructure.CQRS.Events
             var eventStore = new MyEventStore(events);
 
             A.CallTo(() => eventConsumer.Name).Returns(consumerName);
-            A.CallTo(() => eventConsumerInfoRepository.FindAsync(consumerName)).Returns(Task.FromResult<IEventConsumerInfo>(consumerInfo));
+            A.CallTo(() => eventConsumerInfoRepository.FindAsync(consumerName)).Returns(consumerInfo);
 
             A.CallTo(() => formatter.Parse(eventData1)).Returns(envelope1);
             A.CallTo(() => formatter.Parse(eventData2)).Returns(envelope2);

tests/Squidex.Infrastructure.Tests/UsageTracking/BackgroundUsageTrackerTests.cs

@@ -66,7 +66,7 @@ namespace Squidex.Infrastructure.UsageTracking
             };
 
             A.CallTo(() => usageStore.QueryAsync("key", new DateTime(2016, 1, 1), new DateTime(2016, 1, 31)))
-                .Returns(Task.FromResult(originalData));
+                .Returns(originalData);
 
             var result = await sut.GetMonthlyCalls("key", date);
 
@@ -88,7 +88,7 @@ namespace Squidex.Infrastructure.UsageTracking
             };
 
             A.CallTo(() => usageStore.QueryAsync("key", dateFrom, dateTo))
-                .Returns(Task.FromResult(originalData));
+                .Returns(originalData);
 
             var result = await sut.QueryAsync("key", dateFrom, dateTo);