Formatting improved.

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

@@ -64,7 +64,8 @@ namespace Squidex.Domain.Apps.Read.Apps
         [Fact]
         public async Task Should_also_retrieve_app_by_name_if_retrieved_by_id_before()
         {
-            A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(Task.FromResult(appV1));
+            A.CallTo(() => repository.FindAppAsync(appId.Id))
+                .Returns(Task.FromResult(appV1));
 
             await ProvideAppById(appV1);
             await ProvideAppByName(appV1);
@@ -76,7 +77,8 @@ namespace Squidex.Domain.Apps.Read.Apps
         [Fact]
         public async Task Should_also_retrieve_app_by_id_if_retrieved_by_name_before()
         {
-            A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(Task.FromResult(appV1));
+            A.CallTo(() => repository.FindAppAsync(appId.Name))
+                .Returns(Task.FromResult(appV1));
 
             await ProvideAppByName(appV1);
             await ProvideAppById(appV1);
@@ -88,8 +90,10 @@ namespace Squidex.Domain.Apps.Read.Apps
         [Fact]
         public async Task Should_clear_cache_for_id_after_update_event()
         {
-            A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(appV2);
-            A.CallTo(() => repository.FindAppAsync(appId.Id)).Returns(appV1).Once();
+            A.CallTo(() => repository.FindAppAsync(appId.Id))
+                .Returns(appV2);
+            A.CallTo(() => repository.FindAppAsync(appId.Id))
+                .Returns(appV1).Once();
 
             await ProvideAppById(appV1);
 
@@ -103,8 +107,10 @@ namespace Squidex.Domain.Apps.Read.Apps
         [Fact]
         public async Task Should_clear_cache_for_name_after_update_event()
         {
-            A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(appV2);
-            A.CallTo(() => repository.FindAppAsync(appId.Name)).Returns(appV1).Once();
+            A.CallTo(() => repository.FindAppAsync(appId.Name))
+                .Returns(appV2);
+            A.CallTo(() => repository.FindAppAsync(appId.Name))
+                .Returns(appV1).Once();
 
             await ProvideAppByName(appV1);
 

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

@@ -67,7 +67,8 @@ namespace Squidex.Domain.Apps.Read.Schemas
         [Fact]
         public async Task Should_also_retrieve_schema_by_name_if_retrieved_by_id_before()
         {
-            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(Task.FromResult(schemaV1));
+            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id))
+                .Returns(Task.FromResult(schemaV1));
 
             await ProvideSchemaById(schemaV1);
             await ProvideSchemaByName(schemaV1);
@@ -79,7 +80,8 @@ namespace Squidex.Domain.Apps.Read.Schemas
         [Fact]
         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));
+            A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name))
+                .Returns(Task.FromResult(schemaV1));
 
             await ProvideSchemaByName(schemaV1);
             await ProvideSchemaById(schemaV1);
@@ -91,8 +93,10 @@ namespace Squidex.Domain.Apps.Read.Schemas
         [Fact]
         public async Task Should_clear_cache_for_id_after_update_event()
         {
-            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(schemaV2);
-            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id)).Returns(schemaV1).Once();
+            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id))
+                .Returns(schemaV2);
+            A.CallTo(() => repository.FindSchemaAsync(schemaId.Id))
+                .Returns(schemaV1).Once();
 
             await ProvideSchemaById(schemaV1);
 
@@ -106,8 +110,10 @@ namespace Squidex.Domain.Apps.Read.Schemas
         [Fact]
         public async Task Should_clear_cache_for_name_after_update_event()
         {
-            A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(schemaV2);
-            A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name)).Returns(schemaV1).Once();
+            A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name))
+                .Returns(schemaV2);
+            A.CallTo(() => repository.FindSchemaAsync(appId.Id, schemaId.Name))
+                .Returns(schemaV1).Once();
 
             await ProvideSchemaByName(schemaV1);
 

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

@@ -8,7 +8,7 @@
 
 using System;
 using System.Threading.Tasks;
-using Moq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Read.Apps;
 using Squidex.Domain.Apps.Read.Apps.Repositories;
 using Squidex.Domain.Apps.Read.Apps.Services;
