diff --git a/Directory.Packages.props b/Directory.Packages.props
index e7e206e8..f54e1863 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -43,7 +43,7 @@
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.9.0" />
     <PackageVersion Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.23.0" />
     <PackageVersion Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="10.0.2" />
-    <PackageVersion Include="Moq" Version="4.20.72" />
+    <PackageVersion Include="Imposter" Version="0.1.9" />
     <PackageVersion Include="NetBarcode" Version="1.8.3" />
     <PackageVersion Include="NLog.Extensions.Logging" Version="6.2.0" />
     <PackageVersion Include="NuGet.Packaging" Version="7.9.0" />
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ContractDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ContractDomainEventHandlerTests.cs
index 6600901f..22ed198b 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ContractDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ContractDomainEventHandlerTests.cs
@@ -1,4 +1,5 @@
-using Moq;
+using TransactionProcessor.BusinessLogic.Tests;
+using Imposter.Abstractions;
 using Shared.Logger;
 using Shared.Serialisation;
 using Shouldly;
@@ -17,14 +18,14 @@ public class ContractDomainEventHandlerTests
 
     #region Methods
 
-    private Mock<ITransactionProcessorReadModelRepository> EstateReportingRepository;
+    private ITransactionProcessorReadModelRepositoryImposter EstateReportingRepository;
 
     private ReadModelDomainEventHandler DomainEventHandler;
     public ContractDomainEventHandlerTests() {
         Logger.Initialise(NullLogger.Instance);
         StringSerialiser.Initialise(new Shared.Serialisation.SystemTextJsonSerializer(new System.Text.Json.JsonSerializerOptions()));
-        this.EstateReportingRepository= new Mock<ITransactionProcessorReadModelRepository>();
-        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Object);
+        this.EstateReportingRepository= new ITransactionProcessorReadModelRepositoryImposter();
+        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Instance());
     }
         
     [Fact]
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/EstateDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/EstateDomainEventHandlerTests.cs
index 6ecf4946..f68a88ae 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/EstateDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/EstateDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.Logger;
 using Shared.Serialisation;
 using Shouldly;
@@ -18,7 +18,7 @@ public class EstateDomainEventHandlerTests
 {
     #region Methods
 
-    private Mock<ITransactionProcessorReadModelRepository> EstateReportingRepository;
+    private ITransactionProcessorReadModelRepositoryImposter EstateReportingRepository;
 
     private ReadModelDomainEventHandler DomainEventHandler;
 
@@ -26,17 +26,16 @@ public EstateDomainEventHandlerTests()
     {
         Logger.Initialise(NullLogger.Instance);
         StringSerialiser.Initialise(new Shared.Serialisation.SystemTextJsonSerializer(new System.Text.Json.JsonSerializerOptions()));
-        this.EstateReportingRepository = new Mock<ITransactionProcessorReadModelRepository>();
+        this.EstateReportingRepository = new ITransactionProcessorReadModelRepositoryImposter();
 
-        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Object);
+        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Instance());
     }
     [Fact]
     public void EstateDomainEventHandler_EstateCreatedEvent_EventIsHandled()
     {
         EstateDomainEvents.EstateCreatedEvent estateCreatedEvent = TestData.DomainEvents.EstateCreatedEvent;
-        this.EstateReportingRepository
-            .Setup(r => r.CreateReadModel(It.IsAny<EstateDomainEvents.EstateCreatedEvent>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+        this.EstateReportingRepository.CreateReadModel(Arg<EstateDomainEvents.EstateCreatedEvent>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         Should.NotThrow(async () => { await this.DomainEventHandler.Handle(estateCreatedEvent, TestContext.Current.CancellationToken); });
     }
@@ -45,9 +44,8 @@ public void EstateDomainEventHandler_EstateCreatedEvent_EventIsHandled()
     public async Task EstateDomainEventHandler_EstateCreatedEvent_CreateReadModelFailed_EventIsHandled()
     {
         EstateDomainEvents.EstateCreatedEvent estateCreatedEvent = TestData.DomainEvents.EstateCreatedEvent;
-        this.EstateReportingRepository
-            .Setup(r => r.CreateReadModel(It.IsAny<EstateDomainEvents.EstateCreatedEvent>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Failure);
+        this.EstateReportingRepository.CreateReadModel(Arg<EstateDomainEvents.EstateCreatedEvent>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Failure());
 
         Result result = await this.DomainEventHandler.Handle(estateCreatedEvent, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantDomainEventHandlerTests.cs
index 3bfecd01..c3522cd4 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantDomainEventHandlerTests.cs
@@ -1,8 +1,8 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Imposter.Abstractions;
 using MediatR;
-using Moq;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.Logger;
@@ -22,22 +22,22 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers
 {
     public class MerchantDomainEventHandlerTests : DomainEventHandlerTests
     {
-        private readonly Mock<ITransactionProcessorReadModelRepository> TransactionProcessorReadModelRepository;
+        private readonly ITransactionProcessorReadModelRepositoryImposter TransactionProcessorReadModelRepository;
         private readonly MerchantDomainEventHandler DomainEventHandler;
 
         public MerchantDomainEventHandlerTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)  {
-            this.TransactionProcessorReadModelRepository = new Mock<ITransactionProcessorReadModelRepository>();
+            this.TransactionProcessorReadModelRepository = new ITransactionProcessorReadModelRepositoryImposter();
 
-            this.DomainEventHandler = new MerchantDomainEventHandler(this.TransactionProcessorReadModelRepository.Object,
-                                                                     this.Mediator.Object);
+            this.DomainEventHandler = new MerchantDomainEventHandler(this.TransactionProcessorReadModelRepository.Instance(),
+                                                                     this.Mediator.Instance());
         }
 
         [Fact]
         public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEvent_Deposit_EventIsHandled()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchantFromReference(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.TransactionProcessorReadModelRepository.GetMerchantFromReference(Arg<Guid>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
                                       .ReturnsAsync(Result.Success(TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts()));
-            this.Mediator.Setup(m => m.Send(It.IsAny<MerchantCommands.MakeMerchantDepositCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             CallbackReceivedEnrichedEvent domainEvent = TestData.DomainEvents.CallbackReceivedEnrichedEventDeposit;
 
             var result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
@@ -57,7 +57,7 @@ public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEven
         [Fact]
         public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEvent_Deposit_GetMerchantFailed_ResultIsFailure()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchantFromReference(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.TransactionProcessorReadModelRepository.GetMerchantFromReference(Arg<Guid>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             CallbackReceivedEnrichedEvent domainEvent = TestData.DomainEvents.CallbackReceivedEnrichedEventDeposit;
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantScheduleDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantScheduleDomainEventHandlerTests.cs
index b4f1af5f..06d89138 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantScheduleDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantScheduleDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.Logger;
 using Shared.Serialisation;
 using Shouldly;
@@ -16,43 +16,41 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers;
 
 public class MerchantScheduleDomainEventHandlerTests
 {
-    private readonly Mock<ITransactionProcessorReadModelRepository> EstateReportingRepository;
+    private readonly ITransactionProcessorReadModelRepositoryImposter EstateReportingRepository;
     private readonly ReadModelDomainEventHandler DomainEventHandler;
 
     public MerchantScheduleDomainEventHandlerTests()
     {
         Logger.Initialise(NullLogger.Instance);
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-        this.EstateReportingRepository = new Mock<ITransactionProcessorReadModelRepository>();
-        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Object);
+        this.EstateReportingRepository = new ITransactionProcessorReadModelRepositoryImposter();
+        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Instance());
     }
 
     [Fact]
     public async Task MerchantScheduleDomainEventHandler_MerchantScheduleCreatedEvent_EventIsHandled()
     {
         MerchantScheduleDomainEvents.MerchantScheduleCreatedEvent domainEvent = TestData.DomainEvents.MerchantScheduleCreatedEvent;
-        this.EstateReportingRepository
-            .Setup(r => r.AddMerchantSchedule(domainEvent, It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+        this.EstateReportingRepository.AddMerchantSchedule(domainEvent, Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         Result result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.EstateReportingRepository.Verify(r => r.AddMerchantSchedule(domainEvent, It.IsAny<CancellationToken>()), Times.Once);
+        this.EstateReportingRepository.AddMerchantSchedule(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Once());
     }
 
     [Fact]
     public async Task MerchantScheduleDomainEventHandler_MerchantScheduleMonthUpdatedEvent_EventIsHandled()
     {
         MerchantScheduleDomainEvents.MerchantScheduleMonthUpdatedEvent domainEvent = TestData.DomainEvents.MerchantScheduleMonthUpdatedEvent;
-        this.EstateReportingRepository
-            .Setup(r => r.UpdateMerchantSchedule(domainEvent, It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+        this.EstateReportingRepository.UpdateMerchantSchedule(domainEvent, Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         Result result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.EstateReportingRepository.Verify(r => r.UpdateMerchantSchedule(domainEvent, It.IsAny<CancellationToken>()), Times.Once);
+        this.EstateReportingRepository.UpdateMerchantSchedule(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Once());
     }
 }
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantStatementDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantStatementDomainEventHandlerTests.cs
index 8d6b34ac..f306a38f 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantStatementDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantStatementDomainEventHandlerTests.cs
@@ -4,8 +4,8 @@
 using System.Threading.Tasks;
 using EventStore.Client;
 using Grpc.Core;
+using Imposter.Abstractions;
 using MediatR;
-using Moq;
 using Shared.Logger;
 using Shouldly;
 using SimpleResults;
@@ -20,14 +20,14 @@ public class MerchantStatementDomainEventHandlerTests : DomainEventHandlerTests
     private readonly MerchantStatementDomainEventHandler EventHandler;
     public MerchantStatementDomainEventHandlerTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
     {
-        this.EventHandler = new MerchantStatementDomainEventHandler(this.Mediator.Object);
+        this.EventHandler = new MerchantStatementDomainEventHandler(this.Mediator.Instance());
         Logger.Initialise(new NullLogger());
     }
 
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_StatementGeneratedEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.StatementGeneratedEvent, TestContext.Current.CancellationToken);
@@ -37,7 +37,7 @@ public async Task MerchantStatementDomainEventHandler_Handle_StatementGeneratedE
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_StatementBuiltEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.StatementBuiltEvent, TestContext.Current.CancellationToken);
@@ -47,7 +47,7 @@ public async Task MerchantStatementDomainEventHandler_Handle_StatementBuiltEvent
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_TransactionHasBeenCompletedEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.TransactionHasBeenCompletedEvent, TestContext.Current.CancellationToken);
@@ -59,36 +59,37 @@ public async Task MerchantStatementDomainEventHandler_Handle_TransactionHasBeenC
     {
         List<String> errors = new() { "WrongExpectedVersion" };
 
-        this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure(errors))
+            .Then()
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.TransactionHasBeenCompletedEvent, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
-        this.Mediator.Verify(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(2));
     }
 
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_TransactionHasBeenCompletedEvent_WrongExpectedRetried_AllRetriesFailed()
     {
         List<String> errors = new() { "WrongExpectedVersion" };
-        this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors));
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors));
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.TransactionHasBeenCompletedEvent, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
-        this.Mediator.Verify(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()), Times.Exactly(6));
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(6));
     }
 
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_MerchantFeeSettledEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.MerchantFeeSettledEvent, TestContext.Current.CancellationToken);
@@ -100,36 +101,37 @@ public async Task MerchantStatementDomainEventHandler_Handle_MerchantFeeSettledE
     {
         List<String> errors = new() { "WrongExpectedVersion" };
 
-        this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure(errors))
+            .Then()
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.MerchantFeeSettledEvent, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
-        this.Mediator.Verify(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(2));
     }
 
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_MerchantFeeSettledEvent_WrongExpectedRetried_AllRetriesFailed()
     {
         List<String> errors = new() { "WrongExpectedVersion" };
-        this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure(errors))
-            .ReturnsAsync(Result.Failure(errors));
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors))
+            .Then().ReturnsAsync(Result.Failure(errors));
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.MerchantFeeSettledEvent, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
-        this.Mediator.Verify(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()), Times.Exactly(6));
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(6));
     }
 
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_StatementCreatedForDateEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.StatementCreatedForDateEvent, TestContext.Current.CancellationToken);
@@ -139,7 +141,7 @@ public async Task MerchantStatementDomainEventHandler_Handle_StatementCreatedFor
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_AutomaticDepositMadeEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.AutomaticDepositMadeEvent, TestContext.Current.CancellationToken);
@@ -149,7 +151,7 @@ public async Task MerchantStatementDomainEventHandler_Handle_AutomaticDepositMad
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_ManualDepositMadeEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.ManualDepositMadeEvent, TestContext.Current.CancellationToken);
@@ -159,7 +161,7 @@ public async Task MerchantStatementDomainEventHandler_Handle_ManualDepositMadeEv
     [Fact]
     public async Task MerchantStatementDomainEventHandler_Handle_WithdrawalMadeEvent_EventIsHandled()
     {
-        this.Mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
+        this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.WithdrawalMadeEvent, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/OperatorDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/OperatorDomainEventHandlerTests.cs
index dc12bd22..c4869dee 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/OperatorDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/OperatorDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.Logger;
 using Shared.Serialisation;
 using Shouldly;
@@ -14,15 +14,15 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers;
 
 public class OperatorDomainEventHandlerTests
 {
-    private Mock<ITransactionProcessorReadModelRepository> EstateReportingRepository;
+    private ITransactionProcessorReadModelRepositoryImposter EstateReportingRepository;
     private ReadModelDomainEventHandler DomainEventHandler;
 
     public OperatorDomainEventHandlerTests()
     {
         Logger.Initialise(NullLogger.Instance);
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-        this.EstateReportingRepository = new Mock<ITransactionProcessorReadModelRepository>();
-        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Object);
+        this.EstateReportingRepository = new ITransactionProcessorReadModelRepositoryImposter();
+        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Instance());
     }
 
     [Fact]
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ReadModelDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ReadModelDomainEventHandlerTests.cs
index 82bb626e..e984fb64 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ReadModelDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/ReadModelDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.Logger;
 using Shared.Serialisation;
@@ -21,15 +21,15 @@ public class ReadModelDomainEventHandlerTests
 {
     private sealed record UnhandledDomainEvent() : DomainEvent(Guid.NewGuid(), Guid.NewGuid());
 
-    private readonly Mock<ITransactionProcessorReadModelRepository> EstateReportingRepository;
+    private readonly ITransactionProcessorReadModelRepositoryImposter EstateReportingRepository;
     private readonly ReadModelDomainEventHandler DomainEventHandler;
 
     public ReadModelDomainEventHandlerTests()
     {
         Logger.Initialise(NullLogger.Instance);
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-        this.EstateReportingRepository = new Mock<ITransactionProcessorReadModelRepository>();
-        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Object);
+        this.EstateReportingRepository = new ITransactionProcessorReadModelRepositoryImposter();
+        this.DomainEventHandler = new ReadModelDomainEventHandler(this.EstateReportingRepository.Instance());
     }
 
     [Fact]
@@ -42,18 +42,16 @@ public async Task ReadModelDomainEventHandler_Handle_AdditionalRequestDataRecord
                                                                                       new Dictionary<string, string>(),
                                                                                       TestData.TransactionDateTime);
 
-        this.EstateReportingRepository
-            .Setup(r => r.RecordTransactionAdditionalRequestData(domainEvent, It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.EstateReportingRepository
-            .Setup(r => r.SetTransactionAmount(domainEvent, It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+        this.EstateReportingRepository.RecordTransactionAdditionalRequestData(domainEvent, Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.EstateReportingRepository.SetTransactionAmount(domainEvent, Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         Result result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.EstateReportingRepository.Verify(r => r.RecordTransactionAdditionalRequestData(domainEvent, It.IsAny<CancellationToken>()), Times.Once);
-        this.EstateReportingRepository.Verify(r => r.SetTransactionAmount(domainEvent, It.IsAny<CancellationToken>()), Times.Once);
+        this.EstateReportingRepository.RecordTransactionAdditionalRequestData(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Once());
+        this.EstateReportingRepository.SetTransactionAmount(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Once());
     }
 
     [Fact]
@@ -61,15 +59,14 @@ public async Task ReadModelDomainEventHandler_Handle_StatementGeneratedEvent_Mar
     {
         MerchantStatementDomainEvents.StatementGeneratedEvent domainEvent = TestData.DomainEvents.StatementGeneratedEvent;
 
-        this.EstateReportingRepository
-            .Setup(r => r.MarkStatementAsGenerated(domainEvent, It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Failure);
+        this.EstateReportingRepository.MarkStatementAsGenerated(domainEvent, Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Failure());
 
         Result result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
 
         result.IsFailed.ShouldBeTrue();
-        this.EstateReportingRepository.Verify(r => r.MarkStatementAsGenerated(domainEvent, It.IsAny<CancellationToken>()), Times.Once);
-        this.EstateReportingRepository.Verify(r => r.UpdateMerchant(domainEvent, It.IsAny<CancellationToken>()), Times.Never);
+        this.EstateReportingRepository.MarkStatementAsGenerated(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Once());
+        this.EstateReportingRepository.UpdateMerchant(domainEvent, Arg<CancellationToken>.Any()).Called(Count.Never());
     }
 
     [Fact]
@@ -80,7 +77,6 @@ public async Task ReadModelDomainEventHandler_Handle_UnhandledDomainEvent_Return
         Result result = await this.DomainEventHandler.Handle(domainEvent, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.EstateReportingRepository.VerifyNoOtherCalls();
     }
 }
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/TransactionDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/TransactionDomainEventHandlerTests.cs
index 0325e0d5..44ea6132 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/TransactionDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/TransactionDomainEventHandlerTests.cs
@@ -8,7 +8,7 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers
 {
     using EventHandling;
     using Microsoft.Extensions.Configuration;
-    using Moq;
+    using Imposter.Abstractions;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.General;
     using Shared.Logger;
@@ -25,14 +25,14 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers
     [Collection("Sequential")]
     public abstract class DomainEventHandlerTests
     {
-        public Mock<IMediator> Mediator;
+        public IMediatorImposter Mediator;
 
         public DomainEventHandlerTests(ITestOutputHelper testOutputHelper) {
-            this.Mediator = new Mock<IMediator>();
+            this.Mediator = new IMediatorImposter();
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
             IConfigurationRoot configurationRoot = new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
             ConfigurationReader.Initialise(configurationRoot);
-            this.Mediator.Setup(s => s.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.Mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         }
     }
 
@@ -42,7 +42,7 @@ public class TransactionDomainEventHandlerTests : DomainEventHandlerTests
         
         public TransactionDomainEventHandlerTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
         {
-            this.TransactionDomainEventHandler = new TransactionDomainEventHandler(this.Mediator.Object);
+            this.TransactionDomainEventHandler = new TransactionDomainEventHandler(this.Mediator.Instance());
         }
         
         
diff --git a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/VoucherDomainEventHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/VoucherDomainEventHandlerTests.cs
index cf8054a3..66e13fa1 100644
--- a/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/VoucherDomainEventHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/VoucherDomainEventHandlerTests.cs
@@ -12,7 +12,7 @@ namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Moq;
+using Imposter.Abstractions;
 using SecurityService.Client;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EntityFramework;
@@ -39,11 +39,11 @@ public enum TestDatabaseType
 
 public class VoucherDomainEventHandlerTests
 {
-    private readonly Mock<IAggregateService> AggregateService;
-    private readonly Mock<IDbContextResolver<EstateManagementContext>> DbContextFactory;
+    private readonly IAggregateServiceImposter AggregateService;
+    private readonly IDbContextResolverImposter<EstateManagementContext> DbContextFactory;
     private readonly EstateManagementContext Context;
-    private readonly Mock<ISecurityServiceClient> SecurityServiceClient;
-    private readonly Mock<IMessagingServiceClient> MessagingServiceClient;
+    private readonly ISecurityServiceClientImposter SecurityServiceClient;
+    private readonly IMessagingServiceClientImposter MessagingServiceClient;
     private readonly VoucherDomainEventHandler VoucherDomainEventHandler;
 
     private EstateManagementContext GetContext(String databaseName)
@@ -60,8 +60,8 @@ public VoucherDomainEventHandlerTests() {
         Logger.Initialise(NullLogger.Instance);
         
 
-        SecurityServiceClient = new Mock<ISecurityServiceClient>();
-        MessagingServiceClient = new Mock<IMessagingServiceClient>();
+        SecurityServiceClient = new ISecurityServiceClientImposter();
+        MessagingServiceClient = new IMessagingServiceClientImposter();
 
         DirectoryInfo path = Directory.GetParent(Assembly.GetExecutingAssembly().Location);
         MockFileSystem fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>
@@ -70,19 +70,19 @@ public VoucherDomainEventHandlerTests() {
             { $"{path}/VoucherMessages/VoucherSMS.txt", new MockFileData("Transaction Number: [TransactionNumber]") }
         });
 
-        this.AggregateService = new Mock<IAggregateService>();
-        this.DbContextFactory = new Mock<IDbContextResolver<EstateManagementContext>>();
+        this.AggregateService = new IAggregateServiceImposter();
+        this.DbContextFactory = new IDbContextResolverImposter<EstateManagementContext>();
         this.Context = this.GetContext(Guid.NewGuid().ToString("N"));
         var services = new ServiceCollection();
         services.AddTransient<EstateManagementContext>(_ => this.Context);
         var serviceProvider = services.BuildServiceProvider();
         var scope = serviceProvider.CreateScope();
-        this.DbContextFactory.Setup(d => d.Resolve(It.IsAny<String>(), It.IsAny<String>())).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
+        this.DbContextFactory.Resolve(Arg<String>.Any(), Arg<String>.Any()).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
 
-        VoucherDomainEventHandler = new VoucherDomainEventHandler(this.SecurityServiceClient.Object,
-                                                                                            this.AggregateService.Object,
-                                                                                            this.DbContextFactory.Object,
-                                                                                            this.MessagingServiceClient.Object,
+        VoucherDomainEventHandler = new VoucherDomainEventHandler(this.SecurityServiceClient.Instance(),
+                                                                                            this.AggregateService.Instance(),
+                                                                                            this.DbContextFactory.Instance(),
+                                                                                            this.MessagingServiceClient.Instance(),
                                                                                             fileSystem);
 
     }
@@ -90,9 +90,9 @@ public VoucherDomainEventHandlerTests() {
     [Fact]
     public async Task VoucherDomainEventHandler_VoucherIssuedEvent_WithEmailAddress_IsHandled()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(t => t.Get<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                   .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientEmail()));
 
         this.Context.Transactions.Add(new Database.Entities.Transaction()
@@ -115,9 +115,9 @@ public async Task VoucherDomainEventHandler_VoucherIssuedEvent_WithEmailAddress_
     [Fact]
     public async Task VoucherDomainEventHandler_VoucherIssuedEvent_WithRecipientMobile_IsHandled()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(t => t.Get<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                   .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
 
         this.Context.Transactions.Add(new Database.Entities.Transaction()
diff --git a/TransactionProcessor.BusinessLogic.Tests/ImposterUsings.cs b/TransactionProcessor.BusinessLogic.Tests/ImposterUsings.cs
new file mode 100644
index 00000000..79efcaa8
--- /dev/null
+++ b/TransactionProcessor.BusinessLogic.Tests/ImposterUsings.cs
@@ -0,0 +1,46 @@
+using Imposter.Abstractions;
+using MediatR;
+using Microsoft.AspNetCore.Hosting;
+using TransactionProcessor.BusinessLogic.Services;
+using TransactionProcessor.BusinessLogic.Manager;
+using Shared.EventStore.Aggregate;
+using Shared.EntityFramework;
+using Shared.EventStore.EventStore;
+using SecurityService.Client;
+using PataPawaPostPay;
+using TransactionProcessor.BusinessLogic.OperatorInterfaces.PataPawaPostPay;
+using MessagingService.Client;
+using TransactionProcessor.Database.Contexts;
+using TransactionProcessor.Repository;
+using System.IO.Abstractions;
+using TransactionProcessor.ProjectionEngine.Repository;
+using TransactionProcessor.Models.Merchant;
+using TransactionProcessor.BusinessLogic.OperatorInterfaces;
+using TransactionProcessor.BusinessLogic.Common;
+
+[assembly: GenerateImposter(typeof(IOperatorProxy))]
+[assembly: GenerateImposter(typeof(ITransactionDomainService))]
+[assembly: GenerateImposter(typeof(IMediator))]
+[assembly: GenerateImposter(typeof(IWebHostEnvironment))]
+[assembly: GenerateImposter(typeof(IVoucherDomainService))]
+[assembly: GenerateImposter(typeof(IVoucherManagementManager))]
+[assembly: GenerateImposter(typeof(ISettlementDomainService))]
+[assembly: GenerateImposter(typeof(IFloatDomainService))]
+[assembly: GenerateImposter(typeof(IAggregateService))]
+[assembly: GenerateImposter(typeof(ITransactionProcessorManager))]
+[assembly: GenerateImposter(typeof(ITransactionProcessorReadModelRepository))]
+[assembly: GenerateImposter(typeof(IDbContextResolver<EstateManagementContext>))]
+[assembly: GenerateImposter(typeof(IEventStoreContext))]
+[assembly: GenerateImposter(typeof(ISecurityServiceClient))]
+[assembly: GenerateImposter(typeof(ITransactionValidationService))]
+[assembly: GenerateImposter(typeof(IMemoryCacheWrapper))]
+[assembly: GenerateImposter(typeof(IFeeCalculationManager))]
+[assembly: GenerateImposter(typeof(ITransactionReceiptBuilder))]
+[assembly: GenerateImposter(typeof(IMessagingServiceClient))]
+[assembly: GenerateImposter(typeof(PataPawaPostPayServiceClient))]
+[assembly: GenerateImposter(typeof(IPataPawaPostPayService))]
+[assembly: GenerateImposter(typeof(IStatementBuilder))]
+[assembly: GenerateImposter(typeof(IFileSystem))]
+[assembly: GenerateImposter(typeof(IDirectoryInfo))]
+[assembly: GenerateImposter(typeof(ITransactionProcessorReadRepository))]
+[assembly: GenerateImposter(typeof(IMerchantDomainService))]
diff --git a/TransactionProcessor.BusinessLogic.Tests/Manager/TransactionProcessorManagerTests.cs b/TransactionProcessor.BusinessLogic.Tests/Manager/TransactionProcessorManagerTests.cs
index 589dcd42..34e15bd5 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Manager/TransactionProcessorManagerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Manager/TransactionProcessorManagerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.Logger;
@@ -27,26 +27,26 @@ namespace TransactionProcessor.BusinessLogic.Tests.Manager
 {
     public class TransactionProcessorManagerTests
     {
-        private readonly Mock<ITransactionProcessorReadModelRepository> TransactionProcessorReadModelRepository;
-        private readonly Mock<IAggregateService> AggregateService;
+        private readonly ITransactionProcessorReadModelRepositoryImposter TransactionProcessorReadModelRepository;
+        private readonly IAggregateServiceImposter AggregateService;
         
         private readonly TransactionProcessorManager TransactionProcessorManager;
 
         public TransactionProcessorManagerTests()
         {
             Logger.Initialise(Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance);
-            this.TransactionProcessorReadModelRepository = new Mock<ITransactionProcessorReadModelRepository>();
+            this.TransactionProcessorReadModelRepository = new ITransactionProcessorReadModelRepositoryImposter();
             StringSerialiser.Initialise(new Shared.Serialisation.SystemTextJsonSerializer(new System.Text.Json.JsonSerializerOptions()));
-            this.AggregateService = new Mock<IAggregateService>();
+            this.AggregateService = new IAggregateServiceImposter();
             
-            this.TransactionProcessorManager = new TransactionProcessorManager(this.TransactionProcessorReadModelRepository.Object, this.AggregateService.Object);
+            this.TransactionProcessorManager = new TransactionProcessorManager(this.TransactionProcessorReadModelRepository.Instance(), this.AggregateService.Instance());
         }
 
         [Fact]
         public async Task TransactionProcessorManager_GetEstates_EstatesAreReturned()
         {
-            this.AggregateService.Setup(a => a.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetEstate(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.EstateModel));
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.TransactionProcessorReadModelRepository.GetEstate(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.EstateModel));
 
             Result<List<Estate>> getEstatesResult = await this.TransactionProcessorManager.GetEstates(TestData.EstateId, TestContext.Current.CancellationToken);
             getEstatesResult.IsSuccess.ShouldBeTrue();
@@ -60,8 +60,8 @@ public async Task TransactionProcessorManager_GetEstates_EstatesAreReturned()
         [Fact]
         public async Task TransactionProcessorManager_GetEstates_RepoCallFails_ResultFailed()
         {
-            this.AggregateService.Setup(a => a.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetEstate(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.TransactionProcessorReadModelRepository.GetEstate(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<Estate>> getEstatesResult = await this.TransactionProcessorManager.GetEstates(TestData.EstateId, TestContext.Current.CancellationToken);
             getEstatesResult.IsFailed.ShouldBeTrue();
@@ -70,9 +70,9 @@ public async Task TransactionProcessorManager_GetEstates_RepoCallFails_ResultFai
         [Fact]
         public async Task TransactionProcessorManager_GetEstate_EstateIsReturned()
         {
-            this.AggregateService.Setup(a => a.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetEstate(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.EstateModel));
-            this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), TestContext.Current.CancellationToken)).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.TransactionProcessorReadModelRepository.GetEstate(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.EstateModel));
+            this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), TestContext.Current.CancellationToken).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
             Result<Estate> getEstateResult = await this.TransactionProcessorManager.GetEstate(TestData.EstateId, TestContext.Current.CancellationToken);
             getEstateResult.IsSuccess.ShouldBeTrue();
@@ -89,8 +89,8 @@ public async Task TransactionProcessorManager_GetEstate_EstateIsReturned()
         [Fact]
         public async Task TransactionProcessorManager_GetEstate_InvalidEstateId_ErrorIsThrown()
         {
-            this.AggregateService.Setup(a => a.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetEstate(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.EstateModel));
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
+            this.TransactionProcessorReadModelRepository.GetEstate(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.EstateModel));
 
             Result<Estate> getEstateResult = await this.TransactionProcessorManager.GetEstate(TestData.EstateId, TestContext.Current.CancellationToken);
             getEstateResult.IsFailed.ShouldBeTrue();
@@ -99,8 +99,8 @@ public async Task TransactionProcessorManager_GetEstate_InvalidEstateId_ErrorIsT
         [Fact]
         public async Task TransactionProcessorManager_GetEstate_GetLatestFailed_ErrorIsThrown()
         {
-            this.AggregateService.Setup(a => a.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetEstate(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.EstateModel));
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.TransactionProcessorReadModelRepository.GetEstate(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.EstateModel));
 
             Result<Estate> getEstateResult = await this.TransactionProcessorManager.GetEstate(TestData.EstateId, TestContext.Current.CancellationToken);
             getEstateResult.IsFailed.ShouldBeTrue();
@@ -109,7 +109,7 @@ public async Task TransactionProcessorManager_GetEstate_GetLatestFailed_ErrorIsT
         [Fact]
         public async Task TransactionProcessorManager_GetContract_ContractIsReturned()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant)));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant)));
 
             Result<Contract> getContractResult = await this.TransactionProcessorManager.GetContract(TestData.EstateId, TestData.ContractId, TestContext.Current.CancellationToken);
             getContractResult.IsSuccess.ShouldBeTrue();
@@ -128,7 +128,7 @@ public async Task TransactionProcessorManager_GetContract_ContractIsReturned()
         [Fact]
         public async Task TransactionProcessorManager_GetContract_ContractNotCreated_ErrorIsThrown()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
 
             Result<Contract> getContractResult = await this.TransactionProcessorManager.GetContract(TestData.EstateId, TestData.ContractId, TestContext.Current.CancellationToken);
             getContractResult.IsFailed.ShouldBeTrue();
@@ -137,7 +137,7 @@ public async Task TransactionProcessorManager_GetContract_ContractNotCreated_Err
         [Fact]
         public async Task TransactionProcessorManager_GetContract_GetLatestFails_ErrorIsThrown()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<Contract> getContractResult = await this.TransactionProcessorManager.GetContract(TestData.EstateId, TestData.ContractId, TestContext.Current.CancellationToken);
             getContractResult.IsFailed.ShouldBeTrue();
@@ -146,7 +146,7 @@ public async Task TransactionProcessorManager_GetContract_GetLatestFails_ErrorIs
         [Fact]
         public async Task TransactionProcessorManager_GetContracts_ContractAreReturned()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetContracts(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new List<Contract>() { TestData.ContractModelWithProductsAndTransactionFees }));
+            this.TransactionProcessorReadModelRepository.GetContracts(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new List<Contract>() { TestData.ContractModelWithProductsAndTransactionFees }));
 
             Result<List<Contract>> getContractsResult = await this.TransactionProcessorManager.GetContracts(TestData.EstateId, TestContext.Current.CancellationToken);
             getContractsResult.IsSuccess.ShouldBeTrue();
@@ -158,7 +158,7 @@ public async Task TransactionProcessorManager_GetContracts_ContractAreReturned()
         [Fact]
         public async Task TransactionProcessorManager_GetContracts_RepoCallFails_ContractAreReturned()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetContracts(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.TransactionProcessorReadModelRepository.GetContracts(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<Contract>> getContractsResult = await this.TransactionProcessorManager.GetContracts(TestData.EstateId, TestContext.Current.CancellationToken);
             getContractsResult.IsFailed.ShouldBeTrue();
@@ -167,7 +167,7 @@ public async Task TransactionProcessorManager_GetContracts_RepoCallFails_Contrac
         [Fact]
         public async Task TransactionProcessorManager_GetTransactionFeesForProduct_TransactionFeesAreReturned()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant)));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant)));
 
             Result<List<ContractProductTransactionFee>> getTransactionFeesForProductResult = await this.TransactionProcessorManager.GetTransactionFeesForProduct(TestData.EstateId, TestData.MerchantId, TestData.ContractId, TestData.VariableContractProductId, TestContext.Current.CancellationToken);
             getTransactionFeesForProductResult.IsSuccess.ShouldBeTrue();
@@ -180,7 +180,7 @@ public async Task TransactionProcessorManager_GetTransactionFeesForProduct_Trans
         [Fact]
         public async Task TransactionProcessorManager_GetTransactionFeesForProduct_ContractNotFound_ErrorThrown()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
 
             Result<List<ContractProductTransactionFee>> result = await this.TransactionProcessorManager.GetTransactionFeesForProduct(TestData.EstateId, TestData.MerchantId, TestData.ContractId, TestData.FixedContractProductId, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -189,7 +189,7 @@ public async Task TransactionProcessorManager_GetTransactionFeesForProduct_Contr
         [Fact]
         public async Task TransactionProcessorManager_GetTransactionFeesForProduct_ProductNotFound_ErrorThrown()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
 
             Result<List<ContractProductTransactionFee>> result = await this.TransactionProcessorManager.GetTransactionFeesForProduct(TestData.EstateId, TestData.MerchantId, TestData.ContractId, TestData.FixedContractProductId, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -198,7 +198,7 @@ public async Task TransactionProcessorManager_GetTransactionFeesForProduct_Produ
         [Fact]
         public async Task TransactionProcessorManager_GetTransactionFeesForProduct_GetLatestFails_ErrorThrown()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<ContractProductTransactionFee>> result = await this.TransactionProcessorManager.GetTransactionFeesForProduct(TestData.EstateId, TestData.MerchantId, TestData.ContractId, TestData.FixedContractProductId, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -208,7 +208,7 @@ public async Task TransactionProcessorManager_GetTransactionFeesForProduct_GetLa
         [Fact]
         public async Task EstateManagementManager_GetFileDetails_FileDetailsAreReturned()
         {
-            this.EstateManagementRepository.Setup(e => e.GetFileDetails(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.FileModel));
+            this.EstateManagementRepository.GetFileDetails(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.FileModel));
 
             var getFileDetailsResult = await this.EstateManagementManager.GetFileDetails(TestData.EstateId, TestData.FileId, TestContext.Current.CancellationToken);
             getFileDetailsResult.IsSuccess.ShouldBeTrue();
@@ -219,7 +219,7 @@ public async Task EstateManagementManager_GetFileDetails_FileDetailsAreReturned(
         [Fact]
         public async Task EstateManagementManager_GetFileDetails_RepoCallFailed_FileDetailsAreReturned()
         {
-            this.EstateManagementRepository.Setup(e => e.GetFileDetails(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.EstateManagementRepository.GetFileDetails(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             var getFileDetailsResult = await this.EstateManagementManager.GetFileDetails(TestData.EstateId, TestData.FileId, TestContext.Current.CancellationToken);
             getFileDetailsResult.IsFailed.ShouldBeTrue();
@@ -228,7 +228,7 @@ public async Task EstateManagementManager_GetFileDetails_RepoCallFailed_FileDeta
         [Fact]
         public async Task TransactionProcessorManager_GetOperator_OperatorDetailsAreReturned()
         {
-            this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
             Result<Operator> getOperatorResult = await this.TransactionProcessorManager.GetOperator(TestData.EstateId, TestData.OperatorId, TestContext.Current.CancellationToken);
             getOperatorResult.IsSuccess.ShouldBeTrue();
@@ -239,7 +239,7 @@ public async Task TransactionProcessorManager_GetOperator_OperatorDetailsAreRetu
         [Fact]
         public async Task TransactionProcessorManager_GetOperator_OperatorNotCreated_ExceptionThrown()
         {
-            this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
+            this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
 
             Result<Operator> getOperatorResult = await this.TransactionProcessorManager.GetOperator(TestData.EstateId, TestData.OperatorId, TestContext.Current.CancellationToken);
             getOperatorResult.IsFailed.ShouldBeTrue();
@@ -248,7 +248,7 @@ public async Task TransactionProcessorManager_GetOperator_OperatorNotCreated_Exc
         [Fact]
         public async Task TransactionProcessorManager_GetOperator_GetLatestFails_ExceptionThrown()
         {
-            this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<Operator> getOperatorResult = await this.TransactionProcessorManager.GetOperator(TestData.EstateId, TestData.OperatorId, TestContext.Current.CancellationToken);
             getOperatorResult.IsFailed.ShouldBeTrue();
@@ -257,7 +257,7 @@ public async Task TransactionProcessorManager_GetOperator_GetLatestFails_Excepti
         [Fact]
         public async Task TransactionProcessorManager_GetOperators_OperatorDetailsAreReturned()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetOperators(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new List<Operator>{
+            this.TransactionProcessorReadModelRepository.GetOperators(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new List<Operator>{
                                                                                                                                                            TestData.OperatorModel
                                                                                                                                                        }));
 
@@ -272,7 +272,7 @@ public async Task TransactionProcessorManager_GetOperators_OperatorDetailsAreRet
         [Fact]
         public async Task TransactionProcessorManager_GetOperators_EmptyList_ExceptionThrown()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetOperators(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new List<Operator>()));
+            this.TransactionProcessorReadModelRepository.GetOperators(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new List<Operator>()));
 
             Result<List<Operator>> getOperatorsResult = await this.TransactionProcessorManager.GetOperators(TestData.EstateId, TestContext.Current.CancellationToken);
             getOperatorsResult.IsSuccess.ShouldBeTrue();
@@ -281,7 +281,7 @@ public async Task TransactionProcessorManager_GetOperators_EmptyList_ExceptionTh
         [Fact]
         public async Task TransactionProcessorManager_GetOperators_RepoCallFails_ExceptionThrown()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetOperators(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.TransactionProcessorReadModelRepository.GetOperators(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<Operator>> getOperatorsResult = await this.TransactionProcessorManager.GetOperators(TestData.EstateId, TestContext.Current.CancellationToken);
             getOperatorsResult.IsFailed.ShouldBeTrue();
@@ -290,10 +290,9 @@ public async Task TransactionProcessorManager_GetOperators_RepoCallFails_Excepti
         [Fact]
         public async Task TransactionProcessorManager_GetMerchant_MerchantIsReturned()
         {
-            this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-            this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), TestContext.Current.CancellationToken)).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.TransactionProcessorReadModelRepository
-                .Setup(r => r.GetMerchant(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+            this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), TestContext.Current.CancellationToken).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.TransactionProcessorReadModelRepository.GetMerchant(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts()));
 
             Merchant expectedModel = TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts();
@@ -343,7 +342,7 @@ public async Task TransactionProcessorManager_GetMerchant_MerchantIsReturned()
         [Fact]
         public async Task TransactionProcessorManager_GetMerchant_MerchantNotCreated_ErrorThrown()
         {
-            this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
+            this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
             Result<Merchant> result = await this.TransactionProcessorManager.GetMerchant(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -352,7 +351,7 @@ public async Task TransactionProcessorManager_GetMerchant_MerchantNotCreated_Err
         [Fact]
         public async Task TransactionProcessorManager_GetMerchant_GetLatestFails_ErrorThrown()
         {
-            this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<Merchant> result = await this.TransactionProcessorManager.GetMerchant(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -364,8 +363,7 @@ public async Task TransactionProcessorManager_GetMerchantSchedule_MerchantSchedu
             MerchantScheduleAggregate merchantScheduleAggregate = TestData.Aggregates.CreatedMerchantScheduleAggregate();
             merchantScheduleAggregate.UpdateSchedule(TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts().Schedules.Single().Months);
 
-            this.AggregateService
-                .Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(merchantScheduleAggregate));
 
             Result<MerchantScheduleModel> result = await this.TransactionProcessorManager.GetMerchantSchedule(TestData.EstateId, TestData.MerchantId, TestData.MerchantScheduleYear, TestContext.Current.CancellationToken);
@@ -380,8 +378,7 @@ public async Task TransactionProcessorManager_GetMerchantSchedule_MerchantSchedu
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantSchedule_MerchantScheduleNotCreated_ReturnsFailure()
         {
-            this.AggregateService
-                .Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantScheduleAggregate()));
 
             Result<MerchantScheduleModel> result = await this.TransactionProcessorManager.GetMerchantSchedule(TestData.EstateId, TestData.MerchantId, TestData.MerchantScheduleYear, TestContext.Current.CancellationToken);
@@ -393,8 +390,7 @@ public async Task TransactionProcessorManager_GetMerchantSchedule_MerchantSchedu
         public async Task TransactionProcessorManager_GetMerchantScheduleFromReadModel_MerchantScheduleIsReturned()
         {
             MerchantScheduleModel expectedSchedule = TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts().Schedules.Single();
-            this.TransactionProcessorReadModelRepository
-                .Setup(m => m.GetMerchantSchedule(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>()))
+            this.TransactionProcessorReadModelRepository.GetMerchantSchedule(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<Int32>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(expectedSchedule));
 
             Result<MerchantScheduleModel> result = await this.TransactionProcessorManager.GetMerchantScheduleFromReadModel(TestData.EstateId, TestData.MerchantId, TestData.MerchantScheduleYear, TestContext.Current.CancellationToken);
@@ -409,8 +405,7 @@ public async Task TransactionProcessorManager_GetMerchantScheduleFromReadModel_M
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantScheduleFromReadModel_MerchantScheduleNotFound_ReturnsFailure()
         {
-            this.TransactionProcessorReadModelRepository
-                .Setup(m => m.GetMerchantSchedule(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>()))
+            this.TransactionProcessorReadModelRepository.GetMerchantSchedule(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<Int32>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             Result<MerchantScheduleModel> result = await this.TransactionProcessorManager.GetMerchantScheduleFromReadModel(TestData.EstateId, TestData.MerchantId, TestData.MerchantScheduleYear, TestContext.Current.CancellationToken);
@@ -421,7 +416,7 @@ public async Task TransactionProcessorManager_GetMerchantScheduleFromReadModel_M
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantContracts_MerchantContractsReturned()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchantContracts(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.MerchantContracts));
+            this.TransactionProcessorReadModelRepository.GetMerchantContracts(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.MerchantContracts));
 
             Result<List<Contract>> getMerchantContractsResult = await this.TransactionProcessorManager.GetMerchantContracts(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
             getMerchantContractsResult.IsSuccess.ShouldBeTrue();
@@ -434,7 +429,7 @@ public async Task TransactionProcessorManager_GetMerchantContracts_MerchantContr
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantContracts_EmptyListReturned_ResultFailed()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchantContracts(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.MerchantContractsEmptyList));
+            this.TransactionProcessorReadModelRepository.GetMerchantContracts(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.MerchantContractsEmptyList));
 
             Result<List<Contract>> getMerchantContractsResult = await this.TransactionProcessorManager.GetMerchantContracts(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
             getMerchantContractsResult.IsFailed.ShouldBeTrue();
@@ -443,7 +438,7 @@ public async Task TransactionProcessorManager_GetMerchantContracts_EmptyListRetu
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantContracts_RepoCallFailed_ResultFailed()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchantContracts(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.TransactionProcessorReadModelRepository.GetMerchantContracts(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<Contract>> getMerchantContractsResult = await this.TransactionProcessorManager.GetMerchantContracts(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
             getMerchantContractsResult.IsFailed.ShouldBeTrue();
@@ -452,8 +447,7 @@ public async Task TransactionProcessorManager_GetMerchantContracts_RepoCallFaile
         [Fact]
         public async Task TransactionProcessorManager_GetMerchantContracts_RepositoryThrows_ResultFailed()
         {
-            this.TransactionProcessorReadModelRepository
-                .Setup(e => e.GetMerchantContracts(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.TransactionProcessorReadModelRepository.GetMerchantContracts(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception("Test exception"));
 
             Result<List<Contract>> getMerchantContractsResult = await this.TransactionProcessorManager.GetMerchantContracts(TestData.EstateId, TestData.MerchantId, TestContext.Current.CancellationToken);
@@ -465,7 +459,7 @@ public async Task TransactionProcessorManager_GetMerchantContracts_RepositoryThr
         [Fact]
         public async Task TransactionProcessorManager_GetMerchants_MerchantListIsReturned()
         {
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchants(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new List<Merchant>
+            this.TransactionProcessorReadModelRepository.GetMerchants(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new List<Merchant>
                                                                                                                                      {
                                                                                                                                          TestData
                                                                                                                                              .MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts()
@@ -484,7 +478,7 @@ public async Task TransactionProcessorManager_GetMerchants_MerchantListIsReturne
         public async Task TransactionProcessorManager_GetMerchants_NullMerchants_ExceptionThrown()
         {
             List<Merchant> merchants = null;
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchants(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(merchants));
+            this.TransactionProcessorReadModelRepository.GetMerchants(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(merchants));
 
             Result<List<Merchant>> getMerchantsResult = await this.TransactionProcessorManager.GetMerchants(TestData.EstateId, TestContext.Current.CancellationToken);
             getMerchantsResult.IsFailed.ShouldBeTrue();
@@ -494,7 +488,7 @@ public async Task TransactionProcessorManager_GetMerchants_NullMerchants_Excepti
         public async Task TransactionProcessorManager_GetMerchants_EmptyMerchants_ExceptionThrown()
         {
             List<Merchant> merchants = new List<Merchant>();
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchants(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(merchants));
+            this.TransactionProcessorReadModelRepository.GetMerchants(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(merchants));
 
             Result<List<Merchant>> getMerchantsResult = await this.TransactionProcessorManager.GetMerchants(TestData.EstateId, TestContext.Current.CancellationToken);
             getMerchantsResult.IsFailed.ShouldBeTrue();
@@ -504,11 +498,10 @@ public async Task TransactionProcessorManager_GetMerchants_EmptyMerchants_Except
         public async Task TransactionProcessorManager_GetMerchants_RepoCallFails_ExceptionThrown()
         {
             List<Merchant> merchants = new List<Merchant>();
-            this.TransactionProcessorReadModelRepository.Setup(e => e.GetMerchants(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.TransactionProcessorReadModelRepository.GetMerchants(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             Result<List<Merchant>> getMerchantsResult = await this.TransactionProcessorManager.GetMerchants(TestData.EstateId, TestContext.Current.CancellationToken);
             getMerchantsResult.IsFailed.ShouldBeTrue();
         }
     }
 }
-
diff --git a/TransactionProcessor.BusinessLogic.Tests/Manager/VoucherManagementManagerTests.cs b/TransactionProcessor.BusinessLogic.Tests/Manager/VoucherManagementManagerTests.cs
index 2eaa9898..873ac041 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Manager/VoucherManagementManagerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Manager/VoucherManagementManagerTests.cs
@@ -1,6 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.Exceptions;
@@ -39,19 +39,19 @@ private EstateManagementContext GetContext(String databaseName) {
 
         public VoucherManagementManagerTests() {
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-            this.AggregateService = new Mock<IAggregateService>();
-            this.DbContextFactory = new Mock<IDbContextResolver<EstateManagementContext>>();
+            this.AggregateService = new IAggregateServiceImposter();
+            this.DbContextFactory = new IDbContextResolverImposter<EstateManagementContext>();
             this.Context = this.GetContext(Guid.NewGuid().ToString("N"));
             var services = new ServiceCollection();
             services.AddTransient<EstateManagementContext>(_ => this.Context);
             var serviceProvider = services.BuildServiceProvider();
             var scope = serviceProvider.CreateScope();
-            this.DbContextFactory.Setup(d => d.Resolve(It.IsAny<String>(), It.IsAny<String>())).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
-            this.VoucherManagementManager = new VoucherManagementManager(this.AggregateService.Object, this.DbContextFactory.Object);
+            this.DbContextFactory.Resolve(Arg<String>.Any(), Arg<String>.Any()).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
+            this.VoucherManagementManager = new VoucherManagementManager(this.AggregateService.Instance(), this.DbContextFactory.Instance());
         }
 
-        private Mock<IAggregateService> AggregateService;
-        private Mock<IDbContextResolver<EstateManagementContext>> DbContextFactory;
+        private IAggregateServiceImposter AggregateService;
+        private IDbContextResolverImposter<EstateManagementContext> DbContextFactory;
         private VoucherManagementManager VoucherManagementManager;
         private EstateManagementContext Context;
 
@@ -68,7 +68,7 @@ await this.Context.VoucherProjectionStates.AddAsync(new VoucherProjectionState
             }, TestContext.Current.CancellationToken);
             await this.Context.SaveChangesAsync(TestContext.Current.CancellationToken);
             
-            this.AggregateService.Setup(v => v.Get<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
+            this.AggregateService.Get<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
 
             Result<Voucher> result = await this.VoucherManagementManager.GetVoucherByCode(TestData.EstateId, TestData.VoucherCode, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
@@ -80,7 +80,7 @@ await this.Context.VoucherProjectionStates.AddAsync(new VoucherProjectionState
         public async Task VoucherManagementManager_GetVoucherByCode_VoucherNotFound_ErrorThrown()
         {
             
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.NotFound());
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.NotFound());
 
             Should.Throw<NotFoundException>(async () =>
             {
@@ -103,7 +103,7 @@ await this.Context.VoucherProjectionStates.AddAsync(new VoucherProjectionState
             }, TestContext.Current.CancellationToken);
             await this.Context.SaveChangesAsync(TestContext.Current.CancellationToken);
 
-            this.AggregateService.Setup(v => v.Get<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
+            this.AggregateService.Get<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
             
             var result = await VoucherManagementManager.GetVoucherByTransactionId(TestData.EstateId, TestData.TransactionId, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
@@ -114,7 +114,7 @@ await this.Context.VoucherProjectionStates.AddAsync(new VoucherProjectionState
         [Fact]
         public async Task VoucherManagementManager_GetVoucherByTransactionId_VoucherNotFound_ErrorThrown()
         {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.NotFound());
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.NotFound());
 
             Should.Throw<NotFoundException>(async () =>
             {
diff --git a/TransactionProcessor.BusinessLogic.Tests/Mediator/MediatorTests.cs b/TransactionProcessor.BusinessLogic.Tests/Mediator/MediatorTests.cs
index 180d0af9..26b0e070 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Mediator/MediatorTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Mediator/MediatorTests.cs
@@ -8,7 +8,7 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
-using Moq;
+using Imposter.Abstractions;
 using Shared.EventStore.EventStore;
 using Shared.Serialisation;
 using TransactionProcessor.BusinessLogic.Manager;
@@ -116,16 +116,16 @@ public MediatorTests()
         [Fact]
         public async Task Mediator_Send_RequestHandled()
         {
-            Mock<IWebHostEnvironment> hostingEnvironment = new Mock<IWebHostEnvironment>();
-            hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
-            hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
-            hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");
+            IWebHostEnvironmentImposter hostingEnvironment = new();
+            hostingEnvironment.EnvironmentName.Getter().Returns("Development");
+            hostingEnvironment.ContentRootPath.Getter().Returns("/home");
+            hostingEnvironment.ApplicationName.Getter().Returns("Test Application");
 
             ServiceRegistry services = new ServiceRegistry();
-            Startup s = new Startup(hostingEnvironment.Object);
+            Startup s = new Startup(hostingEnvironment.Instance());
             Startup.Configuration = this.SetupMemoryConfiguration();
             
-            this.AddTestRegistrations(services, hostingEnvironment.Object);
+            this.AddTestRegistrations(services, hostingEnvironment.Instance());
             s.ConfigureContainer(services);
 
             List<String> errors = new List<String>();
diff --git a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/AgencyBankingProxyTests.cs b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/AgencyBankingProxyTests.cs
index 53b46d24..b817c71e 100644
--- a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/AgencyBankingProxyTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/AgencyBankingProxyTests.cs
@@ -1,5 +1,3 @@
-using Moq;
-using Moq.Protected;
 using Shared.Logger;
 using Shared.Serialisation;
 using Shouldly;
@@ -155,12 +153,8 @@ public async Task AgencyBankingProxy_ProcessSaleMessage_BalanceEnquiryFailure_Re
         [Fact]
         public async Task AgencyBankingProxy_ProcessSaleMessage_BalanceEnquiryTimeout_ReturnsFailureResult()
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            handlerMock.Protected()
-                       .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
-                       .ThrowsAsync(new TimeoutException("Execution Timeout Expired"));
-
-            HttpClient httpClient = new HttpClient(handlerMock.Object);
+            HttpClient httpClient = new HttpClient(new StubHttpMessageHandler((_, _) =>
+                Task.FromException<HttpResponseMessage>(new TimeoutException("Execution Timeout Expired"))));
             AgencyBankingConfiguration configuration = CreateConfiguration();
             IOperatorProxy proxy = new AgencyBankingProxy(httpClient, configuration);
 
@@ -300,8 +294,8 @@ public async Task AgencyBankingProxy_ProcessSaleMessage_DepositMissingAmount_Ret
         [Fact]
         public async Task AgencyBankingProxy_ProcessSaleMessage_DepositInvalidAmount_ReturnsInvalidResult()
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            HttpClient httpClient = new HttpClient(handlerMock.Object);
+            HttpClient httpClient = new HttpClient(new StubHttpMessageHandler((_, _) =>
+                Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK))));
             AgencyBankingConfiguration configuration = CreateConfiguration();
             IOperatorProxy proxy = new AgencyBankingProxy(httpClient, configuration);
 
@@ -445,8 +439,8 @@ public async Task AgencyBankingProxy_ProcessSaleMessage_WithdrawalMissingAmount_
         [Fact]
         public async Task AgencyBankingProxy_ProcessSaleMessage_WithdrawalInvalidAmount_ReturnsInvalidResult()
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            HttpClient httpClient = new HttpClient(handlerMock.Object);
+            HttpClient httpClient = new HttpClient(new StubHttpMessageHandler((_, _) =>
+                Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK))));
             AgencyBankingConfiguration configuration = CreateConfiguration();
             IOperatorProxy proxy = new AgencyBankingProxy(httpClient, configuration);
 
@@ -691,13 +685,24 @@ private static AgencyBankingConfiguration CreateConfiguration()
 
         private static HttpClient SetupMockHttpClient(HttpResponseMessage responseMessage, Action<HttpRequestMessage> onRequest = null)
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            handlerMock.Protected()
-                       .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
-                       .Callback<HttpRequestMessage, CancellationToken>((request, cancellationToken) => onRequest?.Invoke(request))
-                       .ReturnsAsync(responseMessage);
+            return new HttpClient(new StubHttpMessageHandler((request, _) =>
+            {
+                onRequest?.Invoke(request);
+                return Task.FromResult(responseMessage);
+            }));
+        }
+
+        private sealed class StubHttpMessageHandler : HttpMessageHandler
+        {
+            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> SendHandler;
+
+            public StubHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> send)
+            {
+                this.SendHandler = send;
+            }
 
-            return new HttpClient(handlerMock.Object);
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+                => this.SendHandler(request, cancellationToken);
         }
     }
 }
diff --git a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/PataPawaPostPayProxyTests.cs b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/PataPawaPostPayProxyTests.cs
index ad6917ae..d225569c 100644
--- a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/PataPawaPostPayProxyTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/PataPawaPostPayProxyTests.cs
@@ -6,7 +6,7 @@ namespace TransactionProcessor.BusinessLogic.Tests.OperatorInterfaces
 {
     using Common;
     using Microsoft.Extensions.Caching.Memory;
-    using Moq;
+    using Imposter.Abstractions;
     using PataPawaPostPay;
     using Shared.Serialisation;
     using Shouldly;
@@ -17,9 +17,9 @@ namespace TransactionProcessor.BusinessLogic.Tests.OperatorInterfaces
     using Xunit;
 
     public class PataPawaPostPayProxyTests{
-        private readonly Mock<IPataPawaPostPayService> PataPawaPostPayService;
+        private readonly IPataPawaPostPayServiceImposter PataPawaPostPayService;
 
-        private readonly Mock<PataPawaPostPayServiceClient> PataPawaPostPayServiceClient;
+        private readonly PataPawaPostPayServiceClientImposter PataPawaPostPayServiceClient;
 
         private readonly Func<PataPawaPostPayServiceClient, String, String, IPataPawaPostPayService> ChannelResolver;
 
@@ -29,23 +29,23 @@ public class PataPawaPostPayProxyTests{
 
         public PataPawaPostPayProxyTests(){
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-            PataPawaPostPayService = new Mock<IPataPawaPostPayService>();
-            PataPawaPostPayServiceClient = new Mock<PataPawaPostPayServiceClient>();
+            PataPawaPostPayService = new IPataPawaPostPayServiceImposter();
+            PataPawaPostPayServiceClient = new PataPawaPostPayServiceClientImposter();
 
             ChannelResolver = (client,
                                clientName,
                                s) => {
-                                  return PataPawaPostPayService.Object;
+                                  return PataPawaPostPayService.Instance();
                               };
 
             MemoryCache = new MemoryCache(new MemoryCacheOptions());
-            PataPawaPostPayProxy = new PataPawaPostPayProxy(PataPawaPostPayServiceClient.Object, ChannelResolver, TestData.PataPawaPostPaidConfiguration, this.MemoryCache);
+            PataPawaPostPayProxy = new PataPawaPostPayProxy(PataPawaPostPayServiceClient.Instance(), ChannelResolver, TestData.PataPawaPostPaidConfiguration, this.MemoryCache);
         }
 
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessLogonMessage_SuccessfulResponse_MessageIsProcessed() {
 
-            PataPawaPostPayService.Setup(s => s.getLoginRequestAsync(It.IsAny<String>(), It.IsAny<String>())).ReturnsAsync(TestData.PataPawaPostPaidSuccessfulLoginResponse);
+            PataPawaPostPayService.getLoginRequestAsync(Arg<String>.Any(), Arg<String>.Any()).ReturnsAsync(TestData.PataPawaPostPaidSuccessfulLoginResponse);
 
             var logonResponseResult = await PataPawaPostPayProxy.ProcessLogonMessage(TestContext.Current.CancellationToken);
             logonResponseResult.IsSuccess.ShouldBeTrue();
@@ -77,7 +77,7 @@ public async Task PataPawaPostPayProxy_ProcessLogonMessage_LogonCached_Successfu
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessLogonMessage_FailedResponse_MessageIsProcessed() {
 
-            PataPawaPostPayService.Setup(s => s.getLoginRequestAsync(It.IsAny<String>(), It.IsAny<String>())).ReturnsAsync(TestData.PataPawaPostPaidFailedLoginResponse);
+            PataPawaPostPayService.getLoginRequestAsync(Arg<String>.Any(), Arg<String>.Any()).ReturnsAsync(TestData.PataPawaPostPaidFailedLoginResponse);
             
             var result = await this.PataPawaPostPayProxy.ProcessLogonMessage(TestContext.Current.CancellationToken);
 
@@ -88,7 +88,7 @@ public async Task PataPawaPostPayProxy_ProcessLogonMessage_FailedResponse_Messag
         
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_SuccessfulResponse_MessageIsProcessed() {
-            PataPawaPostPayService.Setup(s => s.getVerifyRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>()))
+            PataPawaPostPayService.getVerifyRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any())
                                   .ReturnsAsync(TestData.PataPawaPostPaidSuccessfulVerifyAccountResponse);
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
             
@@ -117,7 +117,7 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_Successf
         
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_FailedLogon_ErrorIsThrown() {
-            this.PataPawaPostPayService.Setup(s => s.getVerifyRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>()))
+            this.PataPawaPostPayService.getVerifyRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any())
                 .ReturnsAsync(TestData.PataPawaPostPaidSuccessfulVerifyAccountResponse);
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidFailedLoginOperatorResponse);
             
@@ -188,7 +188,7 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_InvalidM
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_RequestFailedAtHost_ErrorIsThrown()
         {
-            this.PataPawaPostPayService.Setup(s => s.getVerifyRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>()))
+            this.PataPawaPostPayService.getVerifyRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any())
                 .ReturnsAsync(TestData.PataPawaPostPaidFailedVerifyAccountResponse);
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
             
@@ -207,7 +207,7 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_RequestF
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_Timeout_ErrorIsThrown()
         {
-            this.PataPawaPostPayService.Setup(s => s.getVerifyRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>()))
+            this.PataPawaPostPayService.getVerifyRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any())
                 .ThrowsAsync(new TimeoutException("Execution Timeout Expired"));
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
 
@@ -228,8 +228,8 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_VerifyAccount_Timeout_
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_ProcessBill_Timeout_ErrorIsThrown()
         {
-            this.PataPawaPostPayService.Setup(s => s.getPayBillRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>(),
-                                                                              It.IsAny<String>(), It.IsAny<String>(), It.IsAny<Decimal>()))
+            this.PataPawaPostPayService.getPayBillRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any(),
+                                                               Arg<String>.Any(), Arg<String>.Any(), Arg<Decimal>.Any())
                 .ThrowsAsync(new TimeoutException("Execution Timeout Expired"));
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
 
@@ -250,8 +250,8 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_ProcessBill_Timeout_Er
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_ProcessBill_SuccessfulResponse_MessageIsProcessed()
         {
-            this.PataPawaPostPayService.Setup(s => s.getPayBillRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>(),
-                                                                             It.IsAny<String>(), It.IsAny<String>(), It.IsAny<Decimal>()))
+            this.PataPawaPostPayService.getPayBillRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any(),
+                                                               Arg<String>.Any(), Arg<String>.Any(), Arg<Decimal>.Any())
                 .ReturnsAsync(TestData.PataPawaPostPaidSuccessfulProcessBillResponse);
             this.MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
 
@@ -408,8 +408,8 @@ public async Task PataPawaPostPayProxy_ProcessSaleMessage_ProcessBill_InvalidMes
         [Fact]
         public async Task PataPawaPostPayProxy_ProcessSaleMessage_ProcessBill_RequestFailedAtHost_ErrorThrown()
         {
-            this.PataPawaPostPayService.Setup(s => s.getPayBillRequestAsync(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<String>(),
-                                                                             It.IsAny<String>(), It.IsAny<String>(), It.IsAny<Decimal>()))
+            this.PataPawaPostPayService.getPayBillRequestAsync(Arg<String>.Any(), Arg<String>.Any(), Arg<String>.Any(),
+                                                               Arg<String>.Any(), Arg<String>.Any(), Arg<Decimal>.Any())
                 .ReturnsAsync(TestData.PataPawaPostPaidFailedProcessBillResponse);
             MemoryCache.Set("PataPawaPostPayLogon", TestData.PataPawaPostPaidSuccessfulLoginOperatorResponse);
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/SafaricomPinlessProxyTests.cs b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/SafaricomPinlessProxyTests.cs
index 0b95bc19..bc69d69b 100644
--- a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/SafaricomPinlessProxyTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/SafaricomPinlessProxyTests.cs
@@ -6,8 +6,6 @@ namespace TransactionProcessor.BusinessLogic.Tests.OperatorInterfaces
 {
     using BusinessLogic.OperatorInterfaces;
     using BusinessLogic.OperatorInterfaces.SafaricomPinless;
-    using Moq;
-    using Moq.Protected;
     using Shared.Logger;
     using Shared.Serialisation;
     using Shouldly;
@@ -191,13 +189,10 @@ public async Task SafaricomPinlessProxy_ProcessSaleMessage_FailedToSend_ErrorThr
         [Fact]
         public async Task SafaricomPinlessProxy_ProcessSaleMessage_Timeout_ErrorThrown()
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            handlerMock.Protected()
-                       .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
-                       .ThrowsAsync(new TimeoutException("Execution Timeout Expired"));
-
+            HttpMessageHandler handler = new StubHttpMessageHandler((_, _) =>
+                Task.FromException<HttpResponseMessage>(new TimeoutException("Execution Timeout Expired")));
             SafaricomConfiguration safaricomConfiguration = TestData.SafaricomConfiguration;
-            HttpClient httpClient = new HttpClient(handlerMock.Object);
+            HttpClient httpClient = new HttpClient(handler);
 
             IOperatorProxy safaricomPinlessproxy = new SafaricomPinlessProxy(safaricomConfiguration, httpClient);
 
@@ -253,17 +248,26 @@ public async Task SafaricomPinlessProxy_ProcessSaleMessage_InvalidData_ErrorThro
 
         private HttpClient SetupMockHttpClient(HttpResponseMessage responseMessage)
         {
-            Mock<HttpMessageHandler> handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
-            handlerMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
-                       .ReturnsAsync(responseMessage);
-
-            var httpClient = new HttpClient(handlerMock.Object)
+            var httpClient = new HttpClient(new StubHttpMessageHandler((_, _) => Task.FromResult(responseMessage)))
                              {
                                  BaseAddress = new Uri("http://test.com")
                              };
 
             return httpClient;
         }
+
+        private sealed class StubHttpMessageHandler : HttpMessageHandler
+        {
+            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> SendHandler;
+
+            public StubHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendHandler)
+            {
+                this.SendHandler = sendHandler;
+            }
+
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+                => this.SendHandler(request, cancellationToken);
+        }
     }
 }
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/VoucherManagementProxyTests.cs b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/VoucherManagementProxyTests.cs
index 119bd673..2b69be31 100644
--- a/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/VoucherManagementProxyTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/OperatorInterfaces/VoucherManagementProxyTests.cs
@@ -6,7 +6,7 @@ namespace TransactionProcessor.BusinessLogic.Tests.OperatorInterfaces
     using BusinessLogic.OperatorInterfaces;
     using BusinessLogic.OperatorInterfaces.VoucherManagement;
     using MediatR;
-    using Moq;
+    using Imposter.Abstractions;
     using Requests;
     using Shared.Serialisation;
     using Shouldly;
@@ -27,9 +27,9 @@ public VoucherManagementProxyTests() {
 
         [Fact]
         public async Task VoucherManagementProxy_ProcessLogonMessage_NullReturned() {
-            Mock<IMediator> mediator = new Mock<IMediator>();
+            IMediatorImposter mediator = new();
             
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var processLogonMessageResult = await voucherManagementProxy.ProcessLogonMessage(TestContext.Current.CancellationToken);
             processLogonMessageResult.IsSuccess.ShouldBeTrue();
@@ -39,9 +39,9 @@ public async Task VoucherManagementProxy_ProcessLogonMessage_NullReturned() {
         
         [Fact]
         public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueSuccessful_SaleMessageIsProcessed() {
-            Mock<IMediator> mediator = new Mock<IMediator>();
-            mediator.Setup(m => m.Send(It.IsAny<VoucherCommands.IssueVoucherCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.IssueVoucherResponse));
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IMediatorImposter mediator = new();
+            mediator.Send<Result<TransactionProcessor.Models.IssueVoucherResponse>>(Arg<IRequest<Result<TransactionProcessor.Models.IssueVoucherResponse>>>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.IssueVoucherResponse));
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var result = await voucherManagementProxy.ProcessSaleMessage(TestData.TransactionId,
                                                                                                 TestData.OperatorId,
@@ -63,9 +63,9 @@ public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueSuccessf
         [Fact]
         public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueFailed_FailedResultReturned()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>();
-            mediator.Setup(m => m.Send(It.IsAny<VoucherCommands.IssueVoucherCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure("Some grim error"));
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IMediatorImposter mediator = new();
+            mediator.Send<Result<TransactionProcessor.Models.IssueVoucherResponse>>(Arg<IRequest<Result<TransactionProcessor.Models.IssueVoucherResponse>>>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure("Some grim error"));
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var result = await voucherManagementProxy.ProcessSaleMessage(TestData.TransactionId,
                 TestData.OperatorId,
@@ -81,10 +81,10 @@ public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueFailed_F
         [Fact]
         public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueThrowsTimeout_FailedResultReturned()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>();
-            mediator.Setup(m => m.Send(It.IsAny<VoucherCommands.IssueVoucherCommand>(), It.IsAny<CancellationToken>()))
-                    .ThrowsAsync(new TimeoutException("Execution Timeout Expired"));
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IMediatorImposter mediator = new();
+            mediator.Send<Result<TransactionProcessor.Models.IssueVoucherResponse>>(Arg<IRequest<Result<TransactionProcessor.Models.IssueVoucherResponse>>>.Any(), Arg<CancellationToken>.Any())
+                    .Throws(new TimeoutException("Execution Timeout Expired"));
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var result = await voucherManagementProxy.ProcessSaleMessage(TestData.TransactionId,
                                                                                          TestData.OperatorId,
@@ -106,12 +106,12 @@ public async Task VoucherManagementProxy_ProcessSaleMessage_VoucherIssueThrowsTi
         [InlineData("A")]
         public async Task VoucherManagementProxy_ProcessSaleMessage_InvalidData_TransactionAmount_ErrorThrown(String transactionAmount)
         {
-            Mock<IMediator> mediator = new Mock<IMediator>();
+            IMediatorImposter mediator = new();
 
             Dictionary<String, String> additionalMetatdata = TestData.AdditionalTransactionMetaDataForVoucher();
             additionalMetatdata["Amount"] = transactionAmount;
 
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var result = await voucherManagementProxy.ProcessSaleMessage(TestData.TransactionId,
                                                                                         TestData.OperatorId,
@@ -133,7 +133,7 @@ public async Task VoucherManagementProxy_ProcessSaleMessage_InvalidData_Transact
         [InlineData(null, null)]
         public async Task VoucherManagementProxy_ProcessSaleMessage_InvalidData_RecipientDetails_ErrorThrown(String recipientEmail, String recipientMobile)
         {
-            Mock<IMediator> mediator = new Mock<IMediator>();
+            IMediatorImposter mediator = new();
 
             Dictionary<String, String> additionalMetatdata = new Dictionary<String, String>
                                                              {
@@ -143,7 +143,7 @@ public async Task VoucherManagementProxy_ProcessSaleMessage_InvalidData_Recipien
 
                                                              };
 
-            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Object);
+            IOperatorProxy voucherManagementProxy = new VoucherManagementProxy(mediator.Instance());
 
             var result = await voucherManagementProxy.ProcessSaleMessage(TestData.TransactionId,
                                                                                         TestData.OperatorId,
diff --git a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/FloatRequestHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/FloatRequestHandlerTests.cs
index 148d7a0a..34a8644a 100644
--- a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/FloatRequestHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/FloatRequestHandlerTests.cs
@@ -4,7 +4,7 @@
 namespace TransactionProcessor.BusinessLogic.Tests.RequestHandler;
 
 using BusinessLogic.Services;
-using Moq;
+using Imposter.Abstractions;
 using RequestHandlers;
 using Requests;
 using Shared.Serialisation;
@@ -22,9 +22,9 @@ public FloatRequestHandlerTests() {
 
     [Fact]
     public async Task FloatRequestHandler_CreateFloatForContractProductRequest_IsHandled(){
-        Mock<IFloatDomainService> floatDomainService = new Mock<IFloatDomainService>();
-        FloatRequestHandler handler = new FloatRequestHandler(floatDomainService.Object);
-        floatDomainService.Setup(f => f.CreateFloat(It.IsAny<FloatCommands.CreateFloatCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        IFloatDomainServiceImposter floatDomainService = new();
+        FloatRequestHandler handler = new FloatRequestHandler(floatDomainService.Instance());
+        floatDomainService.CreateFloat(Arg<FloatCommands.CreateFloatCommand>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         var command = TestData.CreateFloatCommand;
 
         var result = await handler.Handle(command, TestContext.Current.CancellationToken);
@@ -34,10 +34,10 @@ public async Task FloatRequestHandler_CreateFloatForContractProductRequest_IsHan
     [Fact]
     public async Task FloatRequestHandler_RecordCreditPurchaseForFloatRequest_IsHandled()
     {
-        Mock<IFloatDomainService> floatDomainService = new Mock<IFloatDomainService>();
-        FloatRequestHandler handler = new FloatRequestHandler(floatDomainService.Object);
+        IFloatDomainServiceImposter floatDomainService = new();
+        FloatRequestHandler handler = new FloatRequestHandler(floatDomainService.Instance());
         
-        floatDomainService.Setup(f => f.RecordCreditPurchase(It.IsAny<FloatCommands.RecordCreditPurchaseForFloatCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        floatDomainService.RecordCreditPurchase(Arg<FloatCommands.RecordCreditPurchaseForFloatCommand>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
         var command = TestData.RecordCreditPurchaseForFloatCommand;
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/MerchantRequestHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/MerchantRequestHandlerTests.cs
index 7e50064d..991ac06a 100644
--- a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/MerchantRequestHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/MerchantRequestHandlerTests.cs
@@ -1,4 +1,5 @@
-using Moq;
+using Imposter;
+using Imposter.Abstractions;
 using Shared.EventStore.EventStore;
 using Shared.Serialisation;
 using Shouldly;
@@ -29,23 +30,22 @@ public MerchantRequestHandlerTests()
     [Fact]
     public async Task MerchantRequestHandler_GetMerchantQuery_ReturnsMerchantReportingId()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> merchantBalanceStateRepository = new();
-        Mock<IEventStoreContext> eventStoreContext = new();
-        Mock<ITransactionProcessorReadRepository> transactionProcessorReadRepository = new();
-        Mock<IMerchantDomainService> merchantDomainService = new();
-        Mock<ITransactionProcessorManager> manager = new();
+        IProjectionStateRepository<MerchantBalanceState> merchantBalanceStateRepository = new NullProjectionStateRepository();
+        IEventStoreContextImposter eventStoreContext = new();
+        ITransactionProcessorReadRepositoryImposter transactionProcessorReadRepository = new();
+        IMerchantDomainServiceImposter merchantDomainService = new();
+        ITransactionProcessorManagerImposter manager = new();
         MerchantRequestHandler handler = new(
-            merchantBalanceStateRepository.Object,
-            eventStoreContext.Object,
-            transactionProcessorReadRepository.Object,
-            merchantDomainService.Object,
-            manager.Object);
+            merchantBalanceStateRepository,
+            eventStoreContext.Instance(),
+            transactionProcessorReadRepository.Instance(),
+            merchantDomainService.Instance(),
+            manager.Instance());
 
         MerchantModel expectedMerchant = TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts();
         expectedMerchant.MerchantReportingId = TestData.MerchantReportingId;
 
-        manager
-            .Setup(m => m.GetMerchant(TestData.EstateId, TestData.MerchantId, It.IsAny<CancellationToken>()))
+        manager.GetMerchant(TestData.EstateId, TestData.MerchantId, Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(expectedMerchant));
 
         MerchantQueries.GetMerchantQuery query = TestData.Queries.GetMerchantQuery;
@@ -55,7 +55,19 @@ public async Task MerchantRequestHandler_GetMerchantQuery_ReturnsMerchantReporti
         result.IsSuccess.ShouldBeTrue();
         result.Data.ShouldNotBeNull();
         result.Data.MerchantReportingId.ShouldBe(TestData.MerchantReportingId);
-        manager.Verify(m => m.GetMerchant(TestData.EstateId, TestData.MerchantId, It.IsAny<CancellationToken>()), Times.Once);
+        manager.GetMerchant(TestData.EstateId, TestData.MerchantId, Arg<CancellationToken>.Any()).Called(Count.Once());
+    }
+
+    private sealed class NullProjectionStateRepository : IProjectionStateRepository<MerchantBalanceState>
+    {
+        public Task<Result<MerchantBalanceState>> Load(Shared.DomainDrivenDesign.EventSourcing.IDomainEvent @event, CancellationToken cancellationToken) =>
+            Task.FromResult(new Result<MerchantBalanceState>());
+
+        public Task<Result<MerchantBalanceState>> Load(System.Guid estateId, System.Guid stateId, CancellationToken cancellationToken) =>
+            Task.FromResult(new Result<MerchantBalanceState>());
+
+        public Task<Result<MerchantBalanceState>> Save(MerchantBalanceState state, Shared.DomainDrivenDesign.EventSourcing.IDomainEvent @event, CancellationToken cancellationToken) =>
+            Task.FromResult(new Result<MerchantBalanceState>());
     }
 }
 
diff --git a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/SettlementRequestHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/SettlementRequestHandlerTests.cs
index 759f5d75..6b97738a 100644
--- a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/SettlementRequestHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/SettlementRequestHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.Serialisation;
@@ -26,11 +26,11 @@ public SettlementRequestHandlerTests() {
     [Fact]
     public async Task SettlementRequestHandler_ProcessSettlementRequest_IsHandled()
     {
-        Mock<ISettlementDomainService> settlementDomainService = new Mock<ISettlementDomainService>();
-        Mock<ITransactionProcessorManager> manager = new Mock<ITransactionProcessorManager>();
-        SettlementRequestHandler handler = new SettlementRequestHandler(settlementDomainService.Object, manager.Object);
+        ISettlementDomainServiceImposter settlementDomainService = new();
+        ITransactionProcessorManagerImposter manager = new();
+        SettlementRequestHandler handler = new SettlementRequestHandler(settlementDomainService.Instance(), manager.Instance());
         settlementDomainService
-            .Setup(s => s.ProcessSettlement(It.IsAny<SettlementCommands.ProcessSettlementCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            .ProcessSettlement(Arg<SettlementCommands.ProcessSettlementCommand>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         var command = TestData.Commands.ProcessSettlementCommand;
 
         var result = await handler.Handle(command, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs
index a2181e45..7ba479fe 100644
--- a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/TransactionRequestHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.Serialisation;
 using Shouldly;
 using SimpleResults;
@@ -22,10 +22,10 @@ public TransactionRequestHandlerTests() {
         [Fact]
         public async Task TransactionRequestHandler_ProcessLogonTransactionRequest_IsHandled()
         {
-            Mock<ITransactionDomainService> transactionDomainService = new Mock<ITransactionDomainService>();
-            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Object);
-            transactionDomainService.Setup(t => t.ProcessLogonTransaction(It.IsAny<TransactionCommands.ProcessLogonTransactionCommand>(),
-                It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            ITransactionDomainServiceImposter transactionDomainService = new ITransactionDomainServiceImposter();
+            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Instance());
+            transactionDomainService.ProcessLogonTransaction(Arg<TransactionCommands.ProcessLogonTransactionCommand>.Any(),
+                Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.ProcessLogonTransactionCommand command = TestData.Commands.ProcessLogonTransactionCommand;
 
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
@@ -36,10 +36,10 @@ public async Task TransactionRequestHandler_ProcessLogonTransactionRequest_IsHan
         [Fact]
         public async Task TransactionRequestHandler_ProcessSaleTransactionRequest_IsHandled()
         {
-            Mock<ITransactionDomainService> transactionDomainService = new Mock<ITransactionDomainService>();
-            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Object);
-            transactionDomainService.Setup(t => t.ProcessSaleTransaction(It.IsAny<TransactionCommands.ProcessSaleTransactionCommand>(),
-                It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            ITransactionDomainServiceImposter transactionDomainService = new ITransactionDomainServiceImposter();
+            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Instance());
+            transactionDomainService.ProcessSaleTransaction(Arg<TransactionCommands.ProcessSaleTransactionCommand>.Any(),
+                Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.ProcessSaleTransactionCommand command = TestData.Commands.ProcessSaleTransactionCommand;
 
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
@@ -50,10 +50,10 @@ public async Task TransactionRequestHandler_ProcessSaleTransactionRequest_IsHand
         [Fact]
         public async Task TransactionRequestHandler_ProcessReconciliationRequest_IsHandled()
         {
-            Mock<ITransactionDomainService> transactionDomainService = new Mock<ITransactionDomainService>();
-            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Object);
-            transactionDomainService.Setup(t => t.ProcessReconciliationTransaction(It.IsAny<TransactionCommands.ProcessReconciliationCommand>(),
-                It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            ITransactionDomainServiceImposter transactionDomainService = new ITransactionDomainServiceImposter();
+            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Instance());
+            transactionDomainService.ProcessReconciliationTransaction(Arg<TransactionCommands.ProcessReconciliationCommand>.Any(),
+                Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.ProcessReconciliationCommand command = TestData.Commands.ProcessReconciliationCommand;
 
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
@@ -64,11 +64,10 @@ public async Task TransactionRequestHandler_ProcessReconciliationRequest_IsHandl
         [Fact]
         public async Task TransactionRequestHandler_ResendTransactionReceiptRequest_IsHandled()
         {
-            Mock<ITransactionDomainService> transactionDomainService = new Mock<ITransactionDomainService>();
-            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Object);
-            transactionDomainService
-                .Setup(t => t.ResendTransactionReceipt(It.IsAny<TransactionCommands.ResendTransactionReceiptCommand>(),
-                    It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            ITransactionDomainServiceImposter transactionDomainService = new ITransactionDomainServiceImposter();
+            TransactionRequestHandler handler = new TransactionRequestHandler(transactionDomainService.Instance());
+            transactionDomainService.ResendTransactionReceipt(Arg<TransactionCommands.ResendTransactionReceiptCommand>.Any(),
+                    Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.ResendTransactionReceiptCommand command = TestData.Commands.ResendTransactionReceiptCommand;
 
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/VoucherManagementRequestHandlerTests.cs b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/VoucherManagementRequestHandlerTests.cs
index a5abdb99..19d08f71 100644
--- a/TransactionProcessor.BusinessLogic.Tests/RequestHandler/VoucherManagementRequestHandlerTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/RequestHandler/VoucherManagementRequestHandlerTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shouldly;
 using System;
 using System.Threading.Tasks;
@@ -24,12 +24,12 @@ public VoucherManagementRequestHandlerTests() {
         [Fact]
         public async Task VoucherManagementRequestHandler_IssueVoucherRequest_IsHandled()
         {
-            Mock<IVoucherDomainService> voucherDomainService = new Mock<IVoucherDomainService>();
-            Mock<IVoucherManagementManager> voucherManagementManager = new Mock<IVoucherManagementManager>();
-            voucherDomainService.Setup(v => v.IssueVoucher(It.IsAny<VoucherCommands.IssueVoucherCommand>(),
-                                                           It.IsAny<CancellationToken>())).ReturnsAsync(TestData.IssueVoucherResponse);
+            IVoucherDomainServiceImposter voucherDomainService = new();
+            IVoucherManagementManagerImposter voucherManagementManager = new();
+            voucherDomainService.IssueVoucher(Arg<VoucherCommands.IssueVoucherCommand>.Any(),
+                                                           Arg<CancellationToken>.Any()).ReturnsAsync(TestData.IssueVoucherResponse);
 
-            VoucherManagementRequestHandler handler = new VoucherManagementRequestHandler(voucherDomainService.Object, voucherManagementManager.Object);
+            VoucherManagementRequestHandler handler = new VoucherManagementRequestHandler(voucherDomainService.Instance(), voucherManagementManager.Instance());
             
             var command = TestData.IssueVoucherCommand;
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
@@ -39,12 +39,12 @@ public async Task VoucherManagementRequestHandler_IssueVoucherRequest_IsHandled(
         [Fact]
         public async Task VoucherManagementRequestHandler_RedeemVoucherRequest_IsHandled()
         {
-            Mock<IVoucherDomainService> voucherDomainService = new Mock<IVoucherDomainService>();
-            Mock<IVoucherManagementManager> voucherManagementManager = new Mock<IVoucherManagementManager>();
-            voucherDomainService.Setup(v => v.RedeemVoucher(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<DateTime>(),
-                                                           It.IsAny<CancellationToken>())).ReturnsAsync(TestData.RedeemVoucherResponse);
+            IVoucherDomainServiceImposter voucherDomainService = new();
+            IVoucherManagementManagerImposter voucherManagementManager = new();
+            voucherDomainService.RedeemVoucher(Arg<Guid>.Any(), Arg<String>.Any(), Arg<DateTime>.Any(),
+                                                           Arg<CancellationToken>.Any()).ReturnsAsync(TestData.RedeemVoucherResponse);
 
-            VoucherManagementRequestHandler handler = new VoucherManagementRequestHandler(voucherDomainService.Object, voucherManagementManager.Object);
+            VoucherManagementRequestHandler handler = new VoucherManagementRequestHandler(voucherDomainService.Instance(), voucherManagementManager.Instance());
 
             var command = TestData.RedeemVoucherCommand;
             var result = await handler.Handle(command, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/ContractDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/ContractDomainServiceTests.cs
index 032903bb..b8c4a887 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/ContractDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/ContractDomainServiceTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.EventStore.EventStore;
@@ -20,26 +20,26 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
 {
     public class ContractDomainServiceTests {
         private ContractDomainService DomainService;
-        private Mock<IAggregateService> AggregateService;
-        private Mock<IEventStoreContext> EventStoreContext;
+        private IAggregateServiceImposter AggregateService;
+        private IEventStoreContextImposter EventStoreContext;
         public ContractDomainServiceTests() {
-            this.AggregateService = new Mock<IAggregateService>();
-            this.EventStoreContext = new Mock<IEventStoreContext>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
-            this.DomainService = new ContractDomainService(AggregateServiceResolver, this.EventStoreContext.Object);
+            this.AggregateService = new IAggregateServiceImposter();
+            this.EventStoreContext = new IEventStoreContextImposter();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
+            this.DomainService = new ContractDomainService(AggregateServiceResolver, this.EventStoreContext.Instance());
             StringSerialiser.Initialise(new SystemTextJsonSerializer(SystemTextJsonSerializer.GetDefaultJsonSerializerOptions()));
         }
 
         [Fact]
         public async Task ContractDomainService_CreateContract_ContractIsCreated()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                      .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
             
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.AggregateService.Setup(c => c.Save<ContractAggregate>(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Save<ContractAggregate>(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -50,12 +50,12 @@ public async Task ContractDomainService_CreateContract_ContractIsCreated()
         [Fact]
         public async Task ContractDomainService_CreateContract_DuplicateContractNameForOperator_ResultFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
             String queryResult =
                 "{\r\n  \"total\": 1,\r\n  \"contract_Id\": \"3015e4d0-e9a9-49e5-bd55-a5492f193b62\"\r\n}";
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(queryResult);
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -66,12 +66,12 @@ public async Task ContractDomainService_CreateContract_DuplicateContractNameForO
         [Fact]
         public async Task ContractDomainService_CreateContract_ContractAlreadyCreated_ResultFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
             
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -82,9 +82,9 @@ public async Task ContractDomainService_CreateContract_ContractAlreadyCreated_Re
         [Fact]
         public async Task ContractDomainService_CreateContract_EstateNotCreated_ResultFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -95,9 +95,9 @@ public async Task ContractDomainService_CreateContract_EstateNotCreated_ResultFa
         [Fact]
         public async Task ContractDomainService_CreateContract_NoOperatorCreatedForEstate_ResultFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -108,10 +108,10 @@ public async Task ContractDomainService_CreateContract_NoOperatorCreatedForEstat
         [Fact]
         public async Task ContractDomainService_CreateContract_OperatorNotFoundForEstate_ResultFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
             
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -122,11 +122,11 @@ public async Task ContractDomainService_CreateContract_OperatorNotFoundForEstate
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_ProductAddedToContract()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -137,10 +137,10 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_ProductA
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_ContractNotCreated_ErrorThrown()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -151,12 +151,12 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_Contract
         [Fact]
         public async Task ContractDomainService_AddProductToContract_VariableValue_ProductAddedToContract()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_VariableValue;
@@ -167,10 +167,10 @@ public async Task ContractDomainService_AddProductToContract_VariableValue_Produ
         [Fact]
         public async Task ContractDomainService_AddProductToContract_VariableValue_ContractNotCreated_ErrorThrown()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_VariableValue;
@@ -181,10 +181,10 @@ public async Task ContractDomainService_AddProductToContract_VariableValue_Contr
         [Fact]
         public async Task ContractDomainService_AddProductToContract_VariableValue_EstateNotCreated_ErrorThrown()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_VariableValue;
@@ -195,10 +195,10 @@ public async Task ContractDomainService_AddProductToContract_VariableValue_Estat
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_EstateNotCreated_ErrorThrown()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -213,13 +213,13 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_EstateNo
         [InlineData(DataTransferObjects.Responses.Contract.CalculationType.Percentage, DataTransferObjects.Responses.Contract.FeeType.ServiceProvider)]
         public async Task ContractDomainService_AddTransactionFeeForProductToContract_TransactionFeeIsAddedToProduct(DataTransferObjects.Responses.Contract.CalculationType calculationType, DataTransferObjects.Responses.Contract.FeeType feeType)
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                        .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProduct()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
@@ -235,11 +235,11 @@ public async Task ContractDomainService_AddTransactionFeeForProductToContract_Tr
         [InlineData(DataTransferObjects.Responses.Contract.CalculationType.Percentage, DataTransferObjects.Responses.Contract.FeeType.ServiceProvider)]
         public async Task ContractDomainService_AddTransactionFeeForProductToContract_ContractNotCreated_ErrorThrown(DataTransferObjects.Responses.Contract.CalculationType calculationType, DataTransferObjects.Responses.Contract.FeeType feeType)
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                        .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
@@ -256,11 +256,11 @@ public async Task ContractDomainService_AddTransactionFeeForProductToContract_Co
         public async Task ContractDomainService_AddTransactionFeeForProductToContract_ProductNotFound_ErrorThrown(
             DataTransferObjects.Responses.Contract.CalculationType calculationType,
             DataTransferObjects.Responses.Contract.FeeType feeType) {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
@@ -278,14 +278,14 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_Transact
             CalculationType calculationType,
             FeeType feeType) {
 
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(calculationType, feeType));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
 
             ContractCommands.DisableTransactionFeeForProductCommand command = TestData.Commands.DisableTransactionFeeForProductCommand;
@@ -296,7 +296,7 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_Transact
         [Fact]
         public async Task ContractDomainService_DisableTransactionFeeForProduct_GetContractFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.DisableTransactionFeeForProductCommand command = TestData.Commands.DisableTransactionFeeForProductCommand;
@@ -307,7 +307,7 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_GetContr
         [Fact]
         public async Task ContractDomainService_DisableTransactionFeeForProduct_StateChangeFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
 
             ContractCommands.DisableTransactionFeeForProductCommand command = TestData.Commands.DisableTransactionFeeForProductCommand;
@@ -318,9 +318,9 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_StateCha
         [Fact]
         public async Task ContractDomainService_DisableTransactionFeeForProduct_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.DisableTransactionFeeForProductCommand command = TestData.Commands.DisableTransactionFeeForProductCommand;
@@ -331,9 +331,9 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_SaveFail
         [Fact]
         public async Task ContractDomainService_DisableTransactionFeeForProduct_ExceptionThrown_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             ContractCommands.DisableTransactionFeeForProductCommand command = TestData.Commands.DisableTransactionFeeForProductCommand;
             Result result = await this.DomainService.DisableTransactionFeeForProduct(command, TestContext.Current.CancellationToken);
@@ -343,7 +343,7 @@ public async Task ContractDomainService_DisableTransactionFeeForProduct_Exceptio
         [Fact]
         public async Task ContractDomainService_CreateContract_GetEstateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -354,9 +354,9 @@ public async Task ContractDomainService_CreateContract_GetEstateFailed_ResultIsF
         [Fact]
         public async Task ContractDomainService_CreateContract_GetContractFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -367,11 +367,11 @@ public async Task ContractDomainService_CreateContract_GetContractFailed_ResultI
         [Fact]
         public async Task ContractDomainService_CreateContract_RunTransientQueryFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -382,11 +382,11 @@ public async Task ContractDomainService_CreateContract_RunTransientQueryFailed_R
         [Fact]
         public async Task ContractDomainService_CreateContract_StateChangeFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
             
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -403,13 +403,13 @@ public async Task ContractDomainService_CreateContract_StateChangeFailed_ResultI
         [Fact]
         public async Task ContractDomainService_CreateContract_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
@@ -420,13 +420,13 @@ public async Task ContractDomainService_CreateContract_SaveFailed_ResultIsFailed
         [Fact]
         public async Task ContractDomainService_CreateContract_ExceptionThrown_ResultIsFailed()
         {
-            this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyContractAggregate()));
-            this.EventStoreContext.Setup(c => c.RunTransientQuery(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.EventStoreContext.RunTransientQuery(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync("{\r\n  \"total\": 0,\r\n  \"contract_Id\": \"\"\r\n}");
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             ContractCommands.CreateContractCommand command = TestData.Commands.CreateContractCommand;
             Result result = await this.DomainService.CreateContract(command, TestContext.Current.CancellationToken);
@@ -436,7 +436,7 @@ public async Task ContractDomainService_CreateContract_ExceptionThrown_ResultIsF
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_GetContractFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -447,7 +447,7 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_GetContr
         [Fact]
         public async Task ContractDomainService_AddProductToContract_VariableValue_GetContractFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_VariableValue;
@@ -458,9 +458,9 @@ public async Task ContractDomainService_AddProductToContract_VariableValue_GetCo
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_StateChangeFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -472,9 +472,9 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_StateCha
         [Fact]
         public async Task ContractDomainService_AddProductToContract_FixedValue_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_FixedValue;
@@ -485,9 +485,9 @@ public async Task ContractDomainService_AddProductToContract_FixedValue_SaveFail
         [Fact]
         public async Task ContractDomainService_AddProductToContract_VariableValue_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregate()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddProductToContractCommand command = TestData.Commands.AddProductToContractCommand_VariableValue;
@@ -504,7 +504,7 @@ public async Task ContractDomainService_AddTransactionFeeForProductToContract_Ge
             DataTransferObjects.Responses.Contract.CalculationType calculationType,
             DataTransferObjects.Responses.Contract.FeeType feeType)
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
@@ -522,9 +522,9 @@ public async Task ContractDomainService_AddTransactionFeeForProductToContract_Sa
             DataTransferObjects.Responses.Contract.CalculationType calculationType,
             DataTransferObjects.Responses.Contract.FeeType feeType)
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProduct()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
@@ -536,9 +536,9 @@ public async Task ContractDomainService_AddTransactionFeeForProductToContract_Sa
         [Fact]
         public async Task ContractDomainService_AddTransactionFeeForProductToContract_StateChangeFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(c => c.GetLatest<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedContractAggregateWithAProduct()));
-            this.AggregateService.Setup(c => c.Save(It.IsAny<ContractAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ContractAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             ContractCommands.AddTransactionFeeForProductToContractCommand command =
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/EstateDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/EstateDomainServiceTests.cs
index 072f5474..3ab71d32 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/EstateDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/EstateDomainServiceTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using SecurityService.Client;
 using SecurityService.DataTransferObjects;
 using Shared.DomainDrivenDesign.EventSourcing;
@@ -22,23 +22,23 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
 {
     public class EstateDomainServiceTests {
         private EstateDomainService DomainService;
-        private Mock<IAggregateService> AggregateService;
-        private Mock<ISecurityServiceClient> SecurityServiceClient;
+        private IAggregateServiceImposter AggregateService;
+        private ISecurityServiceClientImposter SecurityServiceClient;
         public EstateDomainServiceTests() {
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-            this.AggregateService= new Mock<IAggregateService>();
-            this.SecurityServiceClient = new Mock<ISecurityServiceClient>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
-            this.DomainService = new EstateDomainService(AggregateServiceResolver, this.SecurityServiceClient.Object);
+            this.AggregateService= new IAggregateServiceImposter();
+            this.SecurityServiceClient = new ISecurityServiceClientImposter();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
+            this.DomainService = new EstateDomainService(AggregateServiceResolver, this.SecurityServiceClient.Instance());
         }
 
         [Fact]
         public async Task EstateDomainService_CreateEstate_EstateIsCreated() {
             
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(new EstateAggregate()));
             this.AggregateService
-                .Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+                .Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
             
             Result result = await this.DomainService.CreateEstate(TestData.Commands.CreateEstateCommand, TestContext.Current.CancellationToken);
@@ -49,12 +49,12 @@ public async Task EstateDomainService_CreateEstate_EstateIsCreated() {
         [Fact]
         public async Task EstateDomainService_AddOperatorEstate_OperatorIsAdded()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success());
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success());
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
@@ -63,24 +63,24 @@ public async Task EstateDomainService_AddOperatorEstate_OperatorIsAdded()
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_OperatorIsRemoved()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
         }
 
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_EstateUserIsCreated() {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     new UserResponse {
                         UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -99,17 +99,17 @@ public async Task EstateDomainService_CreateEstateUser_EstateRoleOverrideIsUsedI
             try {
                 Environment.SetEnvironmentVariable("EstateRoleName", "CustomEstateRole");
 
-                this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                     .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-                this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+                this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                     .ReturnsAsync(SimpleResults.Result.Success());
 
                 this.SecurityServiceClient
-                    .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                    .Callback<CreateUserRequest, CancellationToken>((request, _) => capturedRequest = request)
-                    .ReturnsAsync(Result.Success);
+                    .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                    .ReturnsAsync(Result.Success())
+                    .Callback((request, _) => { capturedRequest = request; return Task.CompletedTask; });
                 this.SecurityServiceClient
-                    .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                    .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                     .ReturnsAsync(Result.Success(new List<UserResponse>() {
                         new UserResponse {
                             UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -131,16 +131,16 @@ public async Task EstateDomainService_CreateEstateUser_EstateRoleOverrideIsUsedI
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_UserCreateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     new UserResponse {
                         UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -154,16 +154,16 @@ public async Task EstateDomainService_CreateEstateUser_UserCreateFailed_ResultIs
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_GetUsersFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.CreateEstateUser(TestData.Commands.CreateEstateUserCommand, TestContext.Current.CancellationToken);
@@ -173,16 +173,16 @@ public async Task EstateDomainService_CreateEstateUser_GetUsersFailed_ResultIsFa
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_NullUserReturned_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     null
                 }));
@@ -194,14 +194,14 @@ public async Task EstateDomainService_CreateEstateUser_NullUserReturned_ResultIs
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_GetEstateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     new UserResponse {
                         UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -215,16 +215,16 @@ public async Task EstateDomainService_CreateEstateUser_GetEstateFailed_ResultIsF
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_EstateNotCreated_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     new UserResponse {
                         UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -238,16 +238,16 @@ public async Task EstateDomainService_CreateEstateUser_EstateNotCreated_ResultIs
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
 
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
             this.SecurityServiceClient
-                .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new List<UserResponse>() {
                     new UserResponse {
                         UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -261,7 +261,7 @@ public async Task EstateDomainService_CreateEstateUser_SaveFailed_ResultIsFailed
         [Fact]
         public async Task EstateDomainService_CreateEstate_GetEstateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.CreateEstate(TestData.Commands.CreateEstateCommand, TestContext.Current.CancellationToken);
@@ -271,7 +271,7 @@ public async Task EstateDomainService_CreateEstate_GetEstateFailed_ResultIsFaile
         [Fact]
         public async Task EstateDomainService_CreateEstate_EstateNameEmpty_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(new EstateAggregate()));
 
             EstateCommands.CreateEstateCommand emptyNameCommand = new EstateCommands.CreateEstateCommand(
@@ -284,11 +284,11 @@ public async Task EstateDomainService_CreateEstate_EstateNameEmpty_ResultIsFaile
         [Fact]
         public async Task EstateDomainService_CreateEstate_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(new EstateAggregate()));
             this.AggregateService
-                .Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
+                .Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.CreateEstate(TestData.Commands.CreateEstateCommand, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -297,9 +297,9 @@ public async Task EstateDomainService_CreateEstate_SaveFailed_ResultIsFailed()
         [Fact]
         public async Task EstateDomainService_AddOperatorToEstate_GetOperatorFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
@@ -309,9 +309,9 @@ public async Task EstateDomainService_AddOperatorToEstate_GetOperatorFailed_Resu
         [Fact]
         public async Task EstateDomainService_AddOperatorToEstate_GetEstateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
@@ -321,9 +321,9 @@ public async Task EstateDomainService_AddOperatorToEstate_GetEstateFailed_Result
         [Fact]
         public async Task EstateDomainService_AddOperatorToEstate_EstateNotCreated_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyEstateAggregate));
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
@@ -333,12 +333,12 @@ public async Task EstateDomainService_AddOperatorToEstate_EstateNotCreated_Resul
         [Fact]
         public async Task EstateDomainService_AddOperatorToEstate_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -347,7 +347,7 @@ public async Task EstateDomainService_AddOperatorToEstate_SaveFailed_ResultIsFai
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_GetEstateFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
@@ -357,7 +357,7 @@ public async Task EstateDomainService_RemoveOperatorFromEstate_GetEstateFailed_R
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_EstateNotCreated_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyEstateAggregate));
 
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
@@ -367,7 +367,7 @@ public async Task EstateDomainService_RemoveOperatorFromEstate_EstateNotCreated_
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_OperatorNotAdded_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
@@ -377,10 +377,10 @@ public async Task EstateDomainService_RemoveOperatorFromEstate_OperatorNotAdded_
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_SaveFailed_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
+            this.AggregateService.Save(Arg<EstateAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
 
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -389,7 +389,7 @@ public async Task EstateDomainService_RemoveOperatorFromEstate_SaveFailed_Result
         [Fact]
         public async Task EstateDomainService_CreateEstate_ExceptionThrown_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
             Result result = await this.DomainService.CreateEstate(TestData.Commands.CreateEstateCommand, TestContext.Current.CancellationToken);
@@ -399,7 +399,7 @@ public async Task EstateDomainService_CreateEstate_ExceptionThrown_ResultIsFaile
         [Fact]
         public async Task EstateDomainService_AddOperatorToEstate_ExceptionThrown_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
             Result result = await this.DomainService.AddOperatorToEstate(TestData.Commands.AddOperatorToEstateCommand, TestContext.Current.CancellationToken);
@@ -410,7 +410,7 @@ public async Task EstateDomainService_AddOperatorToEstate_ExceptionThrown_Result
         public async Task EstateDomainService_CreateEstateUser_ExceptionThrown_ResultIsFailed()
         {
             this.SecurityServiceClient
-                .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
+                .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
             Result result = await this.DomainService.CreateEstateUser(TestData.Commands.CreateEstateUserCommand, TestContext.Current.CancellationToken);
@@ -420,7 +420,7 @@ public async Task EstateDomainService_CreateEstateUser_ExceptionThrown_ResultIsF
         [Fact]
         public async Task EstateDomainService_RemoveOperatorFromEstate_ExceptionThrown_ResultIsFailed()
         {
-            this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
             Result result = await this.DomainService.RemoveOperatorFromEstate(TestData.Commands.RemoveOperatorFromEstateCommand, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/FloatDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/FloatDomainServiceTests.cs
index 5fba3a5a..5468cdc2 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/FloatDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/FloatDomainServiceTests.cs
@@ -6,7 +6,7 @@
 namespace TransactionProcessor.BusinessLogic.Tests.Services
 {
     using Microsoft.Extensions.Configuration;
-    using Moq;
+    using Imposter.Abstractions;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EventStore.Aggregate;
     using Shared.General;
@@ -23,7 +23,7 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
 
     public class FloatDomainServiceTests
     {
-        private readonly Mock<IAggregateService> AggregateService;
+        private readonly IAggregateServiceImposter AggregateService;
         private readonly FloatDomainService FloatDomainService;
 
         public FloatDomainServiceTests(){
@@ -33,18 +33,18 @@ public FloatDomainServiceTests(){
 
             Logger.Initialise(NullLogger.Instance);
 
-            this.AggregateService = new Mock<IAggregateService>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
+            this.AggregateService = new IAggregateServiceImposter();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
             this.FloatDomainService = new FloatDomainService(AggregateServiceResolver);
         }
 
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_FloatCreated(){
 
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(TestData.OperatorId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<FloatAggregate>(TestData.OperatorId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -54,7 +54,7 @@ public async Task FloatDomainService_CreateFloatForContractProduct_FloatCreated(
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_InvalidEstate_ErrorThrown()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.NotFound());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.NotFound());
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
@@ -63,7 +63,7 @@ public async Task FloatDomainService_CreateFloatForContractProduct_InvalidEstate
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_InvalidOperator_ErrorThrown()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId2, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -73,7 +73,7 @@ public async Task FloatDomainService_CreateFloatForContractProduct_InvalidOperat
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_DeletedOperator_ErrorThrown()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperatorDeleted()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperatorDeleted()));
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -84,8 +84,8 @@ public async Task FloatDomainService_CreateFloatForContractProduct_DeletedOperat
         public async Task FloatDomainService_RecordCreditPurchase_PurchaseRecorded(){
             FloatAggregate floatAggregate = FloatAggregate.Create(TestData.FloatAggregateId);
             floatAggregate.CreateFloat(TestData.EstateId, TestData.FloatCreatedDateTime);
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
             FloatCommands.RecordCreditPurchaseForFloatCommand command = new FloatCommands.RecordCreditPurchaseForFloatCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.FloatCreditAmount, TestData.FloatCreditCostPrice,
@@ -99,8 +99,8 @@ public async Task FloatDomainService_RecordCreditPurchase_SaveFailed()
         {
             FloatAggregate floatAggregate = FloatAggregate.Create(TestData.FloatAggregateId);
             floatAggregate.CreateFloat(TestData.EstateId, TestData.FloatCreatedDateTime);
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatCommands.RecordCreditPurchaseForFloatCommand command = new FloatCommands.RecordCreditPurchaseForFloatCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.FloatCreditAmount, TestData.FloatCreditCostPrice,
@@ -114,8 +114,8 @@ public async Task FloatDomainService_RecordCreditPurchase_ExceptionThrown()
         {
             FloatAggregate floatAggregate = FloatAggregate.Create(TestData.FloatAggregateId);
             floatAggregate.CreateFloat(TestData.EstateId, TestData.FloatCreatedDateTime);
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             FloatCommands.RecordCreditPurchaseForFloatCommand command = new FloatCommands.RecordCreditPurchaseForFloatCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.FloatCreditAmount, TestData.FloatCreditCostPrice,
@@ -128,8 +128,8 @@ public async Task FloatDomainService_RecordCreditPurchase_ExceptionThrown()
         public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_PurchaseRecorded()
         {
             FloatActivityAggregate floatAggregate = FloatActivityAggregate.Create(TestData.FloatAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.AggregateService.GetLatest<FloatActivityAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
             FloatActivityCommands.RecordCreditPurchaseCommand command = new FloatActivityCommands.RecordCreditPurchaseCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.CreditPurchasedDateTime, TestData.FloatCreditAmount, TestData.FloatCreditId);
@@ -141,8 +141,8 @@ public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_Purchase
         public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_SaveFailed()
         {
             FloatActivityAggregate floatAggregate = FloatActivityAggregate.Create(TestData.FloatAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+            this.AggregateService.GetLatest<FloatActivityAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatActivityCommands.RecordCreditPurchaseCommand command = new FloatActivityCommands.RecordCreditPurchaseCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.CreditPurchasedDateTime, TestData.FloatCreditAmount, TestData.FloatCreditId);
@@ -154,8 +154,8 @@ public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_SaveFail
         public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_ExceptionThrown()
         {
             FloatActivityAggregate floatAggregate = FloatActivityAggregate.Create(TestData.FloatAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.GetLatest<FloatActivityAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             FloatActivityCommands.RecordCreditPurchaseCommand command = new FloatActivityCommands.RecordCreditPurchaseCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.CreditPurchasedDateTime, TestData.FloatCreditAmount, TestData.FloatCreditId);
@@ -166,8 +166,8 @@ public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_Exceptio
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_GetFloatFailed()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(TestData.OperatorId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<FloatAggregate>(TestData.OperatorId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -177,9 +177,9 @@ public async Task FloatDomainService_CreateFloatForContractProduct_GetFloatFaile
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_SaveFailed()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(TestData.OperatorId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<FloatAggregate>(TestData.OperatorId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -189,9 +189,9 @@ public async Task FloatDomainService_CreateFloatForContractProduct_SaveFailed()
         [Fact]
         public async Task FloatDomainService_CreateFloatForContractProduct_ExceptionThrown()
         {
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(TestData.OperatorId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
-            this.AggregateService.Setup(f => f.Save<FloatAggregate>(It.IsAny<FloatAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<FloatAggregate>(TestData.OperatorId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(FloatAggregate.Create(TestData.OperatorId)));
+            this.AggregateService.Save<FloatAggregate>(Arg<FloatAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             FloatCommands.CreateFloatCommand command = new FloatCommands.CreateFloatCommand(TestData.EstateId, TestData.OperatorId, TestData.FloatCreatedDateTime);
             Result result = await this.FloatDomainService.CreateFloat(command, TestContext.Current.CancellationToken);
@@ -201,7 +201,7 @@ public async Task FloatDomainService_CreateFloatForContractProduct_ExceptionThro
         [Fact]
         public async Task FloatDomainService_RecordCreditPurchase_GetFloatFailed()
         {
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatCommands.RecordCreditPurchaseForFloatCommand command = new FloatCommands.RecordCreditPurchaseForFloatCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.FloatCreditAmount, TestData.FloatCreditCostPrice,
@@ -213,7 +213,7 @@ public async Task FloatDomainService_RecordCreditPurchase_GetFloatFailed()
         [Fact]
         public async Task FloatDomainService_RecordCreditPurchase_FloatActivity_GetFloatActivityFailed()
         {
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<FloatActivityAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatActivityCommands.RecordCreditPurchaseCommand command = new FloatActivityCommands.RecordCreditPurchaseCommand(TestData.EstateId,
                 TestData.FloatAggregateId, TestData.CreditPurchasedDateTime, TestData.FloatCreditAmount, TestData.FloatCreditId);
@@ -226,9 +226,9 @@ public async Task FloatDomainService_RecordTransaction_TransactionRecorded()
         {
             Guid floatActivityAggregateId = IdGenerationService.GenerateFloatActivityAggregateId(TestData.EstateId, TestData.OperatorId, TestData.TransactionDateTime.Date);
             FloatActivityAggregate floatActivityAggregate = FloatActivityAggregate.Create(floatActivityAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatActivityAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatActivityAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
             FloatActivityCommands.RecordTransactionCommand command = new FloatActivityCommands.RecordTransactionCommand(TestData.EstateId, TestData.TransactionId);
             Result result = await this.FloatDomainService.RecordTransaction(command, TestContext.Current.CancellationToken);
@@ -238,7 +238,7 @@ public async Task FloatDomainService_RecordTransaction_TransactionRecorded()
         [Fact]
         public async Task FloatDomainService_RecordTransaction_GetTransactionFailed()
         {
-            this.AggregateService.Setup(f => f.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatActivityCommands.RecordTransactionCommand command = new FloatActivityCommands.RecordTransactionCommand(TestData.EstateId, TestData.TransactionId);
             Result result = await this.FloatDomainService.RecordTransaction(command, TestContext.Current.CancellationToken);
@@ -248,8 +248,8 @@ public async Task FloatDomainService_RecordTransaction_GetTransactionFailed()
         [Fact]
         public async Task FloatDomainService_RecordTransaction_GetFloatActivityFailed()
         {
-            this.AggregateService.Setup(f => f.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.GetLatest<FloatActivityAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatActivityCommands.RecordTransactionCommand command = new FloatActivityCommands.RecordTransactionCommand(TestData.EstateId, TestData.TransactionId);
             Result result = await this.FloatDomainService.RecordTransaction(command, TestContext.Current.CancellationToken);
@@ -261,9 +261,9 @@ public async Task FloatDomainService_RecordTransaction_SaveFailed()
         {
             Guid floatActivityAggregateId = IdGenerationService.GenerateFloatActivityAggregateId(TestData.EstateId, TestData.OperatorId, TestData.TransactionDateTime.Date);
             FloatActivityAggregate floatActivityAggregate = FloatActivityAggregate.Create(floatActivityAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatActivityAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatActivityAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             FloatActivityCommands.RecordTransactionCommand command = new FloatActivityCommands.RecordTransactionCommand(TestData.EstateId, TestData.TransactionId);
             Result result = await this.FloatDomainService.RecordTransaction(command, TestContext.Current.CancellationToken);
@@ -275,9 +275,9 @@ public async Task FloatDomainService_RecordTransaction_ExceptionThrown()
         {
             Guid floatActivityAggregateId = IdGenerationService.GenerateFloatActivityAggregateId(TestData.EstateId, TestData.OperatorId, TestData.TransactionDateTime.Date);
             FloatActivityAggregate floatActivityAggregate = FloatActivityAggregate.Create(floatActivityAggregateId);
-            this.AggregateService.Setup(f => f.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(f => f.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatActivityAggregate));
-            this.AggregateService.Setup(f => f.Save<FloatActivityAggregate>(It.IsAny<FloatActivityAggregate>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.GetLatest<FloatActivityAggregate>(floatActivityAggregateId, Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatActivityAggregate));
+            this.AggregateService.Save<FloatActivityAggregate>(Arg<FloatActivityAggregate>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception());
 
             FloatActivityCommands.RecordTransactionCommand command = new FloatActivityCommands.RecordTransactionCommand(TestData.EstateId, TestData.TransactionId);
             Result result = await this.FloatDomainService.RecordTransaction(command, TestContext.Current.CancellationToken);
@@ -286,3 +286,4 @@ public async Task FloatDomainService_RecordTransaction_ExceptionThrown()
     }
 }
 
+
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/MerchantDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/MerchantDomainServiceTests.cs
index 9f430315..8ba557a2 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/MerchantDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/MerchantDomainServiceTests.cs
@@ -1,5 +1,6 @@
 using Microsoft.Extensions.Configuration;
-using Moq;
+using Imposter;
+using Imposter.Abstractions;
 using SecurityService.Client;
 using SecurityService.DataTransferObjects;
 using Shared.DomainDrivenDesign.EventSourcing;
@@ -29,12 +30,12 @@
 namespace TransactionProcessor.BusinessLogic.Tests.Services;
 
 public class MerchantDomainServiceTests {
-    private readonly Mock<IAggregateService> AggregateService;
+    private readonly IAggregateServiceImposter AggregateService;
     
-    private readonly Mock<ISecurityServiceClient> SecurityServiceClient;
+    private readonly ISecurityServiceClientImposter SecurityServiceClient;
 
     private readonly MerchantDomainService DomainService;
-    private readonly Mock<IEventStoreContext> EventStoreContext;
+    private readonly IEventStoreContextImposter EventStoreContext;
 
     public MerchantDomainServiceTests() {
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
@@ -46,12 +47,12 @@ public MerchantDomainServiceTests() {
 
         
 
-        this.AggregateService = new Mock<IAggregateService>();
-        this.SecurityServiceClient = new Mock<ISecurityServiceClient>();
-        this.EventStoreContext = new Mock<IEventStoreContext>();
-        Func<IAggregateService> aggregateServiceResolver = () => this.AggregateService.Object;
+        this.AggregateService = new();
+        this.SecurityServiceClient = new();
+        this.EventStoreContext = new();
+        Func<IAggregateService> aggregateServiceResolver = () => this.AggregateService.Instance();
         this.DomainService = new MerchantDomainService(aggregateServiceResolver,
-            this.SecurityServiceClient.Object, this.EventStoreContext.Object);
+            this.SecurityServiceClient.Instance(), this.EventStoreContext.Instance());
     }
 
     [Theory]
@@ -60,13 +61,13 @@ public MerchantDomainServiceTests() {
     [InlineData(DataTransferObjects.Responses.Merchant.SettlementSchedule.Weekly)]
     public async Task MerchantDomainService_CreateMerchant_MerchantIsCreated(
         DataTransferObjects.Responses.Merchant.SettlementSchedule settlementSchedule) {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         MerchantCommands.CreateMerchantCommand command = TestData.Commands.CreateMerchantCommand;
@@ -79,13 +80,13 @@ public async Task MerchantDomainService_CreateMerchant_MerchantIsCreated(
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_MerchantIdNotSet_MerchantIsCreated() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         MerchantCommands.CreateMerchantCommand command = TestData.Commands.CreateMerchantCommand;
@@ -97,13 +98,13 @@ public async Task MerchantDomainService_CreateMerchant_MerchantIdNotSet_Merchant
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_AlreadyCreated_MerchantIsCreated() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         Result<Guid> result =
@@ -115,12 +116,12 @@ public async Task MerchantDomainService_CreateMerchant_AlreadyCreated_MerchantIs
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_EstateNotFound_ErrorThrown() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
         Result<Guid> result =
@@ -130,15 +131,15 @@ public async Task MerchantDomainService_CreateMerchant_EstateNotFound_ErrorThrow
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorAssigned() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
         Result result =
@@ -149,13 +150,13 @@ await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperat
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
         Result result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand,
@@ -165,13 +166,13 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_MerchantNotCrea
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand,
@@ -181,13 +182,13 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_EstateNotCreate
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorNotFoundForEstate_ErrorThrown() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand,
@@ -202,15 +203,15 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorNotFoun
     [InlineData("")]
     public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorRequiresMerchantNumber_MerchantNumberNotSet_ErrorThrown(
             String merchantNumber) {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
         MerchantCommands.AssignOperatorToMerchantCommand command = new(TestData.EstateId, TestData.MerchantId,
@@ -231,15 +232,15 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorRequire
     [InlineData("")]
     public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorRequiresTerminalNumber_TerminalNumberNotSet_ErrorThrown(
             String terminalNumber) {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
         MerchantCommands.AssignOperatorToMerchantCommand command = new(TestData.EstateId, TestData.MerchantId,
@@ -255,20 +256,20 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_OperatorRequire
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_MerchantUserIsCreated() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
         this.SecurityServiceClient
-            .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(new List<UserResponse>() {
                 new UserResponse {
                     UserId = "FA077CE3-B915-4048-88E3-9B500699317F"
@@ -281,18 +282,18 @@ public async Task MerchantDomainService_CreateMerchantUser_MerchantUserIsCreated
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -300,18 +301,18 @@ public async Task MerchantDomainService_CreateMerchantUser_EstateNotCreated_Erro
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(new MerchantAggregate());
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -319,18 +320,18 @@ public async Task MerchantDomainService_CreateMerchantUser_MerchantNotCreated_Er
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_ErrorCreatingUser_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Failure);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -339,20 +340,20 @@ public async Task MerchantDomainService_CreateMerchantUser_ErrorCreatingUser_Err
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_ErrorGettingUsers_ErrorThrown()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
         this.SecurityServiceClient
-            .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
@@ -362,20 +363,20 @@ public async Task MerchantDomainService_CreateMerchantUser_ErrorGettingUsers_Err
     [Fact] 
     public async Task MerchantDomainService_CreateMerchantUser_UserInListIsNull_ErrorThrown()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
         this.SecurityServiceClient
-            .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            .GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(new List<UserResponse> {
                 null
             }));
@@ -386,14 +387,14 @@ public async Task MerchantDomainService_CreateMerchantUser_UserInListIsNull_Erro
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_MerchantDeviceIsAdded() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -401,14 +402,14 @@ public async Task MerchantDomainService_AddDeviceToMerchant_MerchantDeviceIsAdde
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -416,14 +417,14 @@ public async Task MerchantDomainService_AddDeviceToMerchant_EstateNotCreated_Err
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -432,17 +433,17 @@ public async Task MerchantDomainService_AddDeviceToMerchant_MerchantNotCreated_E
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_DepositIsMade()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -452,17 +453,17 @@ public async Task MerchantDomainService_MakeMerchantDeposit_DepositIsMade()
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_DuplicateDeposit_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantDepositListAggregateWithDeposit()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -472,14 +473,14 @@ public async Task MerchantDomainService_MakeMerchantDeposit_DuplicateDeposit_Res
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_GetDepositListFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -489,18 +490,18 @@ public async Task MerchantDomainService_MakeMerchantDeposit_GetDepositListFailed
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_DepositListSaveFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Failure);
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -508,10 +509,10 @@ public async Task MerchantDomainService_MakeMerchantDeposit_DepositListSaveFaile
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -520,10 +521,10 @@ public async Task MerchantDomainService_MakeMerchantDeposit_EstateNotCreated_Err
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -532,17 +533,17 @@ public async Task MerchantDomainService_MakeMerchantDeposit_MerchantNotCreated_E
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_NoDepositsYet_DepositIsMade() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
        
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantDepositListAggregate));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -551,14 +552,14 @@ public async Task MerchantDomainService_MakeMerchantDeposit_NoDepositsYet_Deposi
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_MerchantDeviceSwapped() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithDevice()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -566,14 +567,14 @@ public async Task MerchantDomainService_SwapMerchantDevice_MerchantDeviceSwapped
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -581,14 +582,14 @@ public async Task MerchantDomainService_SwapMerchantDevice_MerchantNotCreated_Er
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithDevice()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         Result result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -597,15 +598,15 @@ public async Task MerchantDomainService_SwapMerchantDevice_EstateNotCreated_Erro
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantOpeningHours_Success()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantOpeningHours(TestData.Commands.UpdateMerchantOpeningHoursCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -614,10 +615,10 @@ public async Task MerchantDomainService_UpdateMerchantOpeningHours_Success()
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantOpeningHours_MerchantNotCreated_ErrorThrown()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.UpdateMerchantOpeningHours(TestData.Commands.UpdateMerchantOpeningHoursCommand, TestContext.Current.CancellationToken);
@@ -627,10 +628,10 @@ public async Task MerchantDomainService_UpdateMerchantOpeningHours_MerchantNotCr
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantOpeningHours_EstateNotCreated_ErrorThrown()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         var result = await this.DomainService.UpdateMerchantOpeningHours(TestData.Commands.UpdateMerchantOpeningHoursCommand, TestContext.Current.CancellationToken);
@@ -640,33 +641,39 @@ public async Task MerchantDomainService_UpdateMerchantOpeningHours_EstateNotCrea
     [Fact]
     public async Task MerchantDomainService_CreateMerchantSchedule_Success()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        MerchantScheduleAggregate? savedSchedule = null;
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantScheduleAggregate()));
 
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantScheduleAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantScheduleAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.CreateMerchantSchedule(TestData.Commands.CreateMerchantScheduleCommand, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.AggregateService.Verify(m => m.Save(It.Is<MerchantScheduleAggregate>(aggregate =>
-            aggregate.IsCreated &&
-            aggregate.Year == TestData.MerchantScheduleYear &&
-            aggregate.GetSchedule().Months.Single().Month == 1 &&
-            aggregate.GetSchedule().Months.Single().ClosedDays.SequenceEqual(new[] { 1, 26 })), It.IsAny<CancellationToken>()), Times.Once);
+        this.AggregateService.Save(Arg<MerchantScheduleAggregate>.Is(aggregate =>
+        {
+            savedSchedule = aggregate;
+            return true;
+        }), Arg<CancellationToken>.Any()).Called(Count.Once());
+        savedSchedule.ShouldNotBeNull();
+        savedSchedule!.IsCreated.ShouldBeTrue();
+        savedSchedule.Year.ShouldBe(TestData.MerchantScheduleYear);
+        savedSchedule.GetSchedule().Months.Single().Month.ShouldBe(1);
+        savedSchedule.GetSchedule().Months.Single().ClosedDays.ShouldBe(new[] { 1, 26 });
     }
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantSchedule_GetEstateFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantSchedule(TestData.Commands.CreateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -677,9 +684,9 @@ public async Task MerchantDomainService_CreateMerchantSchedule_GetEstateFailed_R
     [Fact]
     public async Task MerchantDomainService_CreateMerchantSchedule_GetMerchantFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantSchedule(TestData.Commands.CreateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -690,11 +697,11 @@ public async Task MerchantDomainService_CreateMerchantSchedule_GetMerchantFailed
     [Fact]
     public async Task MerchantDomainService_CreateMerchantSchedule_GetScheduleFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantSchedule(TestData.Commands.CreateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -705,17 +712,17 @@ public async Task MerchantDomainService_CreateMerchantSchedule_GetScheduleFailed
     [Fact]
     public async Task MerchantDomainService_CreateMerchantSchedule_SaveFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantScheduleAggregate()));
 
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantScheduleAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantScheduleAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantSchedule(TestData.Commands.CreateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -726,30 +733,36 @@ public async Task MerchantDomainService_CreateMerchantSchedule_SaveFailed_Result
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_Success()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        MerchantScheduleAggregate? savedSchedule = null;
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantScheduleAggregate()));
 
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantScheduleAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantScheduleAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
 
         result.IsSuccess.ShouldBeTrue();
-        this.AggregateService.Verify(m => m.Save(It.Is<MerchantScheduleAggregate>(aggregate =>
-            aggregate.GetSchedule().Months.Any(month => month.Month == 2 && month.ClosedDays.SequenceEqual(new[] { 14 }))), It.IsAny<CancellationToken>()), Times.Once);
+        this.AggregateService.Save(Arg<MerchantScheduleAggregate>.Is(aggregate =>
+        {
+            savedSchedule = aggregate;
+            return true;
+        }), Arg<CancellationToken>.Any()).Called(Count.Once());
+        savedSchedule.ShouldNotBeNull();
+        savedSchedule!.GetSchedule().Months.Any(month => month.Month == 2 && month.ClosedDays.SequenceEqual(new[] { 14 })).ShouldBeTrue();
     }
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_GetEstateFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -760,9 +773,9 @@ public async Task MerchantDomainService_UpdateMerchantSchedule_GetEstateFailed_R
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_GetMerchantFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -773,11 +786,11 @@ public async Task MerchantDomainService_UpdateMerchantSchedule_GetMerchantFailed
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_GetScheduleFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -788,11 +801,11 @@ public async Task MerchantDomainService_UpdateMerchantSchedule_GetScheduleFailed
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_ScheduleNotCreated_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantScheduleAggregate()));
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -803,17 +816,17 @@ public async Task MerchantDomainService_UpdateMerchantSchedule_ScheduleNotCreate
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantSchedule_SaveFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantScheduleAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantScheduleAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantScheduleAggregate()));
 
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantScheduleAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantScheduleAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantSchedule(TestData.Commands.UpdateMerchantScheduleCommand, TestContext.Current.CancellationToken);
@@ -823,24 +836,24 @@ public async Task MerchantDomainService_UpdateMerchantSchedule_SaveFailed_Result
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_WithdrawalIsMade() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
        
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            .GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState)));
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState)));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -849,24 +862,24 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_WithdrawalIsMade(
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_DuplicateWithdrawal_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantDepositListAggregateWithWithdrawal()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         this.SecurityServiceClient
-            .Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            .GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState)));
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState)));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -875,14 +888,14 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_DuplicateWithdraw
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_GetDepositListFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -891,10 +904,10 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_GetDepositListFai
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -903,10 +916,10 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_EstateNotCreated_
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -915,14 +928,14 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_MerchantNotCreate
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_MerchantDepositListNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantDepositListAggregate));
         
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -931,20 +944,20 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_MerchantDepositLi
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_NotEnoughFundsToWithdraw_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionStateNoCredit)));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -953,17 +966,17 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_NotEnoughFundsToW
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_InvalidBalanceProjection_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
 
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success<String>("null"));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -972,15 +985,15 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_InvalidBalancePro
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_ContractAdded() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(
                 TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed,
                     FeeType.Merchant));
@@ -991,15 +1004,15 @@ public async Task MerchantDomainService_AddContractToMerchant_ContractAdded() {
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_ContractNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyContractAggregate());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken); 
@@ -1009,15 +1022,15 @@ public async Task MerchantDomainService_AddContractToMerchant_ContractNotCreated
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_GetContractFailed_ErrorThrown()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1026,15 +1039,15 @@ public async Task MerchantDomainService_AddContractToMerchant_GetContractFailed_
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_MerchantNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed,
                     FeeType.Merchant));
 
@@ -1044,15 +1057,15 @@ public async Task MerchantDomainService_AddContractToMerchant_MerchantNotCreated
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_EstateNotCreated_ErrorThrown() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed,
                     FeeType.Merchant));
         
@@ -1066,13 +1079,13 @@ public async Task MerchantDomainService_AddContractToMerchant_EstateNotCreated_E
     [InlineData(DataTransferObjects.Responses.Merchant.SettlementSchedule.Weekly)]
     public async Task MerchantDomainService_UpdateMerchant_MerchantIsUpdated(
         DataTransferObjects.Responses.Merchant.SettlementSchedule settlementSchedule) {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         MerchantCommands.UpdateMerchantCommand command = TestData.Commands.UpdateMerchantCommand;
@@ -1086,13 +1099,13 @@ public async Task MerchantDomainService_UpdateMerchant_MerchantIsUpdated(
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_ValidationError_ResultIsFailed()
     {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
         MerchantCommands.UpdateMerchantCommand command = TestData.Commands.UpdateMerchantCommand;
@@ -1103,14 +1116,14 @@ public async Task MerchantDomainService_UpdateMerchant_ValidationError_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_AddressAdded() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1119,14 +1132,14 @@ public async Task MerchantDomainService_AddMerchantAddress_AddressAdded() {
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_ValidationFailure_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1134,14 +1147,14 @@ public async Task MerchantDomainService_AddMerchantAddress_ValidationFailure_Res
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_AddressUpdated() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1150,14 +1163,14 @@ public async Task MerchantDomainService_UpdateMerchantAddress_AddressUpdated() {
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_ValidationFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1165,14 +1178,14 @@ public async Task MerchantDomainService_UpdateMerchantAddress_ValidationFailed_R
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_ContactAdded() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1181,14 +1194,14 @@ public async Task MerchantDomainService_AddMerchantContact_ContactAdded() {
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_ValidationError_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1196,14 +1209,14 @@ public async Task MerchantDomainService_AddMerchantContact_ValidationError_Resul
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_ContactUpdated() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1212,14 +1225,14 @@ public async Task MerchantDomainService_UpdateMerchantContact_ContactUpdated() {
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_ValidationError_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1227,14 +1240,14 @@ public async Task MerchantDomainService_UpdateMerchantContact_ValidationError_Re
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_OperatorRemoved() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithOperator()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1243,14 +1256,14 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_OperatorRemov
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_ValidationFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithOperator()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1258,14 +1271,14 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_ValidationFai
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_ContractRemoved() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -1274,14 +1287,14 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_ContractRemov
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_ValidationFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(Result.Success);
+            .Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
+            .ReturnsAsync(Result.Success());
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -1289,7 +1302,7 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_ValidationFai
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchant(TestData.Commands.CreateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1298,9 +1311,9 @@ public async Task MerchantDomainService_CreateMerchant_GetEstateFailed_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchant(TestData.Commands.CreateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1309,11 +1322,11 @@ public async Task MerchantDomainService_CreateMerchant_GetMerchantFailed_ResultI
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchant(TestData.Commands.CreateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1322,7 +1335,7 @@ public async Task MerchantDomainService_CreateMerchant_SaveFailed_ResultIsFailed
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -1331,9 +1344,9 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_GetEstateFailed
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -1342,11 +1355,11 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_GetMerchantFail
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_GetOperatorFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -1356,13 +1369,13 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_GetOperatorFail
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_StateChangeFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -1371,13 +1384,13 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_StateChangeFail
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EstateAggregateWithOperator());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -1386,7 +1399,7 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_SaveFailed_Resu
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
@@ -1395,9 +1408,9 @@ public async Task MerchantDomainService_CreateMerchantUser_GetEstateFailed_Resul
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
@@ -1406,15 +1419,15 @@ public async Task MerchantDomainService_CreateMerchantUser_GetMerchantFailed_Res
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.SecurityServiceClient.Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
+        this.SecurityServiceClient.CreateUser(Arg<CreateUserRequest>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
-        this.SecurityServiceClient.Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.SecurityServiceClient.GetUsers(Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(new List<UserResponse> { new UserResponse { UserId = "FA077CE3-B915-4048-88E3-9B500699317F" } }));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
@@ -1423,7 +1436,7 @@ public async Task MerchantDomainService_CreateMerchantUser_SaveFailed_ResultIsFa
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1432,9 +1445,9 @@ public async Task MerchantDomainService_AddDeviceToMerchant_GetEstateFailed_Resu
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1444,11 +1457,11 @@ public async Task MerchantDomainService_AddDeviceToMerchant_GetMerchantFailed_Re
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_StateChangeFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1457,11 +1470,11 @@ public async Task MerchantDomainService_AddDeviceToMerchant_StateChangeFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1470,7 +1483,7 @@ public async Task MerchantDomainService_AddDeviceToMerchant_SaveFailed_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -1479,9 +1492,9 @@ public async Task MerchantDomainService_MakeMerchantDeposit_GetEstateFailed_Resu
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -1490,7 +1503,7 @@ public async Task MerchantDomainService_MakeMerchantDeposit_GetMerchantFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1499,9 +1512,9 @@ public async Task MerchantDomainService_SwapMerchantDevice_GetEstateFailed_Resul
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1511,11 +1524,11 @@ public async Task MerchantDomainService_SwapMerchantDevice_GetMerchantFailed_Res
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_StateChangedFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithDevice()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var command = TestData.Commands.SwapMerchantDeviceCommand with {
@@ -1528,11 +1541,11 @@ public async Task MerchantDomainService_SwapMerchantDevice_StateChangedFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithDevice()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -1541,7 +1554,7 @@ public async Task MerchantDomainService_SwapMerchantDevice_SaveFailed_ResultIsFa
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -1550,9 +1563,9 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_GetEstateFailed_R
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -1561,14 +1574,14 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_GetMerchantFailed
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_GetBalanceFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -1577,16 +1590,16 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_GetBalanceFailed_
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success<String>(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState)));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -1595,7 +1608,7 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_SaveFailed_Result
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1604,9 +1617,9 @@ public async Task MerchantDomainService_AddContractToMerchant_GetEstateFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1616,13 +1629,13 @@ public async Task MerchantDomainService_AddContractToMerchant_GetMerchantFailed_
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_StateChangeFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1631,13 +1644,13 @@ public async Task MerchantDomainService_AddContractToMerchant_StateChangeFailed_
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1646,7 +1659,7 @@ public async Task MerchantDomainService_AddContractToMerchant_SaveFailed_ResultI
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchant(TestData.Commands.UpdateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1655,9 +1668,9 @@ public async Task MerchantDomainService_UpdateMerchant_GetEstateFailed_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchant(TestData.Commands.UpdateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1666,9 +1679,9 @@ public async Task MerchantDomainService_UpdateMerchant_GetMerchantFailed_ResultI
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.UpdateMerchant(TestData.Commands.UpdateMerchantCommand, TestContext.Current.CancellationToken);
@@ -1677,11 +1690,11 @@ public async Task MerchantDomainService_UpdateMerchant_MerchantNotCreated_Result
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         MerchantCommands.UpdateMerchantCommand command = TestData.Commands.UpdateMerchantCommand;
@@ -1693,7 +1706,7 @@ public async Task MerchantDomainService_UpdateMerchant_SaveFailed_ResultIsFailed
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1702,9 +1715,9 @@ public async Task MerchantDomainService_AddMerchantAddress_GetEstateFailed_Resul
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1713,9 +1726,9 @@ public async Task MerchantDomainService_AddMerchantAddress_GetMerchantFailed_Res
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1724,11 +1737,11 @@ public async Task MerchantDomainService_AddMerchantAddress_MerchantNotCreated_Re
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1737,7 +1750,7 @@ public async Task MerchantDomainService_AddMerchantAddress_SaveFailed_ResultIsFa
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1746,9 +1759,9 @@ public async Task MerchantDomainService_UpdateMerchantAddress_GetEstateFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1757,9 +1770,9 @@ public async Task MerchantDomainService_UpdateMerchantAddress_GetMerchantFailed_
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1768,11 +1781,11 @@ public async Task MerchantDomainService_UpdateMerchantAddress_MerchantNotCreated
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -1781,7 +1794,7 @@ public async Task MerchantDomainService_UpdateMerchantAddress_SaveFailed_ResultI
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1790,9 +1803,9 @@ public async Task MerchantDomainService_AddMerchantContact_GetEstateFailed_Resul
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1801,9 +1814,9 @@ public async Task MerchantDomainService_AddMerchantContact_GetMerchantFailed_Res
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1812,11 +1825,11 @@ public async Task MerchantDomainService_AddMerchantContact_MerchantNotCreated_Re
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1825,7 +1838,7 @@ public async Task MerchantDomainService_AddMerchantContact_SaveFailed_ResultIsFa
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1834,9 +1847,9 @@ public async Task MerchantDomainService_UpdateMerchantContact_GetEstateFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1845,9 +1858,9 @@ public async Task MerchantDomainService_UpdateMerchantContact_GetMerchantFailed_
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1856,11 +1869,11 @@ public async Task MerchantDomainService_UpdateMerchantContact_MerchantNotCreated
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -1869,7 +1882,7 @@ public async Task MerchantDomainService_UpdateMerchantContact_SaveFailed_ResultI
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
@@ -1878,9 +1891,9 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_GetEstateFail
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
@@ -1889,9 +1902,9 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_GetMerchantFa
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
@@ -1901,11 +1914,11 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_MerchantNotCr
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_StateChangeFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithOperator()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var command = TestData.Commands.RemoveOperatorFromMerchantCommand with { OperatorId = Guid.NewGuid() };
@@ -1916,11 +1929,11 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_StateChangeFa
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithOperator()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
@@ -1929,7 +1942,7 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_SaveFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_GetEstateFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1938,9 +1951,9 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_GetEstateFail
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_GetMerchantFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1949,9 +1962,9 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_GetMerchantFa
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_MerchantNotCreated_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1961,11 +1974,11 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_MerchantNotCr
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_StateChangeFailed_ResultIsFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var command = TestData.Commands.RemoveMerchantContractCommand with { ContractId = Guid.NewGuid() };
@@ -1976,11 +1989,11 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_StateChangeFa
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_SaveFailed_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -1989,11 +2002,11 @@ public async Task MerchantDomainService_RemoveContractFromMerchant_SaveFailed_Re
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_NotSetSettlementSchedule_ResultIsFailed() {
-        this.AggregateService.Setup(m => m.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
-        this.AggregateService.Setup(m => m.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
         MerchantCommands.CreateMerchantCommand command = TestData.Commands.CreateMerchantCommand;
@@ -2005,15 +2018,15 @@ public async Task MerchantDomainService_CreateMerchant_NotSetSettlementSchedule_
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_AutomaticDepositSource_DepositIsMade() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
         this.AggregateService
-            .Setup(m => m.GetLatest<MerchantDepositListAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            .GetLatest<MerchantDepositListAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantDepositListAggregate()));
         this.AggregateService
-            .Setup(m => m.Save(It.IsAny<MerchantDepositListAggregate>(), It.IsAny<CancellationToken>()))
+            .Save(Arg<MerchantDepositListAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success());
 
         MerchantCommands.MakeMerchantDepositCommand command = new(TestData.EstateId, TestData.MerchantId,
@@ -2025,7 +2038,7 @@ public async Task MerchantDomainService_MakeMerchantDeposit_AutomaticDepositSour
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.CreateMerchant(TestData.Commands.CreateMerchantCommand, TestContext.Current.CancellationToken);
@@ -2034,7 +2047,7 @@ public async Task MerchantDomainService_CreateMerchant_ExceptionThrown_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_AssignOperatorToMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.AssignOperatorToMerchant(TestData.Commands.AssignOperatorToMerchantCommand, TestContext.Current.CancellationToken);
@@ -2043,7 +2056,7 @@ public async Task MerchantDomainService_AssignOperatorToMerchant_ExceptionThrown
 
     [Fact]
     public async Task MerchantDomainService_CreateMerchantUser_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.CreateMerchantUser(TestData.Commands.CreateMerchantUserCommand, TestContext.Current.CancellationToken);
@@ -2052,7 +2065,7 @@ public async Task MerchantDomainService_CreateMerchantUser_ExceptionThrown_Resul
 
     [Fact]
     public async Task MerchantDomainService_AddDeviceToMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.AddDeviceToMerchant(TestData.Commands.AddMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -2061,7 +2074,7 @@ public async Task MerchantDomainService_AddDeviceToMerchant_ExceptionThrown_Resu
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantDeposit_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.MakeMerchantDeposit(TestData.Commands.MakeMerchantDepositCommand, TestContext.Current.CancellationToken);
@@ -2070,7 +2083,7 @@ public async Task MerchantDomainService_MakeMerchantDeposit_ExceptionThrown_Resu
 
     [Fact]
     public async Task MerchantDomainService_SwapMerchantDevice_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.SwapMerchantDevice(TestData.Commands.SwapMerchantDeviceCommand, TestContext.Current.CancellationToken);
@@ -2079,7 +2092,7 @@ public async Task MerchantDomainService_SwapMerchantDevice_ExceptionThrown_Resul
 
     [Fact]
     public async Task MerchantDomainService_MakeMerchantWithdrawal_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.MakeMerchantWithdrawal(TestData.Commands.MakeMerchantWithdrawalCommand, TestContext.Current.CancellationToken);
@@ -2088,7 +2101,7 @@ public async Task MerchantDomainService_MakeMerchantWithdrawal_ExceptionThrown_R
 
     [Fact]
     public async Task MerchantDomainService_AddContractToMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.AddContractToMerchant(TestData.Commands.AddMerchantContractCommand, TestContext.Current.CancellationToken);
@@ -2097,7 +2110,7 @@ public async Task MerchantDomainService_AddContractToMerchant_ExceptionThrown_Re
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.UpdateMerchant(TestData.Commands.UpdateMerchantCommand, TestContext.Current.CancellationToken);
@@ -2106,7 +2119,7 @@ public async Task MerchantDomainService_UpdateMerchant_ExceptionThrown_ResultIsF
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantAddress_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.AddMerchantAddress(TestData.Commands.AddMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -2115,7 +2128,7 @@ public async Task MerchantDomainService_AddMerchantAddress_ExceptionThrown_Resul
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantAddress_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.UpdateMerchantAddress(TestData.Commands.UpdateMerchantAddressCommand, TestContext.Current.CancellationToken);
@@ -2124,7 +2137,7 @@ public async Task MerchantDomainService_UpdateMerchantAddress_ExceptionThrown_Re
 
     [Fact]
     public async Task MerchantDomainService_AddMerchantContact_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.AddMerchantContact(TestData.Commands.AddMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -2133,7 +2146,7 @@ public async Task MerchantDomainService_AddMerchantContact_ExceptionThrown_Resul
 
     [Fact]
     public async Task MerchantDomainService_UpdateMerchantContact_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.UpdateMerchantContact(TestData.Commands.UpdateMerchantContactCommand, TestContext.Current.CancellationToken);
@@ -2142,7 +2155,7 @@ public async Task MerchantDomainService_UpdateMerchantContact_ExceptionThrown_Re
 
     [Fact]
     public async Task MerchantDomainService_RemoveOperatorFromMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.RemoveOperatorFromMerchant(TestData.Commands.RemoveOperatorFromMerchantCommand, TestContext.Current.CancellationToken);
@@ -2151,7 +2164,7 @@ public async Task MerchantDomainService_RemoveOperatorFromMerchant_ExceptionThro
 
     [Fact]
     public async Task MerchantDomainService_RemoveContractFromMerchant_ExceptionThrown_ResultIsFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception("Test exception"));
 
         var result = await this.DomainService.RemoveContractFromMerchant(TestData.Commands.RemoveMerchantContractCommand, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/MerchantStatementDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/MerchantStatementDomainServiceTests.cs
index 0dfcd594..b3bb7bd9 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/MerchantStatementDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/MerchantStatementDomainServiceTests.cs
@@ -1,7 +1,7 @@
 using MessagingService.Client;
 using MessagingService.DataTransferObjects;
 using Microsoft.Extensions.Configuration;
-using Moq;
+using Imposter.Abstractions;
 using SecurityService.Client;
 using Shared.EventStore.Aggregate;
 using Shared.General;
@@ -23,19 +23,19 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services;
 
 public class MerchantStatementDomainServiceTests {
 
-    private readonly Mock<IAggregateService> AggregateService;
-    private readonly Mock<IStatementBuilder> StatementBuilder;
-    private readonly Mock<IMessagingServiceClient> MessagingServiceClient;
-    private readonly Mock<ISecurityServiceClient> SecurityServiceClient;
+    private readonly IAggregateServiceImposter AggregateService;
+    private readonly IStatementBuilderImposter StatementBuilder;
+    private readonly IMessagingServiceClientImposter MessagingServiceClient;
+    private readonly ISecurityServiceClientImposter SecurityServiceClient;
     private readonly MerchantStatementDomainService DomainService;
     public MerchantStatementDomainServiceTests() {
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-        this.AggregateService = new Mock<IAggregateService>();
-        this.StatementBuilder = new Mock<IStatementBuilder>();
-        this.MessagingServiceClient = new Mock<IMessagingServiceClient>();
-        this.SecurityServiceClient = new Mock<ISecurityServiceClient>();
-        IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
-        this.DomainService = new MerchantStatementDomainService(AggregateServiceResolver, this.StatementBuilder.Object, this.MessagingServiceClient.Object, this.SecurityServiceClient.Object);
+        this.AggregateService = new IAggregateServiceImposter();
+        this.StatementBuilder = new IStatementBuilderImposter();
+        this.MessagingServiceClient = new IMessagingServiceClientImposter();
+        this.SecurityServiceClient = new ISecurityServiceClientImposter();
+        IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
+        this.DomainService = new MerchantStatementDomainService(AggregateServiceResolver, this.StatementBuilder.Instance(), this.MessagingServiceClient.Instance(), this.SecurityServiceClient.Instance());
 
         IConfigurationRoot configurationRoot =
             new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
@@ -46,8 +46,8 @@ public MerchantStatementDomainServiceTests() {
     [Fact]
     public async Task MerchantStatementDomainService_AddTransactionToStatement_TransactionAddedToStatement() {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -56,8 +56,8 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_Trans
     public async Task MerchantStatementDomainService_AddTransactionToStatement_TransactionNotAuthorised_TransactionNotAddedToStatement()
     {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionNotAuthorisedToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -66,8 +66,8 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_Trans
     public async Task MerchantStatementDomainService_AddTransactionToStatement_TransactionHasNotAmount_TransactionNotAddedToStatement()
     {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionWithNoAmountToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -76,8 +76,8 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_Trans
     public async Task MerchantStatementDomainService_AddTransactionToStatement_SaveFailed_TransactionNotAddedToStatement()
     {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -85,8 +85,8 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_SaveF
     [Fact]
     public async Task MerchantStatementDomainService_AddSettledFeeToStatement_SettledFeeAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddSettledFeeToStatement(TestData.Commands.AddSettledFeeToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -94,8 +94,8 @@ public async Task MerchantStatementDomainService_AddSettledFeeToStatement_Settle
     [Fact]
     public async Task MerchantStatementDomainService_AddSettledFeeToStatement_SaveFailed_SettledFeeNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddSettledFeeToStatement(TestData.Commands.AddSettledFeeToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -104,8 +104,8 @@ public async Task MerchantStatementDomainService_AddSettledFeeToStatement_SaveFa
     public async Task MerchantStatementDomainService_AddDepositToStatement_DepositAddedToStatement()
     {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddDepositToStatement(TestData.Commands.AddDepositToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -114,16 +114,16 @@ public async Task MerchantStatementDomainService_AddDepositToStatement_DepositAd
     public async Task MerchantStatementDomainService_AddWithdrawalToStatement_WithdrawalAddedToStatement()
     {
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.AddWithdrawalToStatement(TestData.Commands.AddWithdrawalToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
 
     [Fact]
     public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantStatement_SaveFailed_ActivityDateNotRecorded() {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementAggregate));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.DomainService.RecordActivityDateOnMerchantStatement(TestData.Commands.RecordActivityDateOnMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -131,8 +131,8 @@ public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantSta
     [Fact]
     public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantStatement_ActivityDateRecorded()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementAggregate));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.RecordActivityDateOnMerchantStatement(TestData.Commands.RecordActivityDateOnMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -140,10 +140,10 @@ public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantSta
     [Fact]
     public async Task MerchantStatementDomainService_GenerateStatement_StatementIsGenerated()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
         Result result = await this.DomainService.GenerateStatement(TestData.Commands.GenerateMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -152,10 +152,10 @@ public async Task MerchantStatementDomainService_GenerateStatement_StatementIsGe
     [Fact]
     public async Task MerchantStatementDomainService_GenerateStatement_GetStatementForDateFailed_StatementIsNotGenerated()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
         Result result = await this.DomainService.GenerateStatement(TestData.Commands.GenerateMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -164,10 +164,10 @@ public async Task MerchantStatementDomainService_GenerateStatement_GetStatementF
     [Fact]
     public async Task MerchantStatementDomainService_GenerateStatement_SaveFailed_StatementIsNotGenerated()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementAggregateWithActivityDates()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
         Result result = await this.DomainService.GenerateStatement(TestData.Commands.GenerateMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -176,14 +176,14 @@ public async Task MerchantStatementDomainService_GenerateStatement_SaveFailed_St
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_StatementIsBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.StatementBuilder.Setup(s => s.GetStatementHtml(It.IsAny<MerchantStatementAggregate>(), It.IsAny<Merchant>(), It.IsAny<CancellationToken>())).ReturnsAsync("<html></html>");
+        this.StatementBuilder.GetStatementHtml(Arg<MerchantStatementAggregate>.Any(), Arg<Merchant>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync("<html></html>");
 
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -192,14 +192,14 @@ public async Task MerchantStatementDomainService_BuildStatement_StatementIsBuilt
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_GetMerchantFailed_StatementIsNotBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
-        this.StatementBuilder.Setup(s => s.GetStatementHtml(It.IsAny<MerchantStatementAggregate>(), It.IsAny<Merchant>(), It.IsAny<CancellationToken>())).ReturnsAsync("<html></html>");
+        this.StatementBuilder.GetStatementHtml(Arg<MerchantStatementAggregate>.Any(), Arg<Merchant>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync("<html></html>");
 
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -208,14 +208,14 @@ public async Task MerchantStatementDomainService_BuildStatement_GetMerchantFaile
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_MerchantNotCreated_StatementIsNotBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantAggregate()));
 
-        this.StatementBuilder.Setup(s => s.GetStatementHtml(It.IsAny<MerchantStatementAggregate>(), It.IsAny<Merchant>(), It.IsAny<CancellationToken>())).ReturnsAsync("<html></html>");
+        this.StatementBuilder.GetStatementHtml(Arg<MerchantStatementAggregate>.Any(), Arg<Merchant>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync("<html></html>");
 
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -224,14 +224,14 @@ public async Task MerchantStatementDomainService_BuildStatement_MerchantNotCreat
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_SaveFailed_StatementIsNotBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantStatementForDateAggregateWithTransactionAndFee()));
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.StatementBuilder.Setup(s => s.GetStatementHtml(It.IsAny<MerchantStatementAggregate>(), It.IsAny<Merchant>(), It.IsAny<CancellationToken>())).ReturnsAsync("<html></html>");
+        this.StatementBuilder.GetStatementHtml(Arg<MerchantStatementAggregate>.Any(), Arg<Merchant>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync("<html></html>");
 
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -240,14 +240,14 @@ public async Task MerchantStatementDomainService_BuildStatement_SaveFailed_State
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_StatementIsEmailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.MessagingServiceClient.Setup(m => m.SendEmail(It.IsAny<String>(), It.IsAny<SendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.MessagingServiceClient.SendEmail(Arg<String>.Any(), Arg<SendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.SecurityServiceClient.Setup(m => m.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
@@ -256,14 +256,14 @@ public async Task MerchantStatementDomainService_EmailStatement_StatementIsEmail
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_MerchantNotFound_StatementIsNotEmailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
-        this.MessagingServiceClient.Setup(m => m.SendEmail(It.IsAny<String>(), It.IsAny<SendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.MessagingServiceClient.SendEmail(Arg<String>.Any(), Arg<SendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.SecurityServiceClient.Setup(m => m.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -272,14 +272,14 @@ public async Task MerchantStatementDomainService_EmailStatement_MerchantNotFound
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_GetTokenFailed_StatementIsNotEmailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.MessagingServiceClient.Setup(m => m.SendEmail(It.IsAny<String>(), It.IsAny<SendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.MessagingServiceClient.SendEmail(Arg<String>.Any(), Arg<SendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.SecurityServiceClient.Setup(m => m.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -288,7 +288,7 @@ public async Task MerchantStatementDomainService_EmailStatement_GetTokenFailed_S
     [Fact]
     public async Task MerchantStatementDomainService_AddTransactionToStatement_GetStatementForDateFailed_TransactionNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -296,7 +296,7 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_GetSt
     [Fact]
     public async Task MerchantStatementDomainService_AddSettledFeeToStatement_GetStatementForDateFailed_SettledFeeNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddSettledFeeToStatement(TestData.Commands.AddSettledFeeToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -304,8 +304,8 @@ public async Task MerchantStatementDomainService_AddSettledFeeToStatement_GetSta
     [Fact]
     public async Task MerchantStatementDomainService_AddDepositToStatement_SaveFailed_DepositNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddDepositToStatement(TestData.Commands.AddDepositToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -313,7 +313,7 @@ public async Task MerchantStatementDomainService_AddDepositToStatement_SaveFaile
     [Fact]
     public async Task MerchantStatementDomainService_AddDepositToStatement_GetStatementForDateFailed_DepositNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddDepositToStatement(TestData.Commands.AddDepositToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -321,8 +321,8 @@ public async Task MerchantStatementDomainService_AddDepositToStatement_GetStatem
     [Fact]
     public async Task MerchantStatementDomainService_AddWithdrawalToStatement_SaveFailed_WithdrawalNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementForDateAggregate>(It.IsAny<MerchantStatementForDateAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EmptyMerchantStatementForDateAggregate));
+        this.AggregateService.Save<MerchantStatementForDateAggregate>(Arg<MerchantStatementForDateAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddWithdrawalToStatement(TestData.Commands.AddWithdrawalToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -330,7 +330,7 @@ public async Task MerchantStatementDomainService_AddWithdrawalToStatement_SaveFa
     [Fact]
     public async Task MerchantStatementDomainService_AddWithdrawalToStatement_GetStatementForDateFailed_WithdrawalNotAddedToStatement()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.AddWithdrawalToStatement(TestData.Commands.AddWithdrawalToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -338,7 +338,7 @@ public async Task MerchantStatementDomainService_AddWithdrawalToStatement_GetSta
     [Fact]
     public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantStatement_GetStatementFailed_ActivityDateNotRecorded()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.RecordActivityDateOnMerchantStatement(TestData.Commands.RecordActivityDateOnMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -346,7 +346,7 @@ public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantSta
     [Fact]
     public async Task MerchantStatementDomainService_GenerateStatement_GetStatementFailed_StatementIsNotGenerated()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.GenerateStatement(TestData.Commands.GenerateMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -354,7 +354,7 @@ public async Task MerchantStatementDomainService_GenerateStatement_GetStatementF
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_GetStatementFailed_StatementIsNotBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -362,12 +362,12 @@ public async Task MerchantStatementDomainService_BuildStatement_GetStatementFail
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_GetStatementHtmlFailed_StatementIsNotBuilt()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.GeneratedMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.StatementBuilder.Setup(s => s.GetStatementHtml(It.IsAny<MerchantStatementAggregate>(), It.IsAny<Merchant>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.StatementBuilder.GetStatementHtml(Arg<MerchantStatementAggregate>.Any(), Arg<Merchant>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -376,7 +376,7 @@ public async Task MerchantStatementDomainService_BuildStatement_GetStatementHtml
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_GetStatementFailed_StatementIsNotEmailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -384,14 +384,14 @@ public async Task MerchantStatementDomainService_EmailStatement_GetStatementFail
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_SaveFailed_StatementIsNotEmailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
-        this.AggregateService.Setup(a => a.Save<MerchantStatementAggregate>(It.IsAny<MerchantStatementAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.BuiltMerchantStatementAggregate()));
+        this.AggregateService.Save<MerchantStatementAggregate>(Arg<MerchantStatementAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
-        this.AggregateService.Setup(a => a.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)));
 
-        this.MessagingServiceClient.Setup(m => m.SendEmail(It.IsAny<String>(), It.IsAny<SendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.MessagingServiceClient.SendEmail(Arg<String>.Any(), Arg<SendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-        this.SecurityServiceClient.Setup(m => m.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -400,7 +400,7 @@ public async Task MerchantStatementDomainService_EmailStatement_SaveFailed_State
     [Fact]
     public async Task MerchantStatementDomainService_AddTransactionToStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.AddTransactionToStatement(TestData.Commands.AddTransactionToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -408,7 +408,7 @@ public async Task MerchantStatementDomainService_AddTransactionToStatement_Excep
     [Fact]
     public async Task MerchantStatementDomainService_AddSettledFeeToStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.AddSettledFeeToStatement(TestData.Commands.AddSettledFeeToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -416,7 +416,7 @@ public async Task MerchantStatementDomainService_AddSettledFeeToStatement_Except
     [Fact]
     public async Task MerchantStatementDomainService_AddDepositToStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.AddDepositToStatement(TestData.Commands.AddDepositToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -424,7 +424,7 @@ public async Task MerchantStatementDomainService_AddDepositToStatement_Exception
     [Fact]
     public async Task MerchantStatementDomainService_AddWithdrawalToStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementForDateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementForDateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.AddWithdrawalToStatement(TestData.Commands.AddWithdrawalToMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -432,7 +432,7 @@ public async Task MerchantStatementDomainService_AddWithdrawalToStatement_Except
     [Fact]
     public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.RecordActivityDateOnMerchantStatement(TestData.Commands.RecordActivityDateOnMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -440,7 +440,7 @@ public async Task MerchantStatementDomainService_RecordActivityDateOnMerchantSta
     [Fact]
     public async Task MerchantStatementDomainService_GenerateStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.GenerateStatement(TestData.Commands.GenerateMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -448,7 +448,7 @@ public async Task MerchantStatementDomainService_GenerateStatement_ExceptionThro
     [Fact]
     public async Task MerchantStatementDomainService_BuildStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.BuildStatement(TestData.Commands.BuildMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
@@ -456,7 +456,7 @@ public async Task MerchantStatementDomainService_BuildStatement_ExceptionThrown_
     [Fact]
     public async Task MerchantStatementDomainService_EmailStatement_ExceptionThrown_ResultIsFailed()
     {
-        this.AggregateService.Setup(a => a.GetLatest<MerchantStatementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ThrowsAsync(new Exception("Test exception"));
+        this.AggregateService.GetLatest<MerchantStatementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ThrowsAsync(new Exception("Test exception"));
         Result result = await this.DomainService.EmailStatement(TestData.Commands.EmailMerchantStatementCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/OperatorDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/OperatorDomainServiceTests.cs
index db01df9e..05ad3b56 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/OperatorDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/OperatorDomainServiceTests.cs
@@ -1,4 +1,4 @@
-using Moq;
+using Imposter.Abstractions;
 using Shared.DomainDrivenDesign.EventSourcing;
 using Shared.EventStore.Aggregate;
 using Shared.Serialisation;
@@ -20,23 +20,22 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services;
 public class OperatorDomainServiceTests{
 
     private IOperatorDomainService OperatorDomainService;
-    private Mock<IAggregateService> AggregateService;
+    private IAggregateServiceImposter AggregateService;
 
     public OperatorDomainServiceTests(){
-        this.AggregateService = new Mock<IAggregateService>();
-        IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
+        this.AggregateService = new IAggregateServiceImposter();
+        IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
         this.OperatorDomainService = new OperatorDomainService(AggregateServiceResolver);
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
     }
 
     [Fact]
     public async Task OperatorDomainService_CreateOperator_OperatorIsCreated(){
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                  .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
-        this.AggregateService
-            .Setup(o => o.Save(It.IsAny<OperatorAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
+        this.AggregateService.Save(Arg<OperatorAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
 
@@ -45,12 +44,11 @@ public async Task OperatorDomainService_CreateOperator_OperatorIsCreated(){
     [Fact]
     public async Task OperatorDomainService_CreateOperator_OperatorIdIsEmpty_OperatorIsCreated()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
-        this.AggregateService
-            .Setup(o => o.Save(It.IsAny<OperatorAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.Save(Arg<OperatorAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
         OperatorCommands.CreateOperatorCommand emptyIdCommand = new(TestData.EstateId,
             new CreateOperatorRequest {
@@ -67,9 +65,9 @@ public async Task OperatorDomainService_CreateOperator_OperatorIdIsEmpty_Operato
     [Fact]
     public async Task OperatorDomainService_CreateOperator_EstateNotCreated_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -78,10 +76,10 @@ public async Task OperatorDomainService_CreateOperator_EstateNotCreated_ResultFa
 
     [Fact]
     public async Task OperatorDomainService_CreateOperator_OperatorAlreadyCreated_ResultFailed() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
 
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -90,9 +88,9 @@ public async Task OperatorDomainService_CreateOperator_OperatorAlreadyCreated_Re
     [Fact]
     public async Task OperatorDomainService_CreateOperator_OperatorNameEmpty_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
 
         OperatorCommands.CreateOperatorCommand emptyNameCommand = new(TestData.EstateId,
@@ -110,11 +108,10 @@ public async Task OperatorDomainService_CreateOperator_OperatorNameEmpty_ResultF
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_OperatorIsUpdated()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-        this.AggregateService
-            .Setup(o => o.Save(It.IsAny<OperatorAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+        this.AggregateService.Save(Arg<OperatorAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -122,9 +119,9 @@ public async Task OperatorDomainService_UpdateOperator_OperatorIsUpdated()
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_OperatorNotCreated_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
@@ -133,7 +130,7 @@ public async Task OperatorDomainService_UpdateOperator_OperatorNotCreated_Result
     [Fact]
     public async Task OperatorDomainService_CreateOperator_GetEstateFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
@@ -143,9 +140,9 @@ public async Task OperatorDomainService_CreateOperator_GetEstateFailed_ResultFai
     [Fact]
     public async Task OperatorDomainService_CreateOperator_GetOperatorFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
@@ -155,11 +152,11 @@ public async Task OperatorDomainService_CreateOperator_GetOperatorFailed_ResultF
     [Fact]
     public async Task OperatorDomainService_CreateOperator_SaveFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.EmptyOperatorAggregate()));
-        this.AggregateService.Setup(o => o.Save(It.IsAny<OperatorAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<OperatorAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
@@ -169,7 +166,7 @@ public async Task OperatorDomainService_CreateOperator_SaveFailed_ResultFailed()
     [Fact]
     public async Task OperatorDomainService_CreateOperator_ExceptionThrown_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception());
 
         Result result = await this.OperatorDomainService.CreateOperator(TestData.Commands.CreateOperatorCommand, TestContext.Current.CancellationToken);
@@ -179,7 +176,7 @@ public async Task OperatorDomainService_CreateOperator_ExceptionThrown_ResultFai
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_GetEstateFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
@@ -189,9 +186,9 @@ public async Task OperatorDomainService_UpdateOperator_GetEstateFailed_ResultFai
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_EstateNotCreated_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
@@ -201,9 +198,9 @@ public async Task OperatorDomainService_UpdateOperator_EstateNotCreated_ResultFa
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_GetOperatorFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
@@ -213,11 +210,11 @@ public async Task OperatorDomainService_UpdateOperator_GetOperatorFailed_ResultF
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_SaveFailed_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
-        this.AggregateService.Setup(o => o.GetLatest<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.GetLatest<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(SimpleResults.Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-        this.AggregateService.Setup(o => o.Save(It.IsAny<OperatorAggregate>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Save(Arg<OperatorAggregate>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure());
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
@@ -227,10 +224,18 @@ public async Task OperatorDomainService_UpdateOperator_SaveFailed_ResultFailed()
     [Fact]
     public async Task OperatorDomainService_UpdateOperator_ExceptionThrown_ResultFailed()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ThrowsAsync(new Exception());
 
         Result result = await this.OperatorDomainService.UpdateOperator(TestData.Commands.UpdateOperatorCommand, TestContext.Current.CancellationToken);
         result.IsFailed.ShouldBeTrue();
     }
 }
+
+
+
+
+
+
+
+
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/SettlementDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/SettlementDomainServiceTests.cs
index 5e2caf0c..369ef185 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/SettlementDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/SettlementDomainServiceTests.cs
@@ -8,7 +8,8 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
 {
     using BusinessLogic.Services;
     using Microsoft.Extensions.Configuration;
-    using Moq;
+    using Imposter;
+    using Imposter.Abstractions;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EventStore.Aggregate;
     using Shared.General;
@@ -25,14 +26,14 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
 
     public class SettlementDomainServiceTests
     {
-        private Mock<IAggregateService> AggregateService;
+        private IAggregateServiceImposter AggregateService;
         private SettlementDomainService settlementDomainService;
 
         public SettlementDomainServiceTests() {
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
             this.AggregateService =
-                new Mock<IAggregateService>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
+                new IAggregateServiceImposter();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
             this.settlementDomainService =
                 new SettlementDomainService(AggregateServiceResolver);
 
@@ -45,35 +46,34 @@ public SettlementDomainServiceTests() {
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_SettlementIsProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
+
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -89,39 +89,39 @@ public async Task SettlementDomainService_ProcessSettlement_SettlementIsProcesse
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_RunOutOfRetries_SettlementIsNotProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }));
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success());
-
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                .Then().ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
+                .Then().ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
+                .Then().ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
+                .Then().ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }))
+                .Then().ReturnsAsync(Result.Failure(new List<String> { "WrongExpectedVersion" }));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
+
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -131,41 +131,41 @@ public async Task SettlementDomainService_ProcessSettlement_RunOutOfRetries_Sett
             Result<Guid> result = await settlementDomainService.ProcessSettlement(command, TestContext.Current.CancellationToken);
 
             result.IsSuccess.ShouldBeFalse();
-            this.AggregateService.Verify(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()), Times.Exactly(7));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(12));
         }
 
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_RetryOnWrongExpected_SettlementIsProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure(new List<String>{ "WrongExpectedVersion" }))
-                .ReturnsAsync(Result.Success());
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success());
-
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                .Then().ReturnsAsync(Result.Success());
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
+
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -176,42 +176,41 @@ public async Task SettlementDomainService_ProcessSettlement_RetryOnWrongExpected
 
             result.IsSuccess.ShouldBeTrue();
             result.Data.ShouldNotBe(Guid.Empty);
-            this.AggregateService.Verify(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any()).Called(Count.Exactly(2));
         }
 
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_MerchantWithImmediateSettlement_SettlementIsProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9)));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9)));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
 
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -227,10 +226,9 @@ public async Task SettlementDomainService_ProcessSettlement_MerchantWithImmediat
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_SettlementAggregateNotCreated_NothingProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetEmptySettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -245,12 +243,11 @@ public async Task SettlementDomainService_ProcessSettlement_SettlementAggregateN
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_SettlementAggregateNoFeesToSettles_NothingProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command =
@@ -265,36 +262,35 @@ public async Task SettlementDomainService_ProcessSettlement_SettlementAggregateN
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_AddSettledFeeThrownException_SettlementProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8)))
-                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9)));
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Failure())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8)))
+                .Then().ReturnsAsync(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9)));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Failure())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
+
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -306,16 +302,15 @@ public async Task SettlementDomainService_ProcessSettlement_AddSettledFeeThrownE
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_GetTransactionThrownException_SettlementProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                          .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -327,13 +322,12 @@ public async Task SettlementDomainService_ProcessSettlement_GetTransactionThrown
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_GetMerchantThrownException_SettlementProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -344,11 +338,10 @@ public async Task SettlementDomainService_ProcessSettlement_GetMerchantThrownExc
 
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_FeeAdded() {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
 
@@ -359,11 +352,10 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_FeeAdd
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_AggregateNotCreated_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptySettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
 
@@ -374,12 +366,11 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_Aggreg
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -391,12 +382,11 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_FeeAdded()
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_ImmediateSettlement_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -408,12 +398,11 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_ImmediateSet
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_FailedGettingMerchant_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.NotFound());
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -425,12 +414,11 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_FailedGettin
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_SaveFailed_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Failure);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -442,12 +430,11 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_SaveFailed_F
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_ExceptionThrown_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService
-                .Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -459,7 +446,7 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_ExceptionThr
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_GetSettlementAggregateFailed_SettlementNotProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Error retrieving settlement aggregate"));
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -472,9 +459,9 @@ public async Task SettlementDomainService_ProcessSettlement_GetSettlementAggrega
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_GetMerchantFailed_SettlementNotProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Error retrieving merchant aggregate"));
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -487,13 +474,13 @@ public async Task SettlementDomainService_ProcessSettlement_GetMerchantFailed_Se
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_GetTransactionFailed_SettlementNotProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Error retrieving transaction aggregate"));
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -506,11 +493,11 @@ public async Task SettlementDomainService_ProcessSettlement_GetTransactionFailed
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_SaveSettlementAggregateFailed_SettlementNotProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithNoContracts(SettlementSchedule.Weekly));
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Save failed"));
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -523,33 +510,33 @@ public async Task SettlementDomainService_ProcessSettlement_SaveSettlementAggreg
         [Fact]
         public async Task SettlementDomainService_ProcessSettlement_WithScheduledSettlement_SettlementIsProcessed()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetSettlementAggregateWithPendingMerchantFees(10)));
-            this.AggregateService.SetupSequence(s => s.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(0))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
-                .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.SetupSequence(s => s.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
-                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(1))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(2))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(3))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(4))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(5))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(6))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(7))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(8))))
+                .Then().ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.FeeIds.GetValueOrDefault(9))));
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success())
+                .Then().ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithNoContracts(SettlementSchedule.Weekly));
 
             SettlementCommands.ProcessSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId);
@@ -563,7 +550,7 @@ public async Task SettlementDomainService_ProcessSettlement_WithScheduledSettlem
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_GetSettlementFailed_FeeNotAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Error retrieving settlement aggregate"));
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
@@ -576,9 +563,9 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_GetSet
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_StateChangeFailed_FeeNotAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Save failed"));
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(Guid.Empty, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
@@ -591,9 +578,9 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_StateC
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_SaveFailed_FeeNotAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Save failed"));
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
@@ -606,7 +593,7 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_SaveFa
         [Fact]
         public async Task SettlementDomainService_AddMerchantFeePendingSettlement_ExceptionThrown_FeeNotAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ThrowsAsync(new Exception("Unexpected error"));
 
             SettlementCommands.AddMerchantFeePendingSettlementCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeSettlementDueDate, TestData.MerchantId, TestData.EstateId);
@@ -619,7 +606,7 @@ public async Task SettlementDomainService_AddMerchantFeePendingSettlement_Except
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_GetSettlementFailed_FeeNotAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("Error retrieving settlement aggregate"));
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
@@ -632,11 +619,11 @@ public async Task SettlementDomainService_AddSettledFeeToSettlement_GetSettlemen
         [Fact]
         public async Task SettlementDomainService_AddSettledFeeToSettlement_WithScheduledSettlement_FeeAdded()
         {
-            this.AggregateService.Setup(s => s.GetLatest<SettlementAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<SettlementAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCreatedSettlementAggregate()));
-            this.AggregateService.Setup(s => s.Save(It.IsAny<SettlementAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<SettlementAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithNoContracts(SettlementSchedule.Weekly));
 
             SettlementCommands.AddSettledFeeToSettlementCommand command = new(TestData.SettlementDate, TestData.MerchantId, TestData.EstateId, TestData.TransactionFeeId, TestData.TransactionId);
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/StatementBuilderTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/StatementBuilderTests.cs
index c8ef1400..202a8d12 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/StatementBuilderTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/StatementBuilderTests.cs
@@ -1,11 +1,10 @@
-using Moq;
 using Shared.Serialisation;
 using Shouldly;
 using SimpleResults;
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.IO.Abstractions;
+using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
 using System.Reflection;
 using System.Text.Json;
@@ -19,7 +18,7 @@
 
 namespace TransactionProcessor.BusinessLogic.Tests.Services {
     public class StatementBuilderTests {
-        private readonly Mock<IFileSystem> _fileSystemMock;
+        private readonly MockFileSystem _fileSystem;
         private readonly StatementBuilder _builder;
         private readonly MerchantStatementAggregate merchantStatementAggregate;
         private readonly Merchant _merchant;
@@ -27,8 +26,8 @@ public class StatementBuilderTests {
 
         public StatementBuilderTests() {
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
-            _fileSystemMock = new Mock<IFileSystem>();
-            _builder = new StatementBuilder(_fileSystemMock.Object);
+            _fileSystem = new MockFileSystem();
+            _builder = new StatementBuilder(_fileSystem);
 
             // Setup minimal merchant and statement aggregate
             _merchant = TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts(SettlementSchedule.Immediate);
@@ -40,10 +39,16 @@ public StatementBuilderTests() {
             merchantStatementAggregate.AddDailySummaryRecord(new DateTime(2025, 5, 2), new MerchantStatementSummaryTotals(200, 2000.00m, 200, 20.00m, 2, 1000, 2, 200));
             merchantStatementAggregate.GenerateStatement(TestData.GeneratedDateTime);
 
-            // Setup file system mocks for templates and CSS
-            var dirMock = new Mock<IDirectoryInfo>();
-            _fileSystemMock.Setup(fs => fs.Directory.GetParent(It.IsAny<string>())).Returns(dirMock.Object);
-            _fileSystemMock.SetupSequence(f => f.File.ReadAllTextAsync(It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync("<style>{bootstrapcss}</style>\r\n<style>{fontawesomemincss}</style>\r\n<style>{fontawesomesolidcss}</style>\r\n<style>\r\n    {\r\n        bootstrap .css\r\n    }</style>\r\n    <style>\r\n        body {\r\n            color: #484b51;\r\n            margin-top: 20px;\r\n        }\r\n\r\n        .container {\r\n            max-width: 960px;\r\n        }\r\n\r\n        .text-secondary-d1 { color: #728299 !important; }\r\n\r\n        .page-header {\r\n            -ms-flex-align: center;\r\n            -ms-flex-pack: justify;\r\n            align-items: center;\r\n            border-bottom: 1px dotted #e2e2e2;\r\n            display: -ms-flexbox;\r\n            display: flex;\r\n            justify-content: space-between;\r\n            margin: 0 0 1rem;\r\n            padding-bottom: 1rem;\r\n            padding-top: .5rem;\r\n        }\r\n\r\n        .page-title {\r\n            font-size: 1.75rem;\r\n            font-weight: 300;\r\n            margin: 0;\r\n            padding: 0;\r\n        }\r\n\r\n        .brc-default-l1 { border-color: #dce9f0 !important; }\r\n\r\n        .ml-n1, .mx-n1 { margin-left: -.25rem !important; }\r\n\r\n        .mr-n1, .mx-n1 { margin-right: -.25rem !important; }\r\n\r\n        .mb-4, .my-4 { margin-bottom: 1.5rem !important; }\r\n\r\n        hr {\r\n            border: 0;\r\n            border-top: 1px solid rgba(0, 0, 0, .1);\r\n            margin-bottom: 1rem;\r\n            margin-top: 1rem;\r\n        }\r\n\r\n        .text-grey-m2 { color: #888a8d !important; }\r\n\r\n        .text-success-m2 { color: #86bd68 !important; }\r\n\r\n        .font-bolder, .text-600 { font-weight: 600 !important; }\r\n\r\n        .text-110 { font-size: 110% !important; }\r\n\r\n        .text-blue { color: #478fcc !important; }\r\n\r\n        .pb-25, .py-25 { padding-bottom: .75rem !important; }\r\n\r\n        .pt-25, .py-25 { padding-top: .75rem !important; }\r\n\r\n        .bgc-default-tp1 { background-color: rgba(121, 169, 197, .92) !important; }\r\n\r\n        .bgc-default-l4, .bgc-h-default-l4:hover { background-color: #f3f8fa !important; }\r\n\r\n        .page-header .page-tools {\r\n            -ms-flex-item-align: end;\r\n            align-self: flex-end;\r\n        }\r\n\r\n        .btn-light {\r\n            background-color: #f5f6f9;\r\n            border-color: #dddfe4;\r\n            color: #757984;\r\n        }\r\n\r\n        .w-2 { width: 1rem; }\r\n\r\n        .text-120 { font-size: 120% !important; }\r\n\r\n        .text-primary-m1 { color: #4087d4 !important; }\r\n\r\n        .text-danger-m1 { color: #dd4949 !important; }\r\n\r\n        .text-blue-m2 { color: #68a3d5 !important; }\r\n\r\n        .text-150 { font-size: 150% !important; }\r\n\r\n        .text-60 { font-size: 60% !important; }\r\n\r\n        .text-grey-m1 { color: #7b7d81 !important; }\r\n\r\n        .align-bottom { vertical-align: bottom !important; }\r\n    </style>\r\n    <body style=\"width: 100%; border: 0px solid green\">\r\n        <div class=\"container\" style=\"border: 0px solid red\">\r\n            <div class=\"page-header text-blue-d2\">\r\n                <h1 class=\"page-title text-secondary-d1\">\r\n                    Statement\r\n                    <small class=\"page-info\">\r\n                        <i class=\"fa fa-angle-double-right text-80\"></i>\r\n                        ID: [StatementId]\r\n                    </small>\r\n                </h1>\r\n            </div>\r\n\r\n            <div class=\"container px-0\">\r\n                <div class=\"row mt-4\">\r\n                    <div class=\"col-12 col-lg-10 offset-lg-1\">\r\n                        <div class=\"row\">\r\n                            <div class=\"col-12\">\r\n                                <div class=\"text-center text-150\">\r\n                                    <i class=\"fas fa-book fa-2x text-success-m2 mr-1\"></i>\r\n                                    <span class=\"text-default-d3\">[EstateName]</span>\r\n                                </div>\r\n                            </div>\r\n                        </div>\r\n                        <!-- .row -->\r\n\r\n                        <hr class=\"row brc-default-l1 mx-n1 mb-4\" />\r\n\r\n                        <div class=\"row\">\r\n                            <div class=\"col-sm-6\">\r\n                                <div>\r\n                                    <span class=\"text-sm text-grey-m2 align-middle\">To:</span>\r\n                                    <span class=\"text-600 text-110 text-blue align-middle\">[MerchantName]</span>\r\n                                </div>\r\n                                <div class=\"text-grey-m2\">\r\n                                    <div class=\"my-1\">\r\n                                        [MerchantAddressLine1]\r\n                                    </div>\r\n                                    <div class=\"my-1\">\r\n                                        [MerchantTown], [MerchantRegion]\r\n                                    </div>\r\n                                    <div class=\"my-1\">\r\n                                        [MerchantCountry], [MerchantPostcode]\r\n                                    </div>\r\n                                    <div class=\"my-1\"><i class=\"fa fa-phone fa-flip-horizontal text-secondary\"></i> <b class=\"text-600\">[MerchantContactNumber]</b></div>\r\n                                </div>\r\n                            </div>\r\n                            <!-- /.col -->\r\n\r\n                            <div class=\"text-95 col-sm-6 align-self-start d-sm-flex justify-content-end\">\r\n                                <hr class=\"d-sm-none\" />\r\n                                <div class=\"text-grey-m2\">\r\n                                    <div class=\"mt-1 mb-2 text-secondary-m1 text-600 text-125\">\r\n                                        Statement\r\n                                    </div>\r\n\r\n                                    <div class=\"my-2\"><i class=\"fa fa-circle text-blue-m2 text-xs mr-1\"></i> <span class=\"text-600 text-90\">ID:</span> #[StatementId]</div>\r\n\r\n                                    <div class=\"my-2\"><i class=\"fa fa-circle text-blue-m2 text-xs mr-1\"></i> <span class=\"text-600 text-90\">Date:</span> [StatementDate]</div>\r\n\r\n                                </div>\r\n                            </div>\r\n                            <!-- /.col -->\r\n                        </div>\r\n\r\n                        <div class=\"mt-4\">\r\n                            <div class=\"row text-600 text-white bgc-default-tp1 py-25\">\r\n                                <div class=\"d-none d-sm-block col-1\">#</div>\r\n                                <div class=\"d-none d-sm-block col-4\">Date</div>\r\n                                <div class=\"col-9 col-sm-5\">Description</div>\r\n                                <div class=\"d-none d-sm-block col-4 col-sm-2\">Amount</div>\r\n                            </div>\r\n\r\n                            <div class=\"text-95 text-secondary-d3\">\r\n                                [StatementLinesData]\r\n                            </div>\r\n\r\n                            <hr>\r\n\r\n                            <div class=\"row border-b-2 brc-default-l2\"></div>\r\n\r\n                            <div class=\"row mt-3\">\r\n                                <div class=\"col-12 col-sm-7 text-grey-d2 text-95 mt-2 mt-lg-0\">\r\n\r\n                                </div>\r\n\r\n                                <div class=\"col-12 col-sm-5 text-grey text-90 order-first order-sm-last\">\r\n                                    <div class=\"row my-2\">\r\n                                        <div class=\"col-12 text-center\">\r\n                                            <b>Statement Summary</b>\r\n                                        </div>\r\n                                    </div>\r\n                                    <div class=\"row my-2\">\r\n                                        <div class=\"col-5 text-right\">\r\n                                            Total:\r\n                                        </div>\r\n                                        <div class=\"col-7\">\r\n                                            <span class=\"text-120 text-secondary-d1\">[StatementTotal]</span>\r\n                                        </div>\r\n                                    </div>\r\n\r\n                                    <div class=\"row my-2\">\r\n                                        <div class=\"col-5 text-right\">\r\n                                            Transactions:\r\n                                        </div>\r\n                                        <div class=\"col-7\">\r\n                                            <span class=\"text-120 text-secondary-d1\">[TransactionsValue]</span>\r\n                                        </div>\r\n                                    </div>\r\n\r\n                                    <div class=\"row my-2\">\r\n                                        <div class=\"col-5 text-right\">\r\n                                            Fees:\r\n                                        </div>\r\n                                        <div class=\"col-7\">\r\n                                            <span class=\"text-120 text-secondary-d1\">[TransactionFeesValue]</span>\r\n                                        </div>\r\n                                    </div>\r\n                                </div>\r\n                            </div>\r\n\r\n                            <hr />\r\n\r\n                            <div>\r\n                                <span class=\"text-secondary-d1 text-105\">Thank you for your business</span>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </body>").ReturnsAsync("<tr>[StatementLineNumber][StatementLineDate][StatementLineDescription][StatementLineAmount]</tr>").ReturnsAsync("body{color:red;}").ReturnsAsync(".fa{display:inline;}").ReturnsAsync(".fa-solid{font-weight:bold;}");
+            // Seed the templates and CSS consumed by StatementBuilder.
+            String templateDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Templates", "Email");
+            _fileSystem.AddFile(Path.Combine(templateDirectory, "statement.html"), new MockFileData(
+                "Transactions Fees [MerchantName] [MerchantAddressLine1] [StatementLinesData] {bootstrapcss} {fontawesomemincss} {fontawesomesolidcss}"));
+            _fileSystem.AddFile(Path.Combine(templateDirectory, "statementline.html"), new MockFileData(
+                "[StatementLineDate] [StatementLineAmount]"));
+            String cssDirectory = Path.Combine(AppContext.BaseDirectory, "Templates", "Email");
+            _fileSystem.AddFile(Path.Combine(cssDirectory, "bootstrap", "css", "bootstrap.min.css"), new MockFileData("body{color:red;}"));
+            _fileSystem.AddFile(Path.Combine(cssDirectory, "fontawesome", "css", "fontawesome.min.css"), new MockFileData(".fa{display:inline;}"));
+            _fileSystem.AddFile(Path.Combine(cssDirectory, "fontawesome", "css", "solid.css"), new MockFileData(".fa-solid{font-weight:bold;}"));
         }
 
         [Fact]
@@ -106,7 +111,8 @@ public async Task GetStatementHtml_StatementAleadyBuilt_ErrorResult()
         [Fact]
         public async Task GetStatementHtml_ThrowsIfTemplateMissing() {
             // Arrange
-            _fileSystemMock.Setup(fs => fs.File.ReadAllTextAsync(It.Is<string>(s => s.Contains("statement.html")), It.IsAny<CancellationToken>())).ThrowsAsync(new FileNotFoundException());
+            String templatePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Templates", "Email", "statement.html");
+            _fileSystem.File.Delete(templatePath);
 
             // Act & Assert
             await Should.ThrowAsync<FileNotFoundException>(async () => { await _builder.GetStatementHtml(merchantStatementAggregate, _merchant, _cancellationToken); });
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs
index 0bad56ac..d8fbbdc2 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/TransactionDomainServiceTests.cs
@@ -13,7 +13,8 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services{
     using MessagingService.Client;
     using Microsoft.Extensions.Configuration;
     using Models;
-    using Moq;
+    using Imposter;
+    using Imposter.Abstractions;
     using SecurityService.Client;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EventStore.Aggregate;
@@ -32,15 +33,15 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services{
     public class TransactionDomainServiceTests{
         #region Fields
 
-        private readonly Mock<IAggregateService> AggregateService;
-        private readonly Mock<IOperatorProxy> OperatorProxy;
-        private readonly Mock<ISecurityServiceClient> SecurityServiceClient;
+        private readonly IAggregateServiceImposter AggregateService;
+        private readonly IOperatorProxyImposter OperatorProxy;
+        private readonly ISecurityServiceClientImposter SecurityServiceClient;
         private readonly TransactionDomainService TransactionDomainService;
-        private readonly Mock<ITransactionValidationService> TransactionValidationService;
-        private readonly Mock<IMemoryCacheWrapper> MemoryCacheWrapper;
-        private readonly Mock<IFeeCalculationManager> FeeCalculationManager;
-        private readonly Mock<ITransactionReceiptBuilder> TransactionReceiptBuilder;
-        private readonly Mock<IMessagingServiceClient> MessagingServiceClient;
+        private readonly ITransactionValidationServiceImposter TransactionValidationService;
+        private readonly IMemoryCacheWrapperImposter MemoryCacheWrapper;
+        private readonly IFeeCalculationManagerImposter FeeCalculationManager;
+        private readonly ITransactionReceiptBuilderImposter TransactionReceiptBuilder;
+        private readonly IMessagingServiceClientImposter MessagingServiceClient;
         #endregion
 
         #region Constructors
@@ -52,24 +53,24 @@ public TransactionDomainServiceTests(){
 
             Logger.Initialise(NullLogger.Instance);
 
-            this.AggregateService= new Mock<IAggregateService>();
-            this.SecurityServiceClient = new Mock<ISecurityServiceClient>();
-            this.OperatorProxy = new Mock<IOperatorProxy>();
-            Func<String, IOperatorProxy> operatorProxyResolver = operatorName => { return this.OperatorProxy.Object; };
-            this.TransactionValidationService = new Mock<ITransactionValidationService>();
-            this.MemoryCacheWrapper = new Mock<IMemoryCacheWrapper>();
-            this.FeeCalculationManager = new Mock<IFeeCalculationManager>();
-            this.TransactionReceiptBuilder = new Mock<ITransactionReceiptBuilder>();
-            this.MessagingServiceClient = new Mock<IMessagingServiceClient>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
+            this.AggregateService= new();
+            this.SecurityServiceClient = new();
+            this.OperatorProxy = new();
+            Func<String, IOperatorProxy> operatorProxyResolver = operatorName => this.OperatorProxy.Instance();
+            this.TransactionValidationService = new();
+            this.MemoryCacheWrapper = new();
+            this.FeeCalculationManager = new();
+            this.TransactionReceiptBuilder = new();
+            this.MessagingServiceClient = new();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
             this.TransactionDomainService = new TransactionDomainService(AggregateServiceResolver,
                                                                          operatorProxyResolver,
-                                                                         this.TransactionValidationService.Object,
-                                                                         this.SecurityServiceClient.Object,
-                                                                         this.MemoryCacheWrapper.Object,
-                                                                         this.FeeCalculationManager.Object,
-                                                                         this.TransactionReceiptBuilder.Object,
-                                                                         this.MessagingServiceClient.Object);
+                                                                         this.TransactionValidationService.Instance(),
+                                                                         this.SecurityServiceClient.Instance(),
+                                                                         this.MemoryCacheWrapper.Instance(),
+                                                                         this.FeeCalculationManager.Instance(),
+                                                                         this.TransactionReceiptBuilder.Instance(),
+                                                                         this.MessagingServiceClient.Instance());
         }
 
         #endregion
@@ -78,17 +79,17 @@ public TransactionDomainServiceTests(){
 
         [Fact]
         public async Task TransactionDomainService_ProcessLogonTransaction_DeviceNeedsAdded_TransactionIsProcessed(){
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.GetLatest<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedMerchantAggregate()));
             
-            this.TransactionValidationService.Setup(t => t.ValidateLogonTransaction(It.IsAny<Guid>(),
-                                                                                    It.IsAny<Guid>(),
-                                                                                    It.IsAny<String>(),
-                                                                                    It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.SuccessNeedToAddDevice, "SUCCESS")));
+            this.TransactionValidationService.ValidateLogonTransaction(Arg<Guid>.Any(),
+                                                                                    Arg<Guid>.Any(),
+                                                                                    Arg<String>.Any(),
+                                                                                    Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.SuccessNeedToAddDevice, "SUCCESS")));
 
             TransactionCommands.ProcessLogonTransactionCommand command = new(TestData.TransactionId,
                 TestData.EstateId,
@@ -105,21 +106,21 @@ public async Task TransactionDomainService_ProcessLogonTransaction_DeviceNeedsAd
             result.Data.MerchantId.ShouldBe(TestData.MerchantId);
             result.Data.ResponseCode.ShouldBe("0001");
             result.Data.TransactionId.ShouldBe(TestData.TransactionId);
-            this.AggregateService.Verify(t => t.GetLatest<MerchantAggregate>(TestData.MerchantId, It.IsAny<CancellationToken>()), Times.Once);
-            this.AggregateService.Verify(t => t.Save(It.IsAny<MerchantAggregate>(), It.IsAny<CancellationToken>()), Times.Once);
+            this.AggregateService.GetLatest<MerchantAggregate>(TestData.MerchantId, Arg<CancellationToken>.Any()).Called(Count.Once());
+            this.AggregateService.Save(Arg<MerchantAggregate>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task TransactionDomainService_ProcessLogonTransaction_TransactionIsProcessed(){
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.TransactionValidationService.Setup(t => t.ValidateLogonTransaction(It.IsAny<Guid>(),
-                                                                                    It.IsAny<Guid>(),
-                                                                                    It.IsAny<String>(),
-                                                                                    It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.TransactionValidationService.ValidateLogonTransaction(Arg<Guid>.Any(),
+                                                                                    Arg<Guid>.Any(),
+                                                                                    Arg<String>.Any(),
+                                                                                    Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
 
             TransactionCommands.ProcessLogonTransactionCommand command = new(TestData.TransactionId,
                 TestData.EstateId,
@@ -143,14 +144,14 @@ public async Task TransactionDomainService_ProcessLogonTransaction_TransactionIs
         [InlineData(TransactionResponseCode.InvalidMerchantId)]
         [InlineData(TransactionResponseCode.InvalidDeviceIdentifier)]
         public async Task TransactionDomainService_ProcessLogonTransaction_ValidationFailed_TransactionIsProcessed(TransactionResponseCode responseCode){
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-            this.TransactionValidationService.Setup(t => t.ValidateLogonTransaction(It.IsAny<Guid>(),
-                                                                                    It.IsAny<Guid>(),
-                                                                                    It.IsAny<String>(),
-                                                                                    It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
+            this.TransactionValidationService.ValidateLogonTransaction(Arg<Guid>.Any(),
+                                                                                    Arg<Guid>.Any(),
+                                                                                    Arg<String>.Any(),
+                                                                                    Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
 
             TransactionCommands.ProcessLogonTransactionCommand command = new(TestData.TransactionId,
                 TestData.EstateId,
@@ -171,14 +172,14 @@ public async Task TransactionDomainService_ProcessLogonTransaction_ValidationFai
 
         [Fact]
         public async Task TransactionDomainService_ProcessReconciliationTransaction_ReconciliationIsProcessed(){
-            this.AggregateService.Setup(r => r.GetLatest<ReconciliationAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ReconciliationAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(new ReconciliationAggregate());
-            this.AggregateService.Setup(t => t.Save(It.IsAny<ReconciliationAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ReconciliationAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-            this.TransactionValidationService.Setup(t => t.ValidateReconciliationTransaction(It.IsAny<Guid>(),
-                                                                                             It.IsAny<Guid>(),
-                                                                                             It.IsAny<String>(),
-                                                                                             It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.TransactionValidationService.ValidateReconciliationTransaction(Arg<Guid>.Any(),
+                                                                                             Arg<Guid>.Any(),
+                                                                                             Arg<String>.Any(),
+                                                                                             Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
 
             TransactionCommands.ProcessReconciliationCommand command =
                 new(TestData.TransactionId, TestData.EstateId,
@@ -201,14 +202,14 @@ public async Task TransactionDomainService_ProcessReconciliationTransaction_Reco
         [InlineData(TransactionResponseCode.NoValidDevices)]
         [InlineData(TransactionResponseCode.InvalidDeviceIdentifier)]
         public async Task TransactionDomainService_ProcessReconciliationTransaction_ValidationFailed_ReconciliationIsProcessed(TransactionResponseCode responseCode){
-            this.AggregateService.Setup(r => r.GetLatest<ReconciliationAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ReconciliationAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(new ReconciliationAggregate());
-            this.AggregateService.Setup(t => t.Save(It.IsAny<ReconciliationAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ReconciliationAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
-            this.TransactionValidationService.Setup(t => t.ValidateReconciliationTransaction(It.IsAny<Guid>(),
-                                                                                             It.IsAny<Guid>(),
-                                                                                             It.IsAny<String>(),
-                                                                                             It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
+            this.TransactionValidationService.ValidateReconciliationTransaction(Arg<Guid>.Any(),
+                                                                                             Arg<Guid>.Any(),
+                                                                                             Arg<String>.Any(),
+                                                                                             Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
 
             TransactionCommands.ProcessReconciliationCommand command =
                 new(TestData.TransactionId, TestData.EstateId,
@@ -227,33 +228,33 @@ public async Task TransactionDomainService_ProcessReconciliationTransaction_Vali
 
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_DeclinedByOperator_TransactionIsProcessed(){
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(o => o.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
-
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
-
-            this.OperatorProxy.Setup(o => o.ProcessSaleMessage(It.IsAny<Guid>(),
-                                                               It.IsAny<Guid>(),
-                                                               It.IsAny<Models.Merchant.Merchant>(),
-                                                               It.IsAny<DateTime>(),
-                                                               It.IsAny<String>(),
-                                                               It.IsAny<Dictionary<String, String>>(),
-                                                               It.IsAny<CancellationToken>())).ReturnsAsync(new Result<OperatorResponse>{Data = new OperatorResponse{
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
+
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+
+            this.OperatorProxy.ProcessSaleMessage(Arg<Guid>.Any(),
+                                                               Arg<Guid>.Any(),
+                                                               Arg<Models.Merchant.Merchant>.Any(),
+                                                               Arg<DateTime>.Any(),
+                                                               Arg<String>.Any(),
+                                                               Arg<Dictionary<String, String>>.Any(),
+                                                               Arg<CancellationToken>.Any()).ReturnsAsync(new Result<OperatorResponse>{Data = new OperatorResponse{
                                                                                                                                     ResponseMessage = TestData.OperatorResponseMessage,
                                                                                                                                     IsSuccessful = false,
                                                                                                                                     AuthorisationCode =
@@ -282,29 +283,29 @@ public async Task TransactionDomainService_ProcessSaleTransaction_DeclinedByOper
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_OperatorProxyThrowsException_TransactionIsProcessed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(o => o.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
 
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
 
-            this.OperatorProxy.Setup(o => o.ProcessSaleMessage(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Models.Merchant.Merchant>(), It.IsAny<DateTime>(), It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), It.IsAny<CancellationToken>())).Throws(new Exception());
+            this.OperatorProxy.ProcessSaleMessage(Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<Models.Merchant.Merchant>.Any(), Arg<DateTime>.Any(), Arg<String>.Any(), Arg<Dictionary<String, String>>.Any(), Arg<CancellationToken>.Any()).Throws(new Exception());
             TransactionCommands.ProcessSaleTransactionCommand command =
                 new TransactionCommands.ProcessSaleTransactionCommand(TestData.TransactionId, TestData.EstateId,
                     TestData.MerchantId, TestData.DeviceIdentifier, TestData.TransactionTypeSale.ToString(),
@@ -324,39 +325,39 @@ public async Task TransactionDomainService_ProcessSaleTransaction_OperatorProxyT
 
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_TransactionIsProcessed(){
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(o => o.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
 
             TransactionAggregate transactionAggregate = TestData.GetEmptyTransactionAggregate();
             FloatAggregate floatAggregate = TestData.GetFloatAggregateWithCostValues();
 
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(transactionAggregate);
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(floatAggregate));
-
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
-
-            this.OperatorProxy.Setup(o => o.ProcessSaleMessage(It.IsAny<Guid>(),
-                                                               It.IsAny<Guid>(),
-                                                               It.IsAny<Models.Merchant.Merchant>(),
-                                                               It.IsAny<DateTime>(),
-                                                               It.IsAny<String>(),
-                                                               It.IsAny<Dictionary<String, String>>(),
-                                                               It.IsAny<CancellationToken>())).ReturnsAsync(new OperatorResponse{
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(floatAggregate));
+
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+
+            this.OperatorProxy.ProcessSaleMessage(Arg<Guid>.Any(),
+                                                               Arg<Guid>.Any(),
+                                                               Arg<Models.Merchant.Merchant>.Any(),
+                                                               Arg<DateTime>.Any(),
+                                                               Arg<String>.Any(),
+                                                               Arg<Dictionary<String, String>>.Any(),
+                                                               Arg<CancellationToken>.Any()).ReturnsAsync(new OperatorResponse{
                                                                                                                                     ResponseMessage = TestData.OperatorResponseMessage,
                                                                                                                                     IsSuccessful = true,
                                                                                                                                     AuthorisationCode =
@@ -389,37 +390,37 @@ public async Task TransactionDomainService_ProcessSaleTransaction_TransactionIsP
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_NoFloatFound_TransactionIsProcessed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(o => o.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
             TransactionAggregate transactionAggregate = TestData.GetEmptyTransactionAggregate();
 
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(transactionAggregate);
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.NotFound());
-
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
-
-            this.OperatorProxy.Setup(o => o.ProcessSaleMessage(It.IsAny<Guid>(),
-                                                               It.IsAny<Guid>(),
-                                                               It.IsAny<Models.Merchant.Merchant>(),
-                                                               It.IsAny<DateTime>(),
-                                                               It.IsAny<String>(),
-                                                               It.IsAny<Dictionary<String, String>>(),
-                                                               It.IsAny<CancellationToken>())).ReturnsAsync(new OperatorResponse
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.NotFound());
+
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+
+            this.OperatorProxy.ProcessSaleMessage(Arg<Guid>.Any(),
+                                                               Arg<Guid>.Any(),
+                                                               Arg<Models.Merchant.Merchant>.Any(),
+                                                               Arg<DateTime>.Any(),
+                                                               Arg<String>.Any(),
+                                                               Arg<Dictionary<String, String>>.Any(),
+                                                               Arg<CancellationToken>.Any()).ReturnsAsync(new OperatorResponse
                                                                {
                                                                    ResponseMessage = TestData.OperatorResponseMessage,
                                                                    IsSuccessful = true,
@@ -457,21 +458,21 @@ public async Task TransactionDomainService_ProcessSaleTransaction_NoFloatFound_T
         [InlineData(TransactionResponseCode.ContractNotValidForMerchant)]
         [InlineData(TransactionResponseCode.ProductNotValidForMerchant)]
         public async Task TransactionDomainService_ProcessSaleTransaction_ValidationFailed_TransactionIsProcessed(TransactionResponseCode responseCode){
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(responseCode, responseCode.ToString())));
 
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetEmptyFloatAggregate()));
 
             TransactionCommands.ProcessSaleTransactionCommand command =
                 new TransactionCommands.ProcessSaleTransactionCommand(TestData.TransactionId, TestData.EstateId,
@@ -492,9 +493,9 @@ public async Task TransactionDomainService_ProcessSaleTransaction_ValidationFail
 
         [Fact]
         public async Task TransactionDomainService_ResendTransactionReceipt_TransactionReceiptResendIsRequested(){
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionWithReceiptRequestedAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
             TransactionCommands.ResendTransactionReceiptCommand command = new(TestData.TransactionId, TestData.EstateId);
             var result = await this.TransactionDomainService.ResendTransactionReceipt(command, TestContext.Current.CancellationToken);
@@ -592,13 +593,13 @@ public async Task TransactionDomainService_CalculateSettlementDate_CorrectDateRe
 
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_FeesCalculated() {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedMerchantFees);
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedMerchantFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -609,12 +610,12 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_FeesCalcu
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_MerchantWithImmediateSettlement_FeesCalculated()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedMerchantFees);
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedMerchantFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -625,13 +626,13 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_MerchantW
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_NonMerchantFees_FeesCalculated()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.ServiceProvider));
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedServiceProviderFees);
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.ServiceProvider));
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedServiceProviderFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -642,12 +643,12 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_NonMercha
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_TransactionNotNeedingFeeCaclulation_FeesCalculated()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedLogonTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedLogonTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedServiceProviderFees);
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedServiceProviderFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -658,15 +659,15 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_Transacti
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_NoFeesReturned_FeesCalculated()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
-            //this.EstateClient.Setup(e => e.GetTransactionFeesForProduct(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            //this.EstateClient.GetTransactionFeesForProduct(Arg<String>.Any(), Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedServiceProviderFees);
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedServiceProviderFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -676,8 +677,8 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_NoFeesRet
 
         [Fact]
         public async Task TransactionDomainService_AddSettledMerchantFee_FeeAdded() {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.TransactionFeeId)));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregateWithPendingFee(TestData.TransactionFeeId)));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
 
             TransactionCommands.AddSettledMerchantFeeCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.CalculatedFeeValue, TestData.SettlementDate, TestData.SettlementAggregateId);
 
@@ -688,8 +689,8 @@ public async Task TransactionDomainService_AddSettledMerchantFee_FeeAdded() {
         [Fact]
         public async Task TransactionDomainService_AddSettledMerchantFee_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             TransactionCommands.AddSettledMerchantFeeCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.CalculatedFeeValue, TestData.SettlementDate, TestData.SettlementAggregateId);
 
@@ -699,13 +700,13 @@ public async Task TransactionDomainService_AddSettledMerchantFee_SaveFailed_Resu
 
         [Fact]
         public async Task TransactionDomainService_SendCustomerEmailReceipt_ReceiptSent() {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.TransactionReceiptBuilder.Setup(r => r.GetEmailReceiptMessage(It.IsAny<Models.Transaction>(), It.IsAny<Merchant>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync("EmailMessage");
-            this.MessagingServiceClient.Setup(m => m.SendEmail(It.IsAny<String>(), It.IsAny<SendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.TransactionReceiptBuilder.GetEmailReceiptMessage(Arg<Models.Transaction>.Any(), Arg<Merchant>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync("EmailMessage");
+            this.MessagingServiceClient.SendEmail(Arg<String>.Any(), Arg<SendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.SendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId, Guid.NewGuid(), TestData.CustomerEmailAddress);
             var result = await this.TransactionDomainService.SendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
@@ -714,8 +715,8 @@ public async Task TransactionDomainService_SendCustomerEmailReceipt_ReceiptSent(
         [Fact] 
         public async Task TransactionDomainService_SendCustomerEmailReceipt_GetTransactionFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
             
             TransactionCommands.SendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId, Guid.NewGuid(), TestData.CustomerEmailAddress);
             var result = await this.TransactionDomainService.SendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
@@ -725,10 +726,10 @@ public async Task TransactionDomainService_SendCustomerEmailReceipt_GetTransacti
         [Fact]
         public async Task TransactionDomainService_ResendCustomerEmailReceipt_ReceiptSent()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
             
-            this.MessagingServiceClient.Setup(m => m.ResendEmail(It.IsAny<String>(), It.IsAny<ResendEmailRequest>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+            this.MessagingServiceClient.ResendEmail(Arg<String>.Any(), Arg<ResendEmailRequest>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
             TransactionCommands.ResendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId);
             var result = await this.TransactionDomainService.ResendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
             result.IsSuccess.ShouldBeTrue();
@@ -737,8 +738,8 @@ public async Task TransactionDomainService_ResendCustomerEmailReceipt_ReceiptSen
         [Fact]
         public async Task TransactionDomainService_ResendCustomerEmailReceipt_GetTransactionFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             TransactionCommands.ResendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId);
             var result = await this.TransactionDomainService.ResendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
@@ -748,7 +749,7 @@ public async Task TransactionDomainService_ResendCustomerEmailReceipt_GetTransac
         [Fact]
         public async Task TransactionDomainService_ProcessLogonTransaction_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.ProcessLogonTransactionCommand command = new(TestData.TransactionId,
@@ -766,14 +767,14 @@ public async Task TransactionDomainService_ProcessLogonTransaction_GetAggregateF
         [Fact]
         public async Task TransactionDomainService_ProcessLogonTransaction_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
-            this.TransactionValidationService.Setup(t => t.ValidateLogonTransaction(It.IsAny<Guid>(),
-                                                                                    It.IsAny<Guid>(),
-                                                                                    It.IsAny<String>(),
-                                                                                    It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.TransactionValidationService.ValidateLogonTransaction(Arg<Guid>.Any(),
+                                                                                    Arg<Guid>.Any(),
+                                                                                    Arg<String>.Any(),
+                                                                                    Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
 
             TransactionCommands.ProcessLogonTransactionCommand command = new(TestData.TransactionId,
                 TestData.EstateId,
@@ -790,7 +791,7 @@ public async Task TransactionDomainService_ProcessLogonTransaction_SaveFailed_Re
         [Fact]
         public async Task TransactionDomainService_ProcessReconciliationTransaction_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(r => r.GetLatest<ReconciliationAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ReconciliationAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.ProcessReconciliationCommand command =
@@ -805,14 +806,14 @@ public async Task TransactionDomainService_ProcessReconciliationTransaction_GetA
         [Fact]
         public async Task TransactionDomainService_ProcessReconciliationTransaction_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(r => r.GetLatest<ReconciliationAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<ReconciliationAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(new ReconciliationAggregate());
-            this.AggregateService.Setup(t => t.Save(It.IsAny<ReconciliationAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<ReconciliationAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
-            this.TransactionValidationService.Setup(t => t.ValidateReconciliationTransaction(It.IsAny<Guid>(),
-                                                                                             It.IsAny<Guid>(),
-                                                                                             It.IsAny<String>(),
-                                                                                             It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.TransactionValidationService.ValidateReconciliationTransaction(Arg<Guid>.Any(),
+                                                                                             Arg<Guid>.Any(),
+                                                                                             Arg<String>.Any(),
+                                                                                             Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
 
             TransactionCommands.ProcessReconciliationCommand command =
                 new(TestData.TransactionId, TestData.EstateId,
@@ -826,7 +827,7 @@ public async Task TransactionDomainService_ProcessReconciliationTransaction_Save
         [Fact]
         public async Task TransactionDomainService_ResendTransactionReceipt_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.ResendTransactionReceiptCommand command = new(TestData.TransactionId, TestData.EstateId);
@@ -837,9 +838,9 @@ public async Task TransactionDomainService_ResendTransactionReceipt_GetAggregate
         [Fact]
         public async Task TransactionDomainService_ResendTransactionReceipt_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionWithReceiptRequestedAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.ResendTransactionReceiptCommand command = new(TestData.TransactionId, TestData.EstateId);
@@ -850,7 +851,7 @@ public async Task TransactionDomainService_ResendTransactionReceipt_SaveFailed_R
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.ProcessSaleTransactionCommand command =
@@ -867,29 +868,29 @@ public async Task TransactionDomainService_ProcessSaleTransaction_GetAggregateFa
         [Fact]
         public async Task TransactionDomainService_ProcessSaleTransaction_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(o => o.Get<OperatorAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Get<OperatorAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedOperatorAggregate()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(TestData.GetEmptyTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(f => f.GetLatest<FloatAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.NotFound());
-            this.TransactionValidationService.Setup(t => t.ValidateSaleTransaction(It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<String>(),
-                                                                                   It.IsAny<Guid>(),
-                                                                                   It.IsAny<Decimal>(),
-                                                                                   It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
-            this.OperatorProxy.Setup(o => o.ProcessSaleMessage(It.IsAny<Guid>(),
-                                                               It.IsAny<Guid>(),
-                                                               It.IsAny<Models.Merchant.Merchant>(),
-                                                               It.IsAny<DateTime>(),
-                                                               It.IsAny<String>(),
-                                                               It.IsAny<Dictionary<String, String>>(),
-                                                               It.IsAny<CancellationToken>())).ReturnsAsync(new OperatorResponse {
+            this.AggregateService.GetLatest<FloatAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.NotFound());
+            this.TransactionValidationService.ValidateSaleTransaction(Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<String>.Any(),
+                                                                                   Arg<Guid>.Any(),
+                                                                                   Arg<Decimal?>.Any(),
+                                                                                   Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new TransactionValidationResult(TransactionResponseCode.Success, "SUCCESS")));
+            this.OperatorProxy.ProcessSaleMessage(Arg<Guid>.Any(),
+                                                               Arg<Guid>.Any(),
+                                                               Arg<Models.Merchant.Merchant>.Any(),
+                                                               Arg<DateTime>.Any(),
+                                                               Arg<String>.Any(),
+                                                               Arg<Dictionary<String, String>>.Any(),
+                                                               Arg<CancellationToken>.Any()).ReturnsAsync(new OperatorResponse {
                                                                    ResponseMessage = TestData.OperatorResponseMessage,
                                                                    IsSuccessful = true,
                                                                    AuthorisationCode = TestData.OperatorAuthorisationCode,
@@ -911,7 +912,7 @@ public async Task TransactionDomainService_ProcessSaleTransaction_SaveFailed_Res
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
@@ -923,12 +924,12 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_GetAggreg
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_MerchantSettlementScheduleNotSet_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.EmptyMerchantAggregate());
-            this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedMerchantFees);
+            this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedMerchantFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -939,12 +940,12 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_MerchantS
         [Fact]
         public async Task TransactionDomainService_CalculateFeesForTransaction_SaveFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(t => t.Save(It.IsAny<TransactionAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Save(Arg<TransactionAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<ContractAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
-            this.FeeCalculationManager.Setup(f => f.CalculateFees(It.IsAny<List<TransactionFeeToCalculate>>(), It.IsAny<Decimal>(), It.IsAny<DateTime>())).Returns(TestData.CalculatedMerchantFees);
+            this.AggregateService.Get<ContractAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedContractAggregateWithAProductAndTransactionFee(CalculationType.Fixed, FeeType.Merchant));
+            this.FeeCalculationManager.CalculateFees(Arg<List<TransactionFeeToCalculate>>.Any(), Arg<Decimal>.Any(), Arg<DateTime>.Any()).Returns(TestData.CalculatedMerchantFees);
 
             TransactionCommands.CalculateFeesForTransactionCommand command = new(TestData.TransactionId, TestData.TransactionDateTime, TestData.EstateId, TestData.MerchantId);
 
@@ -955,7 +956,7 @@ public async Task TransactionDomainService_CalculateFeesForTransaction_SaveFaile
         [Fact]
         public async Task TransactionDomainService_AddSettledMerchantFee_GetAggregateFailed_ResultFailed()
         {
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.AddSettledMerchantFeeCommand command = new(TestData.TransactionId, TestData.CalculatedFeeValue, TestData.TransactionFeeCalculateDateTime, CalculationType.Fixed, TestData.TransactionFeeId, TestData.CalculatedFeeValue, TestData.SettlementDate, TestData.SettlementAggregateId);
@@ -967,7 +968,7 @@ public async Task TransactionDomainService_AddSettledMerchantFee_GetAggregateFai
         [Fact]
         public async Task TransactionDomainService_SendCustomerEmailReceipt_GetTokenFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             TransactionCommands.SendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId, Guid.NewGuid(), TestData.CustomerEmailAddress);
             var result = await this.TransactionDomainService.SendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
@@ -977,9 +978,9 @@ public async Task TransactionDomainService_SendCustomerEmailReceipt_GetTokenFail
         [Fact]
         public async Task TransactionDomainService_SendCustomerEmailReceipt_GetMerchantFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure());
 
             TransactionCommands.SendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId, Guid.NewGuid(), TestData.CustomerEmailAddress);
@@ -990,11 +991,11 @@ public async Task TransactionDomainService_SendCustomerEmailReceipt_GetMerchantF
         [Fact]
         public async Task TransactionDomainService_SendCustomerEmailReceipt_GetEstateFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
-            this.AggregateService.Setup(t => t.GetLatest<TransactionAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
-            this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+            this.AggregateService.GetLatest<TransactionAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetCompletedAuthorisedSaleTransactionAggregate()));
+            this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithOperator());
-            this.AggregateService.Setup(c => c.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             TransactionCommands.SendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId, Guid.NewGuid(), TestData.CustomerEmailAddress);
             var result = await this.TransactionDomainService.SendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
@@ -1004,7 +1005,7 @@ public async Task TransactionDomainService_SendCustomerEmailReceipt_GetEstateFai
         [Fact]
         public async Task TransactionDomainService_ResendCustomerEmailReceipt_GetTokenFailed_ResultFailed()
         {
-            this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+            this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
 
             TransactionCommands.ResendCustomerEmailReceiptCommand command = new(TestData.EstateId, TestData.TransactionId);
             var result = await this.TransactionDomainService.ResendCustomerEmailReceipt(command, TestContext.Current.CancellationToken);
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/TransactionValidationServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/TransactionValidationServiceTests.cs
index 156f2982..b4edad6a 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/TransactionValidationServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/TransactionValidationServiceTests.cs
@@ -7,7 +7,8 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services;
 
 using BusinessLogic.Services;
 using Microsoft.Extensions.Configuration;
-using Moq;
+using Imposter;
+using Imposter.Abstractions;
 using SecurityService.Client;
 using Shared.EventStore.EventStore;
 using Shared.General;
@@ -23,9 +24,9 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services;
 
 public class TransactionValidationServiceTests {
     private readonly TransactionValidationService TransactionValidationService;
-    private readonly Mock<ISecurityServiceClient> SecurityServiceClient;
-    private readonly Mock<IEventStoreContext> EventStoreContext;
-    private readonly Mock<IAggregateService> AggregateService;
+    private readonly ISecurityServiceClientImposter SecurityServiceClient;
+    private readonly IEventStoreContextImposter EventStoreContext;
+    private readonly IAggregateServiceImposter AggregateService;
     public TransactionValidationServiceTests() {
         StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
         IConfigurationRoot configurationRoot = new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
@@ -33,20 +34,20 @@ public TransactionValidationServiceTests() {
 
         Logger.Initialise(NullLogger.Instance);
 
-        this.SecurityServiceClient = new Mock<ISecurityServiceClient>();
-        this.EventStoreContext = new Mock<IEventStoreContext>();
-        this.AggregateService = new Mock<IAggregateService>();
-        IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient = new ISecurityServiceClientImposter();
+        this.EventStoreContext = new IEventStoreContextImposter();
+        this.AggregateService = new IAggregateServiceImposter();
+        IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.TransactionValidationService = new TransactionValidationService(this.EventStoreContext.Object, AggregateServiceResolver);
+        this.TransactionValidationService = new TransactionValidationService(this.EventStoreContext.Instance(), AggregateServiceResolver);
     }
 
     [Fact]
     public async Task ValidateLogonTransactionX_ValidationSuccessful_CorrectResponseReturned() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -58,7 +59,7 @@ public async Task ValidateLogonTransactionX_ValidationSuccessful_CorrectResponse
 
     [Fact]
     public async Task ValidateLogonTransactionX_InvalidEstate_CorrectResponseReturned() {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Estate not found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -71,7 +72,7 @@ public async Task ValidateLogonTransactionX_InvalidEstate_CorrectResponseReturne
     [Fact]
     public async Task ValidateLogonTransactionX_FailureWhileGettingEstate_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Failed"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -84,9 +85,9 @@ public async Task ValidateLogonTransactionX_FailureWhileGettingEstate_CorrectRes
     [Fact]
     public async Task ValidateLogonTransactionX_InvalidMerchant_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Merchant Not Found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -99,9 +100,9 @@ public async Task ValidateLogonTransactionX_InvalidMerchant_CorrectResponseRetur
     [Fact]
     public async Task ValidateLogonTransactionX_FailureWhileGettingMerchant_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Merchant Not Found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -114,9 +115,9 @@ public async Task ValidateLogonTransactionX_FailureWhileGettingMerchant_CorrectR
     [Fact]
     public async Task ValidateLogonTransactionX_InvalidDeviceId_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateLogonTransaction(TestData.EstateId, TestData.MerchantId,
@@ -129,9 +130,9 @@ public async Task ValidateLogonTransactionX_InvalidDeviceId_CorrectResponseRetur
     [Fact]
     public async Task ValidateLogonTransactionX_MerchantHasNoDevices_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
 
@@ -145,9 +146,9 @@ public async Task ValidateLogonTransactionX_MerchantHasNoDevices_CorrectResponse
     [Fact]
     public async Task ValidateReconciliationTransactionX_ValidationSuccessful_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -160,7 +161,7 @@ public async Task ValidateReconciliationTransactionX_ValidationSuccessful_Correc
     [Fact]
     public async Task ValidateReconciliationTransactionX_InvalidEstate_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Estate Not Found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -173,7 +174,7 @@ public async Task ValidateReconciliationTransactionX_InvalidEstate_CorrectRespon
     [Fact]
     public async Task ValidateReconciliationTransactionX_FailureWhileGettingEstate_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Failed"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -186,9 +187,9 @@ public async Task ValidateReconciliationTransactionX_FailureWhileGettingEstate_C
     [Fact]
     public async Task ValidateReconciliationTransactionX_InvalidMerchant_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Merchant Not Found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -201,9 +202,9 @@ public async Task ValidateReconciliationTransactionX_InvalidMerchant_CorrectResp
     [Fact]
     public async Task ValidateReconciliationTransactionX_FailureWhileGettingMerchant_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Merchant Not Found"));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -216,9 +217,9 @@ public async Task ValidateReconciliationTransactionX_FailureWhileGettingMerchant
     [Fact]
     public async Task ValidateReconciliationTransactionX_InvalidDeviceId_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -231,9 +232,9 @@ public async Task ValidateReconciliationTransactionX_InvalidDeviceId_CorrectResp
     [Fact]
     public async Task ValidateReconciliationTransactionX_MerchantHasNoDevices_CorrectResponseReturned()
     {
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
         Result<TransactionValidationResult> result = await this.TransactionValidationService.ValidateReconciliationTransaction(TestData.EstateId, TestData.MerchantId,
@@ -246,11 +247,11 @@ public async Task ValidateReconciliationTransactionX_MerchantHasNoDevices_Correc
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_DeviceNotRegisteredToMerchant_ResponseIsInvalidDeviceIdentifier()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -269,9 +270,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_DeviceNot
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_EstateFoundButHasNoOperators_ResponseIsInvalidEstateId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
         
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -290,9 +291,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_EstateFou
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_EstateFoundButOperatorIsDeleted_ResponseIsOperatorNotEnabledForEstate()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperatorDeleted()));
         
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -311,9 +312,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_EstateFou
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_EstateFoundButHasNullOperators_ResponseIsInvalidEstateId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
         
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -332,9 +333,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_EstateFou
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_EstateFoundOperatorsNotConfiguredForEstate_ResponseIsOperatorNotValidForEstate()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
         
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -353,9 +354,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_EstateFou
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_EstateNotFound_ResponseIsInvalidEstateId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Estate Not Found"));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -374,9 +375,9 @@ public async Task TransactionValidationService_ValidateSaleTransaction_EstateNot
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_GetEstateFailed_ResponseIsInvalidEstateId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Failed"));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -395,14 +396,14 @@ public async Task TransactionValidationService_ValidateSaleTransaction_GetEstate
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_InvalidContractId_ResponseIsInvalidContractIdValue()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -421,13 +422,13 @@ public async Task TransactionValidationService_ValidateSaleTransaction_InvalidCo
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_InvalidProductId_ResponseIsInvalidProductIdValue()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -448,11 +449,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_InvalidPr
     [InlineData(-1)]
     public async Task TransactionValidationService_ValidateSaleTransaction_InvalidTransactionAmount_ResponseIsInvalidSaleTransactionAmount(Decimal transactionAmount)
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
                                                                                                                                                   TestData.MerchantId,
@@ -470,11 +471,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_InvalidTr
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantDeviceListEmpty_ResponseIsNoValidDevices()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.CreatedMerchantAggregate());
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -493,13 +494,13 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantD
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantDoesNotHaveSuppliedContract_ResponseIsContractNotValidForMerchant()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -518,15 +519,15 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantD
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantHasNoContracts_ResponseIsMerchantDoesNotHaveEnoughCredit()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithNoContracts(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithNoContracts(SettlementSchedule.Immediate));
 
 
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -545,12 +546,12 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantH
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantNotEnoughCredit_ResponseIsMerchantDoesNotHaveEnoughCredit()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionStateNoCredit));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -569,11 +570,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantN
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantNotFound_ResponseIsInvalidMerchantId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.NotFound("Merchant not found"));
 
 
@@ -593,11 +594,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantN
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_FailedGettingMerchant_ResponseIsInvalidMerchantId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Failure("Merchant not found"));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -616,16 +617,16 @@ public async Task TransactionValidationService_ValidateSaleTransaction_FailedGet
     [Fact(Skip = "Need to review if test is needed now")]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantNotFoundOnGetContract_ResponseIsInvalidMerchantId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
-        this.AggregateService.SetupSequence(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)))
-            .ReturnsAsync(Result.NotFound());
+            .Then().ReturnsAsync(Result.NotFound());
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -644,15 +645,15 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantN
     [Fact(Skip = "not sure if this needed now")]
     public async Task TransactionValidationService_ValidateSaleTransaction_FailedGettingMerchantOnGetContract_ResponseIsInvalidMerchantId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.SetupSequence(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate)))
-            .ReturnsAsync(Result.NotFound());
+            .Then().ReturnsAsync(Result.NotFound());
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -671,12 +672,12 @@ public async Task TransactionValidationService_ValidateSaleTransaction_FailedGet
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantOperatorListEmpty_ResponseIsNoMerchantOperators()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
-        this.AggregateService.SetupSequence(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithDevice());
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -695,11 +696,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantO
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_MerchantOperatorIsDeleted_ResponseIsOperatorNotEnabledForMerchant()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithDeletedOperator(SettlementSchedule.Immediate));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -718,11 +719,11 @@ public async Task TransactionValidationService_ValidateSaleTransaction_MerchantO
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_OperatorNotConfiguredFroMerchant_ResponseIsOperatorNotValidForMerchant()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator2()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -741,13 +742,13 @@ public async Task TransactionValidationService_ValidateSaleTransaction_OperatorN
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_ProductIdNotConfigured_ResponseIsProductNotValidForMerchant()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -766,13 +767,13 @@ public async Task TransactionValidationService_ValidateSaleTransaction_ProductId
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_SuccessfulSale()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.SetupSequence(m => m.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(StringSerialiser.Serialise(TestData.MerchantBalanceProjectionState));
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
@@ -790,14 +791,14 @@ public async Task TransactionValidationService_ValidateSaleTransaction_Successfu
     [Fact]
     public async Task TransactionValidationService_ValidateSaleTransaction_FailedGettingMerchantBalance_ResponseIsInvalidMerchantId()
     {
-        this.SecurityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
+        this.SecurityServiceClient.GetToken(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.GetTokenResponse()));
 
-        this.AggregateService.Setup(e => e.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
-        this.AggregateService.Setup(e => e.Get<MerchantAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+        this.AggregateService.Get<MerchantAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
             .ReturnsAsync(TestData.Aggregates.MerchantAggregateWithEverything(SettlementSchedule.Immediate));
 
-        this.EventStoreContext.Setup(e => e.GetPartitionStateFromProjection(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        this.EventStoreContext.GetPartitionStateFromProjection(Arg<String>.Any(), Arg<String>.Any(), Arg<CancellationToken>.Any())
        .ReturnsAsync(Result.Failure());
 
         var result = await this.TransactionValidationService.ValidateSaleTransaction(TestData.EstateId,
diff --git a/TransactionProcessor.BusinessLogic.Tests/Services/VoucherDomainServiceTests.cs b/TransactionProcessor.BusinessLogic.Tests/Services/VoucherDomainServiceTests.cs
index 6145f5c4..e7e5c66e 100644
--- a/TransactionProcessor.BusinessLogic.Tests/Services/VoucherDomainServiceTests.cs
+++ b/TransactionProcessor.BusinessLogic.Tests/Services/VoucherDomainServiceTests.cs
@@ -1,4 +1,6 @@
 using SimpleResults;
+using Imposter;
+using Imposter.Abstractions;
 using TransactionProcessor.Aggregates;
 using TransactionProcessor.Database.Contexts;
 using TransactionProcessor.Models;
@@ -11,7 +13,6 @@ namespace TransactionProcessor.BusinessLogic.Tests.Services
     using Microsoft.EntityFrameworkCore.Diagnostics;
     using Microsoft.Extensions.Configuration;
     using Microsoft.Extensions.DependencyInjection;
-    using Moq;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EntityFramework;
     using Shared.EventStore.Aggregate;
@@ -30,10 +31,10 @@ public class VoucherDomainServiceTests
     {
         #region Methods
 
-        private Mock<IAggregateService> AggregateService;
+        private IAggregateServiceImposter AggregateService;
         private VoucherDomainService VoucherDomainService;
         private readonly EstateManagementContext Context;
-        private readonly Mock<IDbContextResolver<EstateManagementContext>> DbContextFactory;
+        private readonly IDbContextResolverImposter<EstateManagementContext> DbContextFactory;
 
         public VoucherDomainServiceTests() {
             StringSerialiser.Initialise(new SystemTextJsonSerializer(new JsonSerializerOptions()));
@@ -42,70 +43,32 @@ public VoucherDomainServiceTests() {
 
             Logger.Initialise(NullLogger.Instance);
 
-            this.AggregateService  = new Mock<IAggregateService>();
-            IAggregateService AggregateServiceResolver() => this.AggregateService.Object;
-            this.DbContextFactory = new Mock<IDbContextResolver<EstateManagementContext>>();
+            this.AggregateService  = new IAggregateServiceImposter();
+            IAggregateService AggregateServiceResolver() => this.AggregateService.Instance();
+            this.DbContextFactory = new IDbContextResolverImposter<EstateManagementContext>();
             this.Context = this.GetContext(Guid.NewGuid().ToString("N"));
             var services = new ServiceCollection();
             services.AddTransient<EstateManagementContext>(_ => this.Context);
             var serviceProvider = services.BuildServiceProvider();
             var scope = serviceProvider.CreateScope();
-            this.DbContextFactory.Setup(d => d.Resolve(It.IsAny<String>(), It.IsAny<String>())).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
-            this.VoucherDomainService = new VoucherDomainService(AggregateServiceResolver, DbContextFactory.Object);
+            this.DbContextFactory.Resolve(Arg<String>.Any(), Arg<String>.Any()).Returns(new ResolvedDbContext<EstateManagementContext>(scope));
+            this.VoucherDomainService = new VoucherDomainService(AggregateServiceResolver, DbContextFactory.Instance());
         }
 
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_EstateWithNoOperators_ErrorThrown() {
             
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new VoucherAggregate()));
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new VoucherAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.CreatedEstateAggregate());
             var result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                  TestContext.Current.CancellationToken);
             result.IsFailed.ShouldBeTrue();
         }
 
-        //[Fact]
-        //public async Task VoucherDomainService_IssueVoucher_EstateWithNullOperators_ErrorThrown() {
-        //    IConfigurationRoot configurationRoot = new ConfigurationBuilder().AddInMemoryCollection(TestData.DefaultAppSettings).Build();
-        //    ConfigurationReader.Initialise(configurationRoot);
-
-        //    Logger.Initialise(NullLogger.Instance);
-
-        //    Mock<IIntermediateEstateClient> estateClient = new Mock<IIntermediateEstateClient>();
-        //    Mock<ISecurityServiceClient> securityServiceClient = new Mock<ISecurityServiceClient>();
-        //    Mock<IAggregateRepository<VoucherAggregate, DomainEvent>> voucherAggregateRepository = new Mock<IAggregateRepository<VoucherAggregate, DomainEvent>>();
-        //    voucherAggregateRepository.Setup(v => v.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(new VoucherAggregate());
-        //    securityServiceClient.Setup(s => s.GetToken(It.IsAny<String>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.TokenResponse()));
-        //    estateClient.Setup(e => e.GetEstate(It.IsAny<String>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
-        //                .ReturnsAsync(TestData.GetEstateResponseWithNullOperators);
-
-        //    EstateManagementGenericContext context = await this.GetContext(Guid.NewGuid().ToString("N"));
-
-        //    var dbContextFactory = this.GetMockDbContextFactory();
-        //    dbContextFactory.Setup(d => d.GetContext(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>())).ReturnsAsync(context);
-
-        //    VoucherDomainService domainService = new VoucherDomainService(voucherAggregateRepository.Object,
-        //                                                                  securityServiceClient.Object,
-        //                                                                  estateClient.Object,
-        //                                                                  dbContextFactory.Object);
-
-        //    var result = await domainService.IssueVoucher(TestData.VoucherId,
-        //                                                                         TestData.OperatorId,
-        //                                                                         TestData.EstateId,
-        //                                                                         TestData.TransactionId,
-        //                                                                         TestData.IssuedDateTime,
-        //                                                                         TestData.Value,
-        //                                                                         TestData.RecipientEmail,
-        //                                                                         TestData.RecipientMobile,
-        //                                                                         TestContext.Current.CancellationToken);
-        //    result.IsFailed.ShouldBeTrue();
-        //}
-
-        
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_InvalidEstate_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new VoucherAggregate()));
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new VoucherAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
             
             Result<IssueVoucherResponse> result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                  TestContext.Current.CancellationToken);
@@ -114,8 +77,8 @@ public async Task VoucherDomainService_IssueVoucher_InvalidEstate_ErrorThrown()
         
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_OperatorNotSupportedByEstate_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new VoucherAggregate()));
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new VoucherAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
             Result<IssueVoucherResponse> result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                  TestContext.Current.CancellationToken);
@@ -125,9 +88,9 @@ public async Task VoucherDomainService_IssueVoucher_OperatorNotSupportedByEstate
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_VoucherIssued() {
 
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new VoucherAggregate()));
-            this.AggregateService.Setup(v => v.Save(It.IsAny<VoucherAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new VoucherAggregate()));
+            this.AggregateService.Save(Arg<VoucherAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
             Result<IssueVoucherResponse> result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                          TestContext.Current.CancellationToken);
@@ -139,9 +102,9 @@ public async Task VoucherDomainService_IssueVoucher_VoucherIssued() {
         [Fact]
         public async Task VoucherDomainService_RedeemVoucher_InvalidEstate_ErrorThrown() {
 
-            AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                       .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.Aggregates.EmptyEstateAggregate);
 
             this.Context.VoucherProjectionStates.Add(new TransactionProcessor.Database.Entities.VoucherProjectionState() {
                                                  VoucherCode = TestData.VoucherCode,
@@ -161,11 +124,11 @@ public async Task VoucherDomainService_RedeemVoucher_InvalidEstate_ErrorThrown()
         [Fact]
         public async Task VoucherDomainService_RedeemVoucher_VoucherRedeemed() {
 
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                       .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
-            this.AggregateService.Setup(v => v.Save(It.IsAny<VoucherAggregate>(), It.IsAny<CancellationToken>()))
-                .ReturnsAsync(Result.Success);
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Save(Arg<VoucherAggregate>.Any(), Arg<CancellationToken>.Any())
+                .ReturnsAsync(Result.Success());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             this.Context.VoucherProjectionStates.Add(new TransactionProcessor.Database.Entities.VoucherProjectionState() {
                                                  VoucherCode = TestData.VoucherCode,
@@ -186,9 +149,9 @@ public async Task VoucherDomainService_RedeemVoucher_VoucherRedeemed() {
 
         [Fact]
         public async Task VoucherDomainService_RedeemVoucher_VoucherNotFound_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                       .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             Result<RedeemVoucherResponse> result = await this.VoucherDomainService.RedeemVoucher(TestData.EstateId,
                                                                                   TestData.VoucherCode,
@@ -199,8 +162,8 @@ public async Task VoucherDomainService_RedeemVoucher_VoucherNotFound_ErrorThrown
 
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_GetVoucherFailed_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
             Result<IssueVoucherResponse> result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                  TestContext.Current.CancellationToken);
@@ -209,9 +172,9 @@ public async Task VoucherDomainService_IssueVoucher_GetVoucherFailed_ErrorThrown
 
         [Fact]
         public async Task VoucherDomainService_IssueVoucher_SaveFailed_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(new VoucherAggregate()));
-            this.AggregateService.Setup(v => v.Save(It.IsAny<VoucherAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(new VoucherAggregate()));
+            this.AggregateService.Save(Arg<VoucherAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.EstateAggregateWithOperator()));
 
             Result<IssueVoucherResponse> result = await this.VoucherDomainService.IssueVoucher(TestData.IssueVoucherCommand,
                                                                                  TestContext.Current.CancellationToken);
@@ -220,8 +183,8 @@ public async Task VoucherDomainService_IssueVoucher_SaveFailed_ErrorThrown() {
 
         [Fact]
         public async Task VoucherDomainService_RedeemVoucher_GetVoucherAggregateFailed_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             this.Context.VoucherProjectionStates.Add(new TransactionProcessor.Database.Entities.VoucherProjectionState() {
                 VoucherCode = TestData.VoucherCode,
@@ -240,10 +203,10 @@ public async Task VoucherDomainService_RedeemVoucher_GetVoucherAggregateFailed_E
 
         [Fact]
         public async Task VoucherDomainService_RedeemVoucher_SaveFailed_ErrorThrown() {
-            this.AggregateService.Setup(v => v.GetLatest<VoucherAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+            this.AggregateService.GetLatest<VoucherAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any())
                                       .ReturnsAsync(Result.Success(TestData.GetVoucherAggregateWithRecipientMobile()));
-            this.AggregateService.Setup(v => v.Save(It.IsAny<VoucherAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
-            this.AggregateService.Setup(f => f.Get<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+            this.AggregateService.Save(Arg<VoucherAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            this.AggregateService.Get<EstateAggregate>(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
 
             this.Context.VoucherProjectionStates.Add(new TransactionProcessor.Database.Entities.VoucherProjectionState() {
                 VoucherCode = TestData.VoucherCode,
diff --git a/TransactionProcessor.BusinessLogic.Tests/TransactionProcessor.BusinessLogic.Tests.csproj b/TransactionProcessor.BusinessLogic.Tests/TransactionProcessor.BusinessLogic.Tests.csproj
index 3ca16d44..a8f0dca1 100644
--- a/TransactionProcessor.BusinessLogic.Tests/TransactionProcessor.BusinessLogic.Tests.csproj
+++ b/TransactionProcessor.BusinessLogic.Tests/TransactionProcessor.BusinessLogic.Tests.csproj
@@ -13,7 +13,7 @@
 	  <PackageReference Include="Lamar" />
 	  <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" />
 	  <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
-    <PackageReference Include="Moq" />
+    <PackageReference Include="Imposter" />
     <PackageReference Include="NuGet.Packaging" />
     <PackageReference Include="NuGet.Protocol" />
     <PackageReference Include="OpenTelemetry.Api" />
diff --git a/TransactionProcessor.DatabaseTests/BaseTest.cs b/TransactionProcessor.DatabaseTests/BaseTest.cs
index a34964f0..34f18953 100644
--- a/TransactionProcessor.DatabaseTests/BaseTest.cs
+++ b/TransactionProcessor.DatabaseTests/BaseTest.cs
@@ -1,5 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
-using Moq;
+using Imposter.Abstractions;
 using Shared.EntityFramework;
 using TransactionProcessor.Database.Contexts;
 using TransactionProcessor.Repository;
@@ -34,20 +34,18 @@ public async Task GetRepository()
         {
             string dbConnString = this.GetLocalConnectionString($"TransactionProcessorReadModel-{this.TestId}");
 
-            Mock<IDbContextResolver<EstateManagementContext>> resolver = new Mock<IDbContextResolver<EstateManagementContext>>();
-            resolver.Setup(r => r.Resolve(It.IsAny<string>(), It.IsAny<string>()))
-                .Returns(() =>
+            IDbContextResolverImposter<EstateManagementContext> resolver = new();
+            resolver.Resolve(Arg<string>.Any(), Arg<string>.Any())
+                .Returns((_, _) =>
                 {
-                    Mock<IServiceScope> innerScope = new Mock<IServiceScope>();
                     EstateManagementContext context = new EstateManagementContext(dbConnString);
-
-                    innerScope.Setup(s => s.ServiceProvider.GetService(typeof(EstateManagementContext)))
-                        .Returns(context);
-
-                    return new ResolvedDbContext<EstateManagementContext>(innerScope.Object);
+                    ServiceProvider serviceProvider = new ServiceCollection()
+                        .AddSingleton(context)
+                        .BuildServiceProvider();
+                    return new ResolvedDbContext<EstateManagementContext>(serviceProvider.CreateScope());
                 });
 
-            this.Repository = new TransactionProcessorReadModelRepository(resolver.Object);
+            this.Repository = new TransactionProcessorReadModelRepository(resolver.Instance());
         }
 
         public virtual ValueTask DisposeAsync()
diff --git a/TransactionProcessor.DatabaseTests/ContractEventTests.cs b/TransactionProcessor.DatabaseTests/ContractEventTests.cs
index 6f5b8133..acb5fe74 100644
--- a/TransactionProcessor.DatabaseTests/ContractEventTests.cs
+++ b/TransactionProcessor.DatabaseTests/ContractEventTests.cs
@@ -1,7 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Moq;
 using Shared.EntityFramework;
 using Shouldly;
 using SimpleResults;
diff --git a/TransactionProcessor.DatabaseTests/ImposterUsings.cs b/TransactionProcessor.DatabaseTests/ImposterUsings.cs
new file mode 100644
index 00000000..5b4cc29c
--- /dev/null
+++ b/TransactionProcessor.DatabaseTests/ImposterUsings.cs
@@ -0,0 +1,5 @@
+using Imposter.Abstractions;
+using Shared.EntityFramework;
+using TransactionProcessor.Database.Contexts;
+
+[assembly: GenerateImposter(typeof(IDbContextResolver<EstateManagementContext>))]
diff --git a/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj b/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
index d86f1a82..4988f623 100644
--- a/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
+++ b/TransactionProcessor.DatabaseTests/TransactionProcessor.DatabaseTests.csproj
@@ -12,13 +12,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Imposter" />
     <PackageReference Include="coverlet.collector">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
 	  <!--<PackageReference Include="Ductus.FluentDocker" Version="2.85.0" />-->
 	  <PackageReference Include="Ductus.FluentDocker" />
-    <PackageReference Include="Moq" />
     <PackageReference Include="NuGet.Packaging" />
     <PackageReference Include="NuGet.Protocol" />
     <PackageReference Include="OpenTelemetry.Api" />
diff --git a/TransactionProcessor.ProjectionEngine.Tests/ProjectionHandlerTests.cs b/TransactionProcessor.ProjectionEngine.Tests/ProjectionHandlerTests.cs
index 3971f62c..7b4162cb 100644
--- a/TransactionProcessor.ProjectionEngine.Tests/ProjectionHandlerTests.cs
+++ b/TransactionProcessor.ProjectionEngine.Tests/ProjectionHandlerTests.cs
@@ -1,4 +1,4 @@
-using Shared.Logger;
+using Shared.Logger;
 using SimpleResults;
 using TransactionProcessor.DomainEvents;
 using TransactionProcessor.ProjectionEngine.Models;
@@ -7,7 +7,6 @@ namespace TransactionProcessor.ProjectionEngine.Tests;
 
 using Dispatchers;
 using Microsoft.Extensions.Configuration;
-using Moq;
 using Projections;
 using Repository;
 using Shared.DomainDrivenDesign.EventSourcing;
@@ -25,11 +24,11 @@ public ProjectionHandlerTests(){
 
     [Fact]
     public async Task ProjectionHandler_Handle_NullEvent_EventHandled(){
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object,projection.Object,
-                                                                                                                                     stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo,projection,
+                                                                                                                                     stateDispatcher);
         var result = await ph.Handle(null, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -37,13 +36,13 @@ public async Task ProjectionHandler_Handle_NullEvent_EventHandled(){
     [Fact]
     public async Task ProjectionHandler_Handle_EventNotSupported_EventHandled()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-                                                                                                                                     stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+                                                                                                                                     stateDispatcher);
 
-        projection.Setup(p=> p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(false);
+        projection.ShouldHandle = false;
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -51,18 +50,16 @@ public async Task ProjectionHandler_Handle_EventNotSupported_EventHandled()
     [Fact]
     public async Task ProjectionHandler_Handle_StateNotFoundInRepository_EventHandled()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-                                                                                                                                     stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+                                                                                                                                     stateDispatcher);
 
         MerchantBalanceState state = new MerchantBalanceState();
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p =>
-                p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>()))
-            .ReturnsAsync(state);
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(state));
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => state;
+        repo.LoadResult = Result.Success(state);
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -70,18 +67,18 @@ public async Task ProjectionHandler_Handle_StateNotFoundInRepository_EventHandle
     [Fact]
     public async Task ProjectionHandler_Handle_StateFoundInRepository_NoChanges_EventHandled()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-                                                                                                                                     stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+                                                                                                                                     stateDispatcher);
 
         MerchantBalanceState state = new MerchantBalanceState();
 
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p => p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(state.InitialiseBalances);
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => state.InitialiseBalances();
             
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(state);
+        repo.LoadResult = state;
 
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
@@ -90,21 +87,21 @@ public async Task ProjectionHandler_Handle_StateFoundInRepository_NoChanges_Even
     [Fact]
     public async Task ProjectionHandler_Handle_StateFoundInRepository_ChangesMade_EventHandled()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-                                                                                                                                     stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+                                                                                                                                     stateDispatcher);
         MerchantBalanceState state = new MerchantBalanceState();
         MerchantBalanceState newState = new MerchantBalanceState();
         newState = newState.HandleMerchantCreated(TestData.MerchantCreatedEvent);
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p => p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(newState);
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => newState;
             
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(state);
-        repo.Setup(r => r.Save(It.IsAny<MerchantBalanceState>(),It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(state));
+        repo.LoadResult = state;
+        repo.SaveResult = Result.Success(state);
 
-        stateDispatcher.Setup(d => d.Dispatch(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        stateDispatcher.DispatchResult = Result.Success();
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
@@ -112,21 +109,21 @@ public async Task ProjectionHandler_Handle_StateFoundInRepository_ChangesMade_Ev
     [Fact]
     public async Task ProjectionHandler_Handle_LoadFails_FailedResult()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-            stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+            stateDispatcher);
         MerchantBalanceState state = new MerchantBalanceState();
         MerchantBalanceState newState = new MerchantBalanceState();
         newState = newState.HandleMerchantCreated(TestData.MerchantCreatedEvent);
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p => p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(newState);
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => newState;
 
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
-        //repo.Setup(r => r.Save(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(state));
+        repo.LoadResult = Result.Failure();
+        //repo.SaveResult = Result.Success(state);
 
-        //stateDispatcher.Setup(d => d.Dispatch(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        //stateDispatcher.DispatchResult = Result.Success();
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsFailed.ShouldBeTrue();
     }
@@ -134,21 +131,21 @@ public async Task ProjectionHandler_Handle_LoadFails_FailedResult()
     [Fact]
     public async Task ProjectionHandler_Handle_SaveFails_FailedResult()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-            stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+            stateDispatcher);
         MerchantBalanceState state = new MerchantBalanceState();
         MerchantBalanceState newState = new MerchantBalanceState();
         newState = newState.HandleMerchantCreated(TestData.MerchantCreatedEvent);
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p => p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(newState);
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => newState;
 
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(state);
-        repo.Setup(r => r.Save(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure());
+        repo.LoadResult = state;
+        repo.SaveResult = Result.Failure();
 
-        //stateDispatcher.Setup(d => d.Dispatch(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
+        //stateDispatcher.DispatchResult = Result.Success();
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsFailed.ShouldBeTrue();
     }
@@ -156,21 +153,21 @@ public async Task ProjectionHandler_Handle_SaveFails_FailedResult()
     [Fact]
     public async Task ProjectionHandler_Handle_DispatchFails_FailedResult()
     {
-        Mock<IProjectionStateRepository<MerchantBalanceState>> repo = new Mock<IProjectionStateRepository<MerchantBalanceState>>();
-        Mock<IProjection<MerchantBalanceState>> projection = new Mock<IProjection<MerchantBalanceState>>();
-        Mock<IStateDispatcher<MerchantBalanceState>> stateDispatcher = new Mock<IStateDispatcher<MerchantBalanceState>>();
-        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo.Object, projection.Object,
-            stateDispatcher.Object);
+        TestProjectionStateRepository repo = new();
+        TestProjection projection = new();
+        TestStateDispatcher stateDispatcher = new();
+        ProjectionHandler.ProjectionHandler<MerchantBalanceState> ph = new ProjectionHandler.ProjectionHandler<MerchantBalanceState>(repo, projection,
+            stateDispatcher);
         MerchantBalanceState state = new MerchantBalanceState();
         MerchantBalanceState newState = new MerchantBalanceState();
         newState = newState.HandleMerchantCreated(TestData.MerchantCreatedEvent);
-        projection.Setup(p => p.ShouldIHandleEvent(It.IsAny<IDomainEvent>())).Returns(true);
-        projection.Setup(p => p.Handle(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(newState);
+        projection.ShouldHandle = true;
+        projection.HandleFunc = (_, _, _) => newState;
 
-        repo.Setup(r => r.Load(It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(state);
-        repo.Setup(r => r.Save(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(state));
+        repo.LoadResult = state;
+        repo.SaveResult = Result.Success(state);
 
-        stateDispatcher.Setup(d => d.Dispatch(It.IsAny<MerchantBalanceState>(), It.IsAny<IDomainEvent>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
+        stateDispatcher.DispatchResult = Result.Failure();
         var result = await ph.Handle(TestData.MerchantCreatedEvent, CancellationToken.None);
         result.IsFailed.ShouldBeTrue();
     }
@@ -198,11 +195,11 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
 public class MerchantBalanceStateDispatcherTests
 {
     private readonly IStateDispatcher<MerchantBalanceState> Dispatcher;
-    private readonly Mock<ITransactionProcessorReadRepository> Repository;
+    private readonly TestReadRepository Repository;
 
     public MerchantBalanceStateDispatcherTests() {
-        this.Repository = new Mock<ITransactionProcessorReadRepository>();
-        this.Dispatcher = new MerchantBalanceStateDispatcher(this.Repository.Object);
+        this.Repository = new TestReadRepository();
+        this.Dispatcher = new MerchantBalanceStateDispatcher(this.Repository);
         Logger.Initialise(new NullLogger());
     }
 
@@ -216,7 +213,7 @@ public MerchantBalanceStateDispatcherTests() {
     public async Task MerchantBalanceStateDispatcher_EventIsDispatched_ResultSuccessful(Type type) {
         MerchantBalanceState state = new();
 
-        this.Repository.Setup(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.Repository.AddResult = Result.Success();
 
         IDomainEvent domainEvent = type.Name switch {
             nameof(MerchantDomainEvents.MerchantCreatedEvent) => TestData.MerchantCreatedEvent,
@@ -231,7 +228,7 @@ public async Task MerchantBalanceStateDispatcher_EventIsDispatched_ResultSuccess
         if (domainEvent != null) {
             var result = await this.Dispatcher.Dispatch(state, domainEvent, CancellationToken.None);
             result.IsSuccess.ShouldBeTrue();
-            this.Repository.Verify(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>()), Times.Once);
+            this.Repository.AddCalls.ShouldBe(1);
         }
     }
 
@@ -240,14 +237,14 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
     {
         MerchantBalanceState state = new();
 
-        this.Repository.Setup(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.Repository.AddResult = Result.Success();
 
         IDomainEvent domainEvent = TestData.TransactionHasBeenCompletedEvent with {
                 IsAuthorised = false
             };
             var result = await this.Dispatcher.Dispatch(state, domainEvent, CancellationToken.None);
             result.IsSuccess.ShouldBeTrue();
-            this.Repository.Verify(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>()), Times.Never);
+            this.Repository.AddCalls.ShouldBe(0);
     }
 
     [Fact]
@@ -255,7 +252,7 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
     {
         MerchantBalanceState state = new();
 
-        this.Repository.Setup(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.Repository.AddResult = Result.Success();
 
         IDomainEvent domainEvent = TestData.TransactionHasBeenCompletedEvent with
         {
@@ -263,7 +260,7 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
         };
         var result = await this.Dispatcher.Dispatch(state, domainEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
-        this.Repository.Verify(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>()), Times.Never);
+        this.Repository.AddCalls.ShouldBe(0);
     }
 
     [Fact]
@@ -271,7 +268,7 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
     {
         MerchantBalanceState state = new();
 
-        this.Repository.Setup(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        this.Repository.AddResult = Result.Success();
 
         IDomainEvent domainEvent = TestData.TransactionHasBeenCompletedEvent with
         {
@@ -279,7 +276,49 @@ public async Task MerchantBalanceStateDispatcher_TransactionHasBeenCompletedEven
         };
         var result = await this.Dispatcher.Dispatch(state, domainEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
-        this.Repository.Verify(t => t.AddMerchantBalanceChangedEntry(It.IsAny<MerchantBalanceChangedEntry>(), It.IsAny<CancellationToken>()), Times.Once);
+        this.Repository.AddCalls.ShouldBe(1);
     }
 
-}
\ No newline at end of file
+}
+
+internal sealed class TestProjectionStateRepository : IProjectionStateRepository<MerchantBalanceState>
+{
+    public Result<MerchantBalanceState> LoadResult { get; set; } = new();
+    public Result<MerchantBalanceState> SaveResult { get; set; } = new();
+
+    public Task<Result<MerchantBalanceState>> Load(IDomainEvent @event, CancellationToken cancellationToken) => Task.FromResult(LoadResult);
+    public Task<Result<MerchantBalanceState>> Load(Guid estateId, Guid stateId, CancellationToken cancellationToken) => Task.FromResult(LoadResult);
+    public Task<Result<MerchantBalanceState>> Save(MerchantBalanceState state, IDomainEvent @event, CancellationToken cancellationToken) => Task.FromResult(SaveResult);
+}
+
+internal sealed class TestProjection : IProjection<MerchantBalanceState>
+{
+    public bool ShouldHandle { get; set; }
+    public Func<MerchantBalanceState, IDomainEvent, CancellationToken, MerchantBalanceState> HandleFunc { get; set; } = (state, _, _) => state;
+
+    public Task<MerchantBalanceState> Handle(MerchantBalanceState state, IDomainEvent domainEvent, CancellationToken cancellationToken) =>
+        Task.FromResult(HandleFunc(state, domainEvent, cancellationToken));
+
+    public bool ShouldIHandleEvent(IDomainEvent domainEvent) => ShouldHandle;
+}
+
+internal sealed class TestStateDispatcher : IStateDispatcher<MerchantBalanceState>
+{
+    public Result DispatchResult { get; set; } = Result.Success();
+    public Task<Result> Dispatch(MerchantBalanceState state, IDomainEvent @event, CancellationToken cancellationToken) => Task.FromResult(DispatchResult);
+}
+
+internal sealed class TestReadRepository : ITransactionProcessorReadRepository
+{
+    public Result AddResult { get; set; } = Result.Success();
+    public int AddCalls { get; private set; }
+
+    public Task<Result> AddMerchantBalanceChangedEntry(MerchantBalanceChangedEntry entry, CancellationToken cancellationToken)
+    {
+        AddCalls++;
+        return Task.FromResult(AddResult);
+    }
+
+    public Task<Result<List<MerchantBalanceChangedEntry>>> GetMerchantBalanceHistory(Guid estateId, Guid merchantId, DateTime startDate, DateTime endDate, CancellationToken cancellationToken) =>
+        Task.FromResult(new Result<List<MerchantBalanceChangedEntry>>());
+}
diff --git a/TransactionProcessor.ProjectionEngine.Tests/TransactionProcessor.ProjectionEngine.Tests.csproj b/TransactionProcessor.ProjectionEngine.Tests/TransactionProcessor.ProjectionEngine.Tests.csproj
index 9ee770e7..bcf08aad 100644
--- a/TransactionProcessor.ProjectionEngine.Tests/TransactionProcessor.ProjectionEngine.Tests.csproj
+++ b/TransactionProcessor.ProjectionEngine.Tests/TransactionProcessor.ProjectionEngine.Tests.csproj
@@ -16,7 +16,6 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
     <PackageReference Include="Microsoft.IdentityModel.Tokens" />
     <PackageReference Include="Microsoft.IdentityModel.JsonWebTokens" />
-    <PackageReference Include="Moq" />
     <PackageReference Include="OpenTelemetry.Api" />
     <PackageReference Include="Shouldly" />
     <PackageReference Include="xunit.v3.mtp-v2" />
diff --git a/TransactionProcessor.Tests/Common/TransactionProcessorWebFactory.cs b/TransactionProcessor.Tests/Common/TransactionProcessorWebFactory.cs
index 8d12e9b2..7705e75e 100644
--- a/TransactionProcessor.Tests/Common/TransactionProcessorWebFactory.cs
+++ b/TransactionProcessor.Tests/Common/TransactionProcessorWebFactory.cs
@@ -12,7 +12,7 @@ namespace TransactionProcessor.Tests.Common
     using Microsoft.AspNetCore.Mvc.Authorization;
     using Microsoft.AspNetCore.Mvc.Testing;
     using Microsoft.Extensions.DependencyInjection;
-    using Moq;
+    using Imposter.Abstractions;
     using Xunit;
 
     public class TransactionProcessorWebFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
@@ -20,13 +20,13 @@ public class TransactionProcessorWebFactory<TStartup> : WebApplicationFactory<TS
         protected override void ConfigureWebHost(IWebHostBuilder builder)
         {
             // Setup my mocks in here
-            Mock<IMediator> mediatorMock = this.CreateMediatorMock();
+            IMediatorImposter mediatorMock = this.CreateMediatorMock();
 
             builder.ConfigureServices((builderContext, services) =>
             {
                 if (mediatorMock != null)
                 {
-                    services.AddSingleton<IMediator>(mediatorMock.Object);
+                    services.AddSingleton<IMediator>(mediatorMock.Instance());
                 }
 
                 services.AddMvc(options =>
@@ -38,11 +38,11 @@ protected override void ConfigureWebHost(IWebHostBuilder builder)
             ;
         }
 
-        private Mock<IMediator> CreateMediatorMock()
+        private IMediatorImposter CreateMediatorMock()
         {
-            Mock<IMediator> mediatorMock = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediatorMock = new();
 
-            mediatorMock.Setup(c => c.Send(It.IsAny<IRequest<String>>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult("Hello"));
+            mediatorMock.Send<String>(Arg<IRequest<String>>.Any(), Arg<CancellationToken>.Any()).Returns(Task.FromResult("Hello"));
 
             return mediatorMock;
         }
diff --git a/TransactionProcessor.Tests/General/AutoLogonWorkerServiceTests.cs b/TransactionProcessor.Tests/General/AutoLogonWorkerServiceTests.cs
index 3d5377db..87f55d05 100644
--- a/TransactionProcessor.Tests/General/AutoLogonWorkerServiceTests.cs
+++ b/TransactionProcessor.Tests/General/AutoLogonWorkerServiceTests.cs
@@ -1,7 +1,7 @@
 using Grpc.Core;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging.Abstractions;
-using Moq;
+using Imposter.Abstractions;
 using Shared.Logger;
 using Shouldly;
 using System;
@@ -19,12 +19,12 @@ public AutoLogonWorkerServiceTests() {
 
     [Fact]
     public async Task OperatorLogonAsync_TransientGrpcUnavailable_ExceptionIsHandled() {
-        Mock<IOperatorProxy> proxy = new Mock<IOperatorProxy>();
-        proxy.Setup(x => x.ProcessLogonMessage(It.IsAny<CancellationToken>()))
-             .ThrowsAsync(new RpcException(new Status(StatusCode.Unavailable, "RPC server unavailable")));
+        IOperatorProxyImposter proxy = new IOperatorProxyImposter();
+        proxy.ProcessLogonMessage(Arg<CancellationToken>.Any())
+             .Throws(new RpcException(new Status(StatusCode.Unavailable, "RPC server unavailable")));
 
         ServiceCollection services = new ServiceCollection();
-        services.AddSingleton<Func<String, IOperatorProxy>>(_ => _ => proxy.Object);
+        services.AddSingleton<Func<String, IOperatorProxy>>(_ => _ => proxy.Instance());
         IServiceProvider previousServiceProvider = Startup.ServiceProvider;
 
         try {
@@ -46,12 +46,12 @@ public async Task OperatorLogonAsync_TransientGrpcUnavailable_ExceptionIsHandled
 
     [Fact]
     public async Task OperatorLogonAsync_NonTransientException_ExceptionIsHandled() {
-        Mock<IOperatorProxy> proxy = new Mock<IOperatorProxy>();
-        proxy.Setup(x => x.ProcessLogonMessage(It.IsAny<CancellationToken>()))
-             .ThrowsAsync(new InvalidOperationException("boom"));
+        IOperatorProxyImposter proxy = new IOperatorProxyImposter();
+        proxy.ProcessLogonMessage(Arg<CancellationToken>.Any())
+             .Throws(new InvalidOperationException("boom"));
 
         ServiceCollection services = new ServiceCollection();
-        services.AddSingleton<Func<String, IOperatorProxy>>(_ => _ => proxy.Object);
+        services.AddSingleton<Func<String, IOperatorProxy>>(_ => _ => proxy.Instance());
         IServiceProvider previousServiceProvider = Startup.ServiceProvider;
 
         try {
diff --git a/TransactionProcessor.Tests/General/BootstrapperTests.cs b/TransactionProcessor.Tests/General/BootstrapperTests.cs
index 364837ab..212a2159 100644
--- a/TransactionProcessor.Tests/General/BootstrapperTests.cs
+++ b/TransactionProcessor.Tests/General/BootstrapperTests.cs
@@ -7,7 +7,7 @@ namespace TransactionProcessor.Tests.General
     using Microsoft.Extensions.Configuration;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Hosting;
-    using Moq;
+    using Imposter.Abstractions;
     using Shared.Serialisation;
     using System;
     using System.Collections.Generic;
@@ -26,22 +26,22 @@ public class BootstrapperTests
         [Fact]
         public void ConfigureContainer_PopulatesAutoApiLogonOperators_WithoutDuplicates()
         {
-            Mock<IWebHostEnvironment> hostingEnvironment = new Mock<IWebHostEnvironment>();
-            hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
-            hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
-            hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");
+            IWebHostEnvironmentImposter hostingEnvironment = new IWebHostEnvironmentImposter();
+            hostingEnvironment.EnvironmentName.Getter().Returns("Development");
+            hostingEnvironment.ContentRootPath.Getter().Returns("/home");
+            hostingEnvironment.ApplicationName.Getter().Returns("Test Application");
 
-            Startup s = new Startup(hostingEnvironment.Object);
+            Startup s = new Startup(hostingEnvironment.Instance());
             Startup.Configuration = this.SetupMemoryConfiguration();
 
             ServiceRegistry firstServices = new ServiceRegistry();
-            this.AddTestRegistrations(firstServices, hostingEnvironment.Object);
+            this.AddTestRegistrations(firstServices, hostingEnvironment.Instance());
             s.ConfigureContainer(firstServices);
 
             Assert.Equal(new[] { "Safaricom", "PataPawaPostPay" }, Startup.AutoApiLogonOperators.ToArray());
 
             ServiceRegistry secondServices = new ServiceRegistry();
-            this.AddTestRegistrations(secondServices, hostingEnvironment.Object);
+            this.AddTestRegistrations(secondServices, hostingEnvironment.Instance());
             s.ConfigureContainer(secondServices);
 
             Assert.Equal(new[] { "Safaricom", "PataPawaPostPay" }, Startup.AutoApiLogonOperators.ToArray());
diff --git a/TransactionProcessor.Tests/HandlerTests/TransactionHandlersTests.cs b/TransactionProcessor.Tests/HandlerTests/TransactionHandlersTests.cs
index 31fd6095..c7721aeb 100644
--- a/TransactionProcessor.Tests/HandlerTests/TransactionHandlersTests.cs
+++ b/TransactionProcessor.Tests/HandlerTests/TransactionHandlersTests.cs
@@ -4,7 +4,7 @@
 using System.Threading.Tasks;
 using MediatR;
 using Microsoft.AspNetCore.Http;
-using Moq;
+using Imposter.Abstractions;
 using Shared.General;
 using Shouldly;
 using SimpleResults;
@@ -21,7 +21,7 @@ public class TransactionHandlersTests
         [Fact]
         public async Task PerformTransaction_LogonPayloadWithoutTypeMetadata_SendsLogonCommand()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             LogonTransactionRequest request = new LogonTransactionRequest
             {
                 DeviceIdentifier = "device-1",
@@ -32,7 +32,7 @@ public async Task PerformTransaction_LogonPayloadWithoutTypeMetadata_SendsLogonC
                 MerchantId = TestData.MerchantId
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessLogonTransactionCommand>(), It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessLogonTransactionResponse>>(Arg<IRequest<Result<ProcessLogonTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new ProcessLogonTransactionResponse
                 {
                     EstateId = TestData.EstateId,
@@ -42,19 +42,19 @@ public async Task PerformTransaction_LogonPayloadWithoutTypeMetadata_SendsLogonC
                     TransactionId = Guid.NewGuid()
                 }));
 
-            IResult result = await TransactionHandlers.PerformLogonTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformLogonTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessLogonTransactionResponse>>(Arg<IRequest<Result<ProcessLogonTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_SalePayloadWithoutTypeMetadata_SendsSaleCommand()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             SaleTransactionRequest request = new SaleTransactionRequest
             {
                 AdditionalTransactionMetadata = new Dictionary<String, String> { { "amount", "12.34" } },
@@ -71,8 +71,7 @@ public async Task PerformTransaction_SalePayloadWithoutTypeMetadata_SendsSaleCom
                 MerchantId = TestData.MerchantId
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessSaleTransactionCommand>(),
-                It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new ProcessSaleTransactionResponse
                 {
                     EstateId = TestData.EstateId,
@@ -82,19 +81,19 @@ public async Task PerformTransaction_SalePayloadWithoutTypeMetadata_SendsSaleCom
                     TransactionId = Guid.NewGuid()
                 }));
 
-            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_SalePayloadWithoutTransactionSource_UsesDefaultSource()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             TransactionCommands.ProcessSaleTransactionCommand? capturedCommand = null;
             SaleTransactionRequest request = new SaleTransactionRequest
             {
@@ -111,9 +110,7 @@ public async Task PerformTransaction_SalePayloadWithoutTransactionSource_UsesDef
                 MerchantId = TestData.MerchantId
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessSaleTransactionCommand>(),
-                It.IsAny<CancellationToken>()))
-                .Callback((IRequest<Result<ProcessSaleTransactionResponse>> request, CancellationToken _) => capturedCommand = (TransactionCommands.ProcessSaleTransactionCommand)request)
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new ProcessSaleTransactionResponse
                 {
                     EstateId = TestData.EstateId,
@@ -121,9 +118,10 @@ public async Task PerformTransaction_SalePayloadWithoutTransactionSource_UsesDef
                     ResponseCode = "0000",
                     ResponseMessage = "SUCCESS",
                     TransactionId = Guid.NewGuid()
-                }));
+                }))
+                .Callback((IRequest<Result<ProcessSaleTransactionResponse>> request, CancellationToken _) => { capturedCommand = (TransactionCommands.ProcessSaleTransactionCommand)request; return Task.CompletedTask; });
 
-            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
@@ -131,13 +129,13 @@ public async Task PerformTransaction_SalePayloadWithoutTransactionSource_UsesDef
             result.ShouldNotBeNull();
             capturedCommand.ShouldNotBeNull();
             capturedCommand!.TransactionSource.ShouldBe(1);
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_SalePayload_WhenMediatorFails_ReturnsFailure()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             SaleTransactionRequest request = new SaleTransactionRequest
             {
                 AdditionalTransactionMetadata = new Dictionary<String, String> { { "amount", "12.34" } },
@@ -154,23 +152,22 @@ public async Task PerformTransaction_SalePayload_WhenMediatorFails_ReturnsFailur
                 MerchantId = TestData.MerchantId
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessSaleTransactionCommand>(),
-                It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("boom").ToResult(new ProcessSaleTransactionResponse()));
 
-            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformSaleTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessSaleTransactionResponse>>(Arg<IRequest<Result<ProcessSaleTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_LogonPayload_WhenMediatorFails_ReturnsFailure()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             LogonTransactionRequest request = new LogonTransactionRequest
             {
                 DeviceIdentifier = "device-1",
@@ -181,22 +178,22 @@ public async Task PerformTransaction_LogonPayload_WhenMediatorFails_ReturnsFailu
                 MerchantId = TestData.MerchantId
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessLogonTransactionCommand>(), It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessLogonTransactionResponse>>(Arg<IRequest<Result<ProcessLogonTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("boom").ToResult(new ProcessLogonTransactionResponse()));
 
-            IResult result = await TransactionHandlers.PerformLogonTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformLogonTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessLogonTransactionResponse>>(Arg<IRequest<Result<ProcessLogonTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_ReconciliationPayloadWithoutTypeMetadata_SendsReconciliationCommand()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             ReconciliationRequest request = new ReconciliationRequest
             {
                 DeviceIdentifier = "device-1",
@@ -209,8 +206,7 @@ public async Task PerformTransaction_ReconciliationPayloadWithoutTypeMetadata_Se
                 TransactionType = "Reconciliation"
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessReconciliationCommand>(),
-                It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessReconciliationTransactionResponse>>(Arg<IRequest<Result<ProcessReconciliationTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success(new ProcessReconciliationTransactionResponse
                 {
                     EstateId = TestData.EstateId,
@@ -220,19 +216,19 @@ public async Task PerformTransaction_ReconciliationPayloadWithoutTypeMetadata_Se
                     TransactionId = Guid.NewGuid()
                 }));
 
-            IResult result = await TransactionHandlers.PerformReconciliationTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformReconciliationTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessReconciliationTransactionResponse>>(Arg<IRequest<Result<ProcessReconciliationTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task PerformTransaction_ReconciliationPayload_WhenMediatorFails_ReturnsFailure()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
             ReconciliationRequest request = new ReconciliationRequest
             {
                 DeviceIdentifier = "device-1",
@@ -245,35 +241,34 @@ public async Task PerformTransaction_ReconciliationPayload_WhenMediatorFails_Ret
                 TransactionType = "Reconciliation"
             };
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ProcessReconciliationCommand>(),
-                It.IsAny<CancellationToken>()))
+            mediator.Send<Result<ProcessReconciliationTransactionResponse>>(Arg<IRequest<Result<ProcessReconciliationTransactionResponse>>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Failure("boom").ToResult(new ProcessReconciliationTransactionResponse()));
 
-            IResult result = await TransactionHandlers.PerformReconciliationTransaction(mediator.Object,
+            IResult result = await TransactionHandlers.PerformReconciliationTransaction(mediator.Instance(),
                 new DefaultHttpContext(),
                 request,
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result<ProcessReconciliationTransactionResponse>>(Arg<IRequest<Result<ProcessReconciliationTransactionResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         [Fact]
         public async Task ResendTransactionReceipt_SendsCommand()
         {
-            Mock<IMediator> mediator = new Mock<IMediator>(MockBehavior.Strict);
+            IMediatorImposter mediator = new();
 
-            mediator.Setup(m => m.Send(It.IsAny<TransactionCommands.ResendTransactionReceiptCommand>(), It.IsAny<CancellationToken>()))
+            mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
                 .ReturnsAsync(Result.Success());
 
-            IResult result = await TransactionHandlers.ResendTransactionReceipt(mediator.Object,
+            IResult result = await TransactionHandlers.ResendTransactionReceipt(mediator.Instance(),
                 new DefaultHttpContext(),
                 TestData.EstateId,
                 Guid.NewGuid(),
                 CancellationToken.None);
 
             result.ShouldNotBeNull();
-            mediator.VerifyAll();
+            mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once());
         }
 
         private static class TestData
diff --git a/TransactionProcessor.Tests/HandlerTests/WebHandlersTests.cs b/TransactionProcessor.Tests/HandlerTests/WebHandlersTests.cs
index dd701465..2be903b1 100644
--- a/TransactionProcessor.Tests/HandlerTests/WebHandlersTests.cs
+++ b/TransactionProcessor.Tests/HandlerTests/WebHandlersTests.cs
@@ -1,6 +1,6 @@
 using MediatR;
 using Microsoft.AspNetCore.Http;
-using Moq;
+using Imposter.Abstractions;
 using Shouldly;
 using SimpleResults;
 using System;
@@ -53,119 +53,91 @@ public class WebHandlersTests
     [MemberData(nameof(ContractCases))]
     public async Task ContractHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(EstateCases))]
     public async Task EstateHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(FloatCases))]
     public async Task FloatHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(MerchantCases))]
     public async Task MerchantHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(OperatorCases))]
     public async Task OperatorHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(SettlementCases))]
     public async Task SettlementHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     [Theory]
     [MemberData(nameof(VoucherCases))]
     public async Task VoucherHandlers_AreCovered(HandlerCase testCase)
     {
-        Mock<IMediator> mediator = new(MockBehavior.Strict);
+        IMediatorImposter mediator = new();
         testCase.Setup(mediator);
 
-        IResult result = await testCase.Invoke(mediator.Object);
+        IResult result = await testCase.Invoke(mediator.Instance());
 
         result.ShouldNotBeNull();
         testCase.Verify?.Invoke(mediator);
-        if (testCase.Verify is null)
-        {
-            mediator.VerifyAll();
-        }
     }
 
     public static IEnumerable<object[]> ContractCases()
@@ -1129,36 +1101,41 @@ public static IEnumerable<object[]> VoucherCases()
             "GetVoucher_Invalid",
             mediator => { },
             mediator => VoucherHandlers.GetVoucher(mediator, new DefaultHttpContext(), EstateId, "", null, CancellationToken.None),
-            mediator => mediator.VerifyNoOtherCalls());
+            mediator => { });
     }
 
-    private static object[] Case(string name, Action<Mock<IMediator>> setup, Func<IMediator, Task<IResult>> invoke, Action<Mock<IMediator>>? verify = null)
+    private static object[] Case(string name, MediatorSetup setup, Func<IMediator, Task<IResult>> invoke, Action<IMediatorImposter>? verify = null)
+        => new object[] { new HandlerCase(name, setup.Configure, invoke, verify ?? setup.Verify) };
+
+    private static object[] Case(string name, Action<IMediatorImposter> setup, Func<IMediator, Task<IResult>> invoke, Action<IMediatorImposter>? verify = null)
         => new object[] { new HandlerCase(name, setup, invoke, verify) };
 
-    private static Action<Mock<IMediator>> SetupSuccess<TRequest, TResponse>(TResponse response, Action<TRequest>? capture = null)
+    private static MediatorSetup SetupSuccess<TRequest, TResponse>(TResponse response, Action<TRequest>? capture = null)
         where TRequest : class, IRequest<Result<TResponse>>
     {
-        return mediator =>
+        return new MediatorSetup(mediator =>
         {
-            mediator.Setup(m => m.Send(It.IsAny<IRequest<Result<TResponse>>>(), It.IsAny<CancellationToken>()))
-                    .Callback((IRequest<Result<TResponse>> request, CancellationToken _) => capture?.Invoke((TRequest)request))
-                    .ReturnsAsync(Result.Success(response));
-        };
+            mediator.Send<Result<TResponse>>(Arg<IRequest<Result<TResponse>>>.Any(), Arg<CancellationToken>.Any())
+                    .ReturnsAsync(Result.Success(response))
+                    .Callback((IRequest<Result<TResponse>> request, CancellationToken _) => { capture?.Invoke((TRequest)request); return Task.CompletedTask; });
+        }, mediator => mediator.Send<Result<TResponse>>(Arg<IRequest<Result<TResponse>>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once()));
     }
 
-    private static Action<Mock<IMediator>> SetupSuccess<TRequest>(Action<TRequest>? capture = null)
+    private static MediatorSetup SetupSuccess<TRequest>(Action<TRequest>? capture = null)
         where TRequest : class, IRequest<Result>
     {
-        return mediator =>
+        return new MediatorSetup(mediator =>
         {
-            mediator.Setup(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-                    .Callback((IRequest<Result> request, CancellationToken _) => capture?.Invoke((TRequest)request))
-                    .ReturnsAsync(Result.Success());
-        };
+            mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any())
+                    .ReturnsAsync(Result.Success())
+                    .Callback((IRequest<Result> request, CancellationToken _) => { capture?.Invoke((TRequest)request); return Task.CompletedTask; });
+        }, mediator => mediator.Send<Result>(Arg<IRequest<Result>>.Any(), Arg<CancellationToken>.Any()).Called(Count.Once()));
     }
 
+    private sealed record MediatorSetup(Action<IMediatorImposter> Configure, Action<IMediatorImposter> Verify);
+
     public sealed record HandlerCase(string Name,
-                                     Action<Mock<IMediator>> Setup,
+                                     Action<IMediatorImposter> Setup,
                                      Func<IMediator, Task<IResult>> Invoke,
-                                     Action<Mock<IMediator>>? Verify = null);
+                                     Action<IMediatorImposter>? Verify = null);
 }
diff --git a/TransactionProcessor.Tests/ImposterUsings.cs b/TransactionProcessor.Tests/ImposterUsings.cs
new file mode 100644
index 00000000..74830d16
--- /dev/null
+++ b/TransactionProcessor.Tests/ImposterUsings.cs
@@ -0,0 +1,11 @@
+using Imposter.Abstractions;
+using Microsoft.AspNetCore.Hosting;
+using MediatR;
+using TransactionProcessor.BusinessLogic.OperatorInterfaces;
+using Shared.EntityFramework;
+using TransactionProcessor.Database.Contexts;
+
+[assembly: GenerateImposter(typeof(IMediator))]
+[assembly: GenerateImposter(typeof(IWebHostEnvironment))]
+[assembly: GenerateImposter(typeof(IOperatorProxy))]
+[assembly: GenerateImposter(typeof(IDbContextResolver<EstateManagementContext>))]
diff --git a/TransactionProcessor.Tests/RepositoryTests/MerchantBalanceStateRepositoryTests.cs b/TransactionProcessor.Tests/RepositoryTests/MerchantBalanceStateRepositoryTests.cs
index f74bd5a8..32075a7e 100644
--- a/TransactionProcessor.Tests/RepositoryTests/MerchantBalanceStateRepositoryTests.cs
+++ b/TransactionProcessor.Tests/RepositoryTests/MerchantBalanceStateRepositoryTests.cs
@@ -2,7 +2,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.Extensions.DependencyInjection;
-using Moq;
+using Imposter.Abstractions;
 using Shared.EntityFramework;
 using Shouldly;
 using System;
@@ -46,11 +46,11 @@ public async Task Load_ReturnsFailure_WhenQueryThrows()
 
         using IServiceScope scope = serviceProvider.CreateScope();
 
-        Mock<IDbContextResolver<EstateManagementContext>> resolver = new();
-        resolver.Setup(r => r.Resolve(It.IsAny<string>(), It.IsAny<string>()))
+        IDbContextResolverImposter<EstateManagementContext> resolver = new();
+        resolver.Resolve(Arg<string>.Any(), Arg<string>.Any())
                 .Returns(new ResolvedDbContext<EstateManagementContext>(scope));
 
-        MerchantBalanceStateRepository repository = new(resolver.Object);
+        MerchantBalanceStateRepository repository = new(resolver.Instance());
 
         var result = await repository.Load(estateId, merchantId, CancellationToken.None);
 
diff --git a/TransactionProcessor.Tests/RepositoryTests/TransactionProcessorReadModelRepositoryTests.cs b/TransactionProcessor.Tests/RepositoryTests/TransactionProcessorReadModelRepositoryTests.cs
index 508a5d73..3b8b5bd6 100644
--- a/TransactionProcessor.Tests/RepositoryTests/TransactionProcessorReadModelRepositoryTests.cs
+++ b/TransactionProcessor.Tests/RepositoryTests/TransactionProcessorReadModelRepositoryTests.cs
@@ -1,7 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Data.Sqlite;
-using Moq;
+using Imposter.Abstractions;
 using Shared.EntityFramework;
 using Shouldly;
 using System;
@@ -58,11 +58,11 @@ await context.Estates.AddAsync(new Estate
                 IServiceScope scope = serviceProvider.CreateScope();
                 _ = scope.ServiceProvider.GetRequiredService<TrackingDisposable>();
 
-                Mock<IDbContextResolver<EstateManagementContext>> resolver = new();
-                resolver.Setup(r => r.Resolve(It.IsAny<String>(), It.IsAny<String>()))
+                IDbContextResolverImposter<EstateManagementContext> resolver = new();
+                resolver.Resolve(Arg<String>.Any(), Arg<String>.Any())
                         .Returns(new ResolvedDbContext<EstateManagementContext>(scope));
 
-                TransactionProcessorReadModelRepository repository = new TransactionProcessorReadModelRepository(resolver.Object);
+                TransactionProcessorReadModelRepository repository = new TransactionProcessorReadModelRepository(resolver.Instance());
 
                 var result = await repository.GetEstate(estateId, CancellationToken.None);
 
diff --git a/TransactionProcessor.Tests/TransactionProcessor.Tests.csproj b/TransactionProcessor.Tests/TransactionProcessor.Tests.csproj
index 21eb35b2..a8311e80 100644
--- a/TransactionProcessor.Tests/TransactionProcessor.Tests.csproj
+++ b/TransactionProcessor.Tests/TransactionProcessor.Tests.csproj
@@ -15,7 +15,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" />
     <PackageReference Include="Microsoft.Extensions.Logging.Debug" />
-    <PackageReference Include="Moq" />
+    <PackageReference Include="Imposter" />
     <PackageReference Include="NuGet.Packaging" />
     <PackageReference Include="NuGet.Protocol" />
     <PackageReference Include="OpenTelemetry.Api" />