@@ -27,10 +27,10 @@ namespace Squidex.Domain.Apps.Write.Apps
 {
     public class AppCommandHandlerTests : HandlerTestBase<AppDomainObject>
     {
-        private readonly Mock<IAppRepository> appRepository = new Mock<IAppRepository>();
-        private readonly Mock<IAppPlansProvider> appPlansProvider = new Mock<IAppPlansProvider>();
-        private readonly Mock<IAppPlanBillingManager> appPlansBillingManager = new Mock<IAppPlanBillingManager>();
-        private readonly Mock<IUserResolver> userResolver = new Mock<IUserResolver>();
+        private readonly IAppRepository appRepository = A.Fake<IAppRepository>();
+        private readonly IAppPlansProvider appPlansProvider = A.Fake<IAppPlansProvider>();
+        private readonly IAppPlanBillingManager appPlansBillingManager = A.Fake<IAppPlanBillingManager>();
+        private readonly IUserResolver userResolver = A.Fake<IUserResolver>();
         private readonly AppCommandHandler sut;
         private readonly AppDomainObject app;
         private readonly Language language = Language.DE;
@@ -41,7 +41,7 @@ namespace Squidex.Domain.Apps.Write.Apps
         {
             app = new AppDomainObject(AppId, -1);
 
-            sut = new AppCommandHandler(Handler, appRepository.Object, appPlansProvider.Object, appPlansBillingManager.Object, userResolver.Object);
+            sut = new AppCommandHandler(Handler, appRepository, appPlansProvider, appPlansBillingManager, userResolver);
         }
 
         [Fact]
@@ -49,16 +49,15 @@ namespace Squidex.Domain.Apps.Write.Apps
         {
             var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId });
 
-            appRepository.Setup(x => x.FindAppAsync(AppName))
-                .Returns(Task.FromResult(new Mock<IAppEntity>().Object))
-                .Verifiable();
+            A.CallTo(() => appRepository.FindAppAsync(AppName))
+                .Returns(Task.FromResult(A.Dummy<IAppEntity>()));
 
             await TestCreate(app, async _ =>
             {
                 await Assert.ThrowsAsync<ValidationException>(async () => await sut.HandleAsync(context));
             }, false);
 
-            appRepository.VerifyAll();
+            A.CallTo(() => appRepository.FindAppAsync(AppName)).MustHaveHappened();
         }
 
         [Fact]
@@ -66,9 +65,8 @@ namespace Squidex.Domain.Apps.Write.Apps
         {
             var context = CreateContextForCommand(new CreateApp { Name = AppName, AppId = AppId });
 
-            appRepository.Setup(x => x.FindAppAsync(AppName))
-                .Returns(Task.FromResult<IAppEntity>(null))
-                .Verifiable();
+            A.CallTo(() => appRepository.FindAppAsync(AppName))
+                .Returns(Task.FromResult<IAppEntity>(null));
 
             await TestCreate(app, async _ =>
             {
@@ -85,7 +83,8 @@ namespace Squidex.Domain.Apps.Write.Apps
 
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
-            userResolver.Setup(x => x.FindByIdAsync(contributorId)).Returns(Task.FromResult<IUser>(null));
+            A.CallTo(() => userResolver.FindByIdAsync(contributorId))
+                .Returns(Task.FromResult<IUser>(null));
 
             await TestUpdate(app, async _ =>
             {
@@ -96,7 +95,8 @@ namespace Squidex.Domain.Apps.Write.Apps
         [Fact]
         public async Task AssignContributor_throw_exception_if_reached_max_contributor_size()
         {
-            appPlansProvider.Setup(x => x.GetPlan(null)).Returns(new ConfigAppLimitsPlan { MaxContributors = 2 });
+            A.CallTo(() => appPlansProvider.GetPlan(null))
+                .Returns(new ConfigAppLimitsPlan { MaxContributors = 2 });
 
             CreateApp()
                 .AssignContributor(CreateCommand(new AssignContributor { ContributorId = "1" }))
@@ -104,7 +104,8 @@ namespace Squidex.Domain.Apps.Write.Apps
 
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
-            userResolver.Setup(x => x.FindByIdAsync(It.IsAny<string>())).Returns(Task.FromResult(new Mock<IUser>().Object));
+            A.CallTo(() => userResolver.FindByIdAsync(A<string>.Ignored))
+                .Returns(Task.FromResult(A.Dummy<IUser>()));
 
             await TestUpdate(app, async _ =>
             {
@@ -119,7 +120,8 @@ namespace Squidex.Domain.Apps.Write.Apps
 
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
-            userResolver.Setup(x => x.FindByIdAsync(contributorId)).Returns(Task.FromResult<IUser>(null));
+            A.CallTo(() => userResolver.FindByIdAsync(contributorId))
+                .Returns(Task.FromResult<IUser>(null));
 
             await TestUpdate(app, async _ =>
             {
@@ -130,13 +132,15 @@ namespace Squidex.Domain.Apps.Write.Apps
         [Fact]
         public async Task AssignContributor_should_assign_if_user_found()
         {
-            appPlansProvider.Setup(x => x.GetPlan(null)).Returns(new ConfigAppLimitsPlan { MaxContributors = -1 });
+            A.CallTo(() => appPlansProvider.GetPlan(null))
+                .Returns(new ConfigAppLimitsPlan { MaxContributors = -1 });
 
             CreateApp();
 
             var context = CreateContextForCommand(new AssignContributor { ContributorId = contributorId });
 
-            userResolver.Setup(x => x.FindByIdAsync(contributorId)).Returns(Task.FromResult(new Mock<IUser>().Object));
+            A.CallTo(() => userResolver.FindByIdAsync(contributorId))
+                .Returns(Task.FromResult(A.Dummy<IUser>()));
 
             await TestUpdate(app, async _ =>
             {
@@ -174,7 +178,8 @@ namespace Squidex.Domain.Apps.Write.Apps
         [Fact]
         public async Task ChangePlan_should_throw_if_plan_not_found()
         {
-            appPlansProvider.Setup(x => x.IsConfiguredPlan("my-plan")).Returns(false);
+            A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
+                .Returns(false);
 
             CreateApp()
                 .AttachClient(CreateCommand(new AttachClient { Id = clientName }));
@@ -218,7 +223,8 @@ namespace Squidex.Domain.Apps.Write.Apps
         [Fact]
         public async Task ChangePlan_should_update_domain_object()
         {
-            appPlansProvider.Setup(x => x.IsConfiguredPlan("my-plan")).Returns(true);
+            A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
+                .Returns(true);
 
             CreateApp();
 
@@ -229,14 +235,17 @@ namespace Squidex.Domain.Apps.Write.Apps
                 await sut.HandleAsync(context);
             });
 
-            appPlansBillingManager.Verify(x => x.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan"), Times.Once());
+            A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan")).MustHaveHappened();
         }
 
         [Fact]
         public async Task ChangePlan_should_not_make_update_for_redirect_result()
         {
-            appPlansProvider.Setup(x => x.IsConfiguredPlan("my-plan")).Returns(true);
-            appPlansBillingManager.Setup(x => x.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan")).Returns(CreateRedirectResult());
+            A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
+                .Returns(true);
+
+            A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan"))
+                .Returns(CreateRedirectResult());
 
             CreateApp();
 
@@ -253,7 +262,8 @@ namespace Squidex.Domain.Apps.Write.Apps
         [Fact]
         public async Task ChangePlan_should_not_call_billing_manager_for_callback()
         {
-            appPlansProvider.Setup(x => x.IsConfiguredPlan("my-plan")).Returns(true);
+            A.CallTo(() => appPlansProvider.IsConfiguredPlan("my-plan"))
+                .Returns(true);
 
             CreateApp();
 
@@ -264,7 +274,7 @@ namespace Squidex.Domain.Apps.Write.Apps
                 await sut.HandleAsync(context);
             });
 
-            appPlansBillingManager.Verify(x => x.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan"), Times.Never());
+            A.CallTo(() => appPlansBillingManager.ChangePlanAsync(User.Identifier, app.Id, app.Name, "my-plan")).MustNotHaveHappened();
         }
 
         [Fact]

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

@@ -9,7 +9,7 @@
 using System;
 using System.IO;
 using System.Threading.Tasks;
-using Moq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Write.Assets.Commands;
 using Squidex.Domain.Apps.Write.TestHelpers;
 using Squidex.Infrastructure.Assets;
@@ -24,8 +24,8 @@ namespace Squidex.Domain.Apps.Write.Assets
 {
     public class AssetCommandHandlerTests : HandlerTestBase<AssetDomainObject>
     {
-        private readonly Mock<IAssetThumbnailGenerator> assetThumbnailGenerator = new Mock<IAssetThumbnailGenerator>();
-        private readonly Mock<IAssetStore> assetStore = new Mock<IAssetStore>();
+        private readonly IAssetThumbnailGenerator assetThumbnailGenerator = A.Fake<IAssetThumbnailGenerator>();
+        private readonly IAssetStore assetStore = A.Fake<IAssetStore>();
         private readonly AssetCommandHandler sut;
         private readonly AssetDomainObject asset;
         private readonly Guid assetId = Guid.NewGuid();
@@ -39,7 +39,7 @@ namespace Squidex.Domain.Apps.Write.Assets
 
             asset = new AssetDomainObject(assetId, -1);
 
-            sut = new AssetCommandHandler(Handler, assetStore.Object, assetThumbnailGenerator.Object);
+            sut = new AssetCommandHandler(Handler, assetStore, assetThumbnailGenerator);
         }
 
         [Fact]
@@ -57,8 +57,8 @@ namespace Squidex.Domain.Apps.Write.Assets
 
             Assert.Equal(assetId, context.Result<EntityCreatedResult<Guid>>().IdOrValue);
 
-            assetStore.VerifyAll();
-            assetThumbnailGenerator.VerifyAll();
+            VerifyStore(0, context.ContextId);
+            VerifyImageInfo();
         }
 
         [Fact]
@@ -76,8 +76,8 @@ namespace Squidex.Domain.Apps.Write.Assets
                 await sut.HandleAsync(context);
             });
 
-            assetStore.VerifyAll();
-            assetThumbnailGenerator.VerifyAll();
+            VerifyStore(1, context.ContextId);
+            VerifyImageInfo();
         }
 
         [Fact]
@@ -113,24 +113,30 @@ namespace Squidex.Domain.Apps.Write.Assets
 
         private void SetupImageInfo()
         {
-            assetThumbnailGenerator
-                .Setup(x => x.GetImageInfoAsync(stream)).Returns(Task.FromResult(image))
-                .Verifiable();
+            A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(stream))
+                .Returns(Task.FromResult(image));
         }
 
         private void SetupStore(long version, Guid commitId)
         {
-            assetStore
-                .Setup(x => x.UploadTemporaryAsync(commitId.ToString(), stream)).Returns(TaskHelper.Done)
-                .Verifiable();
+            A.CallTo(() => assetStore.UploadTemporaryAsync(commitId.ToString(), stream))
+                .Returns(TaskHelper.Done);
+            A.CallTo(() => assetStore.CopyTemporaryAsync(commitId.ToString(), assetId.ToString(), version, null))
+                .Returns(TaskHelper.Done);
+            A.CallTo(() => assetStore.DeleteTemporaryAsync(commitId.ToString()))
+                .Returns(TaskHelper.Done);
+        }
 
-            assetStore
-                .Setup(x => x.CopyTemporaryAsync(commitId.ToString(), assetId.ToString(), version, null)).Returns(TaskHelper.Done)
-                .Verifiable();
+        private void VerifyImageInfo()
+        {
+            A.CallTo(() => assetThumbnailGenerator.GetImageInfoAsync(stream)).MustHaveHappened();
+        }
 
-            assetStore
-                .Setup(x => x.DeleteTemporaryAsync(commitId.ToString())).Returns(TaskHelper.Done)
-                .Verifiable();
+        private void VerifyStore(long version, Guid commitId)
+        {
+            A.CallTo(() => assetStore.UploadTemporaryAsync(commitId.ToString(), stream)).MustHaveHappened();
+            A.CallTo(() => assetStore.CopyTemporaryAsync(commitId.ToString(), assetId.ToString(), version, null)).MustHaveHappened();
+            A.CallTo(() => assetStore.DeleteTemporaryAsync(commitId.ToString())).MustHaveHappened();
         }
     }
 }

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

@@ -8,7 +8,7 @@
 
 using System;
 using System.Threading.Tasks;
-using Moq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Core;
 using Squidex.Domain.Apps.Core.Contents;
 using Squidex.Domain.Apps.Core.Schemas;
@@ -32,10 +32,10 @@ namespace Squidex.Domain.Apps.Write.Contents
     {
         private readonly ContentCommandHandler sut;
         private readonly ContentDomainObject content;
-        private readonly Mock<ISchemaProvider> schemaProvider = new Mock<ISchemaProvider>();
-        private readonly Mock<IAppProvider> appProvider = new Mock<IAppProvider>();
-        private readonly Mock<ISchemaEntity> schemaEntity = new Mock<ISchemaEntity>();
-        private readonly Mock<IAppEntity> appEntity = new Mock<IAppEntity>();
+        private readonly ISchemaProvider schemaProvider = A.Fake<ISchemaProvider>();
+        private readonly ISchemaEntity schemaEntity = A.Fake<ISchemaEntity>();
+        private readonly IAppProvider appProvider = A.Fake<IAppProvider>();
+        private readonly IAppEntity appEntity = A.Fake<IAppEntity>();
         private readonly NamedContentData data = new NamedContentData().AddField("my-field", new ContentFieldData().SetValue(1));
         private readonly LanguagesConfig languagesConfig = LanguagesConfig.Create(Language.DE);
         private readonly Guid contentId = Guid.NewGuid();
@@ -49,14 +49,14 @@ namespace Squidex.Domain.Apps.Write.Contents
 
             content = new ContentDomainObject(contentId, -1);
 
-            sut = new ContentCommandHandler(Handler, appProvider.Object, new Mock<IAssetRepository>().Object, schemaProvider.Object, new Mock<IContentRepository>().Object);
+            sut = new ContentCommandHandler(Handler, appProvider, A.Dummy<IAssetRepository>(), schemaProvider, A.Dummy<IContentRepository>());
 
-            appEntity.Setup(x => x.LanguagesConfig).Returns(languagesConfig);
-            appEntity.Setup(x => x.PartitionResolver).Returns(languagesConfig.ToResolver());
-            appProvider.Setup(x => x.FindAppByIdAsync(AppId)).Returns(Task.FromResult(appEntity.Object));
+            A.CallTo(() => appEntity.LanguagesConfig).Returns(languagesConfig);
+            A.CallTo(() => appEntity.PartitionResolver).Returns(languagesConfig.ToResolver());
+            A.CallTo(() => appProvider.FindAppByIdAsync(AppId)).Returns(Task.FromResult(appEntity));
 
-            schemaEntity.Setup(x => x.Schema).Returns(schema);
-            schemaProvider.Setup(x => x.FindSchemaByIdAsync(SchemaId, false)).Returns(Task.FromResult(schemaEntity.Object));
+            A.CallTo(() => schemaEntity.Schema).Returns(schema);
+            A.CallTo(() => schemaProvider.FindSchemaByIdAsync(SchemaId, false)).Returns(Task.FromResult(schemaEntity));
         }
 
         [Fact]

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

@@ -9,7 +9,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Moq;
+using FakeItEasy;
 using Squidex.Domain.Apps.Core.Schemas;
 using Squidex.Domain.Apps.Read.Schemas;
 using Squidex.Domain.Apps.Read.Schemas.Services;
@@ -25,7 +25,7 @@ namespace Squidex.Domain.Apps.Write.Schemas
 {
     public class SchemaCommandHandlerTests : HandlerTestBase<SchemaDomainObject>
     {
-        private readonly Mock<ISchemaProvider> schemaProvider = new Mock<ISchemaProvider>();
+        private readonly ISchemaProvider schemaProvider = A.Fake<ISchemaProvider>();
         private readonly SchemaCommandHandler sut;
         private readonly SchemaDomainObject schema;
         private readonly FieldRegistry registry = new FieldRegistry(new TypeNameRegistry());
@@ -35,7 +35,7 @@ namespace Squidex.Domain.Apps.Write.Schemas
         {
             schema = new SchemaDomainObject(SchemaId, -1, registry);
 
-            sut = new SchemaCommandHandler(Handler, schemaProvider.Object);
+            sut = new SchemaCommandHandler(Handler, schemaProvider);
         }
 
         [Fact]
@@ -43,16 +43,15 @@ namespace Squidex.Domain.Apps.Write.Schemas
         {
             var context = CreateContextForCommand(new CreateSchema { Name = SchemaName, SchemaId = SchemaId });
 
-            schemaProvider.Setup(x => x.FindSchemaByNameAsync(AppId, SchemaName))
-                .Returns(Task.FromResult(new Mock<ISchemaEntity>().Object))
-                .Verifiable();
+            A.CallTo(() => schemaProvider.FindSchemaByNameAsync(AppId, SchemaName))
+                .Returns(Task.FromResult(A.Dummy<ISchemaEntity>()));
 
             await TestCreate(schema, async _ =>
             {
                 await Assert.ThrowsAsync<ValidationException>(async () => await sut.HandleAsync(context));
             }, false);
 
-            schemaProvider.VerifyAll();
+            A.CallTo(() => schemaProvider.FindSchemaByNameAsync(AppId, SchemaName)).MustHaveHappened();
         }
 
         [Fact]
@@ -60,9 +59,8 @@ namespace Squidex.Domain.Apps.Write.Schemas
         {
             var context = CreateContextForCommand(new CreateSchema { Name = SchemaName, SchemaId = SchemaId });
 
-            schemaProvider.Setup(x => x.FindSchemaByNameAsync(AppId, SchemaName))
-                .Returns(Task.FromResult<ISchemaEntity>(null))
-                .Verifiable();
+            A.CallTo(() => schemaProvider.FindSchemaByNameAsync(AppId, SchemaName))
+                .Returns(Task.FromResult<ISchemaEntity>(null));
 
             await TestCreate(schema, async _ =>
             {
@@ -70,6 +68,8 @@ namespace Squidex.Domain.Apps.Write.Schemas
             });
 
             Assert.Equal(SchemaId, context.Result<EntityCreatedResult<Guid>>().IdOrValue);
+
+            A.CallTo(() => schemaProvider.FindSchemaByNameAsync(AppId, SchemaName)).MustHaveHappened();
         }
 
         [Fact]

tests/Squidex.Domain.Apps.Write.Tests/Squidex.Domain.Apps.Write.Tests.csproj

@@ -11,9 +11,9 @@
     <ProjectReference Include="..\..\src\Squidex.Domain.Apps.Write\Squidex.Domain.Apps.Write.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="FakeItEasy" Version="4.0.0" />
     <PackageReference Include="FluentAssertions" Version="4.19.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="Moq" Version="4.7.99" />
     <PackageReference Include="System.ValueTuple" Version="4.3.1" />
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />

tests/Squidex.Domain.Apps.Write.Tests/TestHelpers/HandlerTestBase.cs

@@ -57,7 +57,7 @@ namespace Squidex.Domain.Apps.Write.TestHelpers
             }
         }
 
-        private readonly MockupHandler handler = new MockupHandler();
+        private readonly MockupHandler handler = A.DummyupHandler();
 
         protected RefToken User { get; } = new RefToken("subject", Guid.NewGuid().ToString());
 

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

@@ -39,7 +39,8 @@ namespace Squidex.Infrastructure.CQRS.Commands
                 return new DO(passedId, -1);
             });
 
-            serviceProvider.Setup(x => x.GetService(typeof(DomainObjectFactoryFunction<DO>))).Returns(factoryFunction);
+            serviceProvider.Setup(x => x.GetService(typeof(DomainObjectFactoryFunction<DO>)))
+                .Returns(factoryFunction);
 
             var sut = new DefaultDomainObjectFactory(serviceProvider.Object);
 
@@ -61,7 +62,8 @@ namespace Squidex.Infrastructure.CQRS.Commands
                 return new DO(passedId, 0);
             });
 
-            serviceProvider.Setup(x => x.GetService(typeof(DomainObjectFactoryFunction<DO>))).Returns(factoryFunction);
+            serviceProvider.Setup(x => x.GetService(typeof(DomainObjectFactoryFunction<DO>)))
+                .Returns(factoryFunction);
 
             var sut = new DefaultDomainObjectFactory(serviceProvider.Object);
 

tests/Squidex.Infrastructure.Tests/Caching/InvalidatingMemoryCacheTest.cs

@@ -87,7 +87,8 @@ namespace Squidex.Infrastructure.Caching
         {
             var cacheEntry = new Mock<ICacheEntry>();
 
-            cache.Setup(x => x.CreateEntry("a-key")).Returns(cacheEntry.Object);
+            cache.Setup(x => x.CreateEntry("a-key"))
+                .Returns(cacheEntry.Object);
 
             var result = sut.CreateEntry("a-key");
 
@@ -99,7 +100,8 @@ namespace Squidex.Infrastructure.Caching
         {
             object currentOut = 123;
 
-            cache.Setup(x => x.TryGetValue("a-key", out currentOut)).Returns(true);
+            cache.Setup(x => x.TryGetValue("a-key", out currentOut))
+                .Returns(true);
 
             var exists = sut.TryGetValue("a-key", out object result);