diff --git a/Directory.Packages.props b/Directory.Packages.props
index 39484ae..2827f4f 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -28,7 +28,7 @@
     <PackageVersion Include="Reqnroll.Tools.MsBuild.Generation" Version="3.3.4" />
     <PackageVersion Include="NUnit" Version="4.6.1" />
     <PackageVersion Include="Lamar" Version="16.0.0" />
-    <PackageVersion Include="Moq" Version="4.20.72" />
+    <PackageVersion Include="Imposter" Version="0.1.9" />
     <PackageVersion Include="Microsoft.AspNetCore.Mvc.Core" Version="2.3.12" />
     <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.11" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.11" />
@@ -59,4 +59,4 @@
     <PackageVersion Include="SecurityService.IntegrationTesting.Helpers" Version="2026.8.1" />
     <PackageVersion Include="coverlet.collector" Version="10.0.1" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/MessagingService.BusinessLogic.Tests/DomainEventHanders/EmailDomainEventHandlerTests.cs b/MessagingService.BusinessLogic.Tests/DomainEventHanders/EmailDomainEventHandlerTests.cs
index 2ceb13e..b723ffd 100644
--- a/MessagingService.BusinessLogic.Tests/DomainEventHanders/EmailDomainEventHandlerTests.cs
+++ b/MessagingService.BusinessLogic.Tests/DomainEventHanders/EmailDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Text;
 using MediatR;
 
@@ -8,7 +8,7 @@ namespace MessagingService.BusinessLogic.Tests.DomainEventHanders
     using BusinessLogic.Services.EmailServices;
     using EmailMessageAggregate;
     using EventHandling;
-    using Moq;
+    using Imposter.Abstractions;
     using System.Threading.Tasks;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EventStore.Aggregate;
@@ -16,20 +16,20 @@ namespace MessagingService.BusinessLogic.Tests.DomainEventHanders
     using Xunit;
 
     public class EmailDomainEventHandlerTests {
-        private Mock<IMediator> Mediator;
-        private Mock<IEmailServiceProxy> EmailServiceProxy;
+        private IMediatorImposter Mediator;
+        private IEmailServiceProxyImposter EmailServiceProxy;
         private EmailDomainEventHandler EmailDomainEventHandler;
         public EmailDomainEventHandlerTests() {
-            this.Mediator = new Mock<IMediator>();
-            this.EmailServiceProxy = new Mock<IEmailServiceProxy>();
+            this.Mediator = new IMediatorImposter();
+            this.EmailServiceProxy = new IEmailServiceProxyImposter();
             this.EmailDomainEventHandler =
-                new EmailDomainEventHandler(this.Mediator.Object, this.EmailServiceProxy.Object);
+                new EmailDomainEventHandler(this.Mediator.Instance(), this.EmailServiceProxy.Instance());
         }
 
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Delivered_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseDelivered);
             
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
@@ -38,7 +38,7 @@ public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEve
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Failed_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseFailed);
             
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
@@ -47,7 +47,7 @@ public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEve
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Rejected_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseRejected);
 
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
@@ -56,7 +56,7 @@ public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEve
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Bounced_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseBounced);
 
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
@@ -65,7 +65,7 @@ public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEve
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Spam_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseSpam);
 
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
@@ -74,7 +74,7 @@ public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEve
         [Fact]
         public async Task EmailDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Unknown_EventIsHandled()
         {
-            this.EmailServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<CancellationToken>()))
+            this.EmailServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<DateTime>.Any(), Arg<DateTime>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.MessageStatusResponseUnknown);
             
             await this.EmailDomainEventHandler.Handle(TestData.ResponseReceivedFromEmailProviderEvent, CancellationToken.None);
diff --git a/MessagingService.BusinessLogic.Tests/DomainEventHanders/SMSDomainEventHandlerTests.cs b/MessagingService.BusinessLogic.Tests/DomainEventHanders/SMSDomainEventHandlerTests.cs
index a818260..6fe576d 100644
--- a/MessagingService.BusinessLogic.Tests/DomainEventHanders/SMSDomainEventHandlerTests.cs
+++ b/MessagingService.BusinessLogic.Tests/DomainEventHanders/SMSDomainEventHandlerTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Text;
 
 namespace MessagingService.BusinessLogic.Tests.DomainEventHanders
@@ -7,7 +7,7 @@ namespace MessagingService.BusinessLogic.Tests.DomainEventHanders
     using BusinessLogic.Services.EmailServices;
     using EmailMessageAggregate;
     using EventHandling;
-    using Moq;
+    using Imposter.Abstractions;
     using System.Threading.Tasks;
     using BusinessLogic.Services.SMSServices;
     using Shared.DomainDrivenDesign.EventSourcing;
@@ -19,21 +19,21 @@ namespace MessagingService.BusinessLogic.Tests.DomainEventHanders
 
     public class SMSDomainEventHandlerTests
     {
-        private Mock<IMediator> Mediator;
-        private Mock<ISMSServiceProxy> SMSServiceProxy;
+        private IMediatorImposter Mediator;
+        private ISMSServiceProxyImposter SMSServiceProxy;
         private SMSDomainEventHandler SMSDomainEventHandler;
         public SMSDomainEventHandlerTests()
         {
-            this.Mediator = new Mock<IMediator>();
-            this.SMSServiceProxy = new Mock<ISMSServiceProxy>();
+            this.Mediator = new IMediatorImposter();
+            this.SMSServiceProxy = new ISMSServiceProxyImposter();
             this.SMSDomainEventHandler =
-                new SMSDomainEventHandler(this.Mediator.Object, this.SMSServiceProxy.Object);
+                new SMSDomainEventHandler(this.Mediator.Instance(), this.SMSServiceProxy.Instance());
         }
 
         [Fact]
         public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Delivered_EventIsHandled()
         {
-            this.SMSServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.SMSServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<CancellationToken>.Any())
                              .ReturnsAsync(TestData.SMSMessageStatusResponseDelivered);
             
             await SMSDomainEventHandler.Handle(TestData.ResponseReceivedFromSMSProviderEvent, CancellationToken.None);
@@ -42,7 +42,7 @@ public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent
         [Fact]
         public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Expired_EventIsHandled()
         {
-            this.SMSServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.SMSServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<CancellationToken>.Any())
                            .ReturnsAsync(TestData.SMSMessageStatusResponseExpired);
             
             await SMSDomainEventHandler.Handle(TestData.ResponseReceivedFromSMSProviderEvent, CancellationToken.None);
@@ -51,7 +51,7 @@ public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent
         [Fact]
         public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Rejected_EventIsHandled()
         {
-            this.SMSServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.SMSServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<CancellationToken>.Any())
                            .ReturnsAsync(TestData.SMSMessageStatusResponseRejected);
 
             await SMSDomainEventHandler.Handle(TestData.ResponseReceivedFromSMSProviderEvent, CancellationToken.None);
@@ -60,7 +60,7 @@ public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent
         [Fact]
         public async Task SMSDomainEventHandler_Handle_ResponseReceivedFromProviderEvent_Undelivered_EventIsHandled()
         {
-            this.SMSServiceProxy.Setup(e => e.GetMessageStatus(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+            this.SMSServiceProxy.GetMessageStatus(Arg<String>.Any(), Arg<CancellationToken>.Any())
                            .ReturnsAsync(TestData.SMSMessageStatusResponseUndelivered);
 
             await this.SMSDomainEventHandler.Handle(TestData.ResponseReceivedFromSMSProviderEvent, CancellationToken.None);
diff --git a/MessagingService.BusinessLogic.Tests/ImposterDeclarations.cs b/MessagingService.BusinessLogic.Tests/ImposterDeclarations.cs
new file mode 100644
index 0000000..a7aee53
--- /dev/null
+++ b/MessagingService.BusinessLogic.Tests/ImposterDeclarations.cs
@@ -0,0 +1,13 @@
+using Imposter.Abstractions;
+using MediatR;
+using Microsoft.AspNetCore.Hosting;
+using MessagingService.BusinessLogic.Services.EmailServices;
+using MessagingService.BusinessLogic.Services.SMSServices;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+
+[assembly: GenerateImposter(typeof(IAggregateRepository<,>))]
+[assembly: GenerateImposter(typeof(IEmailServiceProxy))]
+[assembly: GenerateImposter(typeof(ISMSServiceProxy))]
+[assembly: GenerateImposter(typeof(IMediator))]
+[assembly: GenerateImposter(typeof(IWebHostEnvironment))]
diff --git a/MessagingService.BusinessLogic.Tests/Mediator/MediatorTests.cs b/MessagingService.BusinessLogic.Tests/Mediator/MediatorTests.cs
index b5b492a..557d5de 100644
--- a/MessagingService.BusinessLogic.Tests/Mediator/MediatorTests.cs
+++ b/MessagingService.BusinessLogic.Tests/Mediator/MediatorTests.cs
@@ -1,8 +1,8 @@
-using MediatR;
+using MediatR;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
-using Moq;
+using Imposter.Abstractions;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -34,16 +34,16 @@ public MediatorTests() {
 
         [Fact]
         public async Task Mediator_Send_RequestHandled() {
-            Mock<IWebHostEnvironment> hostingEnvironment = new();
-            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();
-            Startup s = new(hostingEnvironment.Object);
+            Startup s = new(hostingEnvironment.Instance());
             Startup.Configuration = this.SetupMemoryConfiguration();
 
-            this.AddTestRegistrations(services, hostingEnvironment.Object);
+            this.AddTestRegistrations(services, hostingEnvironment.Instance());
             s.ConfigureContainer(services);
             //Startup.Container.AssertConfigurationIsValid(AssertMode.Full);
 
diff --git a/MessagingService.BusinessLogic.Tests/MessagingService.BusinessLogic.Tests.csproj b/MessagingService.BusinessLogic.Tests/MessagingService.BusinessLogic.Tests.csproj
index bfb15e8..8156cb9 100644
--- a/MessagingService.BusinessLogic.Tests/MessagingService.BusinessLogic.Tests.csproj
+++ b/MessagingService.BusinessLogic.Tests/MessagingService.BusinessLogic.Tests.csproj
@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Lamar" />
-    <PackageReference Include="Moq" />
+    <PackageReference Include="Imposter" />
     <PackageReference Include="Microsoft.Testing.Extensions.TrxReport">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
diff --git a/MessagingService.BusinessLogic.Tests/Services/MessagingDomainServiceTests.cs b/MessagingService.BusinessLogic.Tests/Services/MessagingDomainServiceTests.cs
index 9962bc3..226e986 100644
--- a/MessagingService.BusinessLogic.Tests/Services/MessagingDomainServiceTests.cs
+++ b/MessagingService.BusinessLogic.Tests/Services/MessagingDomainServiceTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Text;
 using MessagingService.BusinessLogic.Requests;
@@ -12,7 +12,7 @@ namespace MessagingService.BusinessLogic.Tests.Services
     using BusinessLogic.Services.SMSServices;
     using EmailMessageAggregate;
     using Models;
-    using Moq;
+    using Imposter.Abstractions;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.EventStore.Aggregate;
     using Shouldly;
@@ -26,24 +26,24 @@ public class MessagingDomainServiceTests
         [Fact]
         public async Task MessagingDomainService_SendEmailMessage_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEmailAggregate());
-            emailAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<EmailAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptyEmailAggregate());
+            emailAggregateRepository.SaveChanges(Arg<EmailAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             var result  = await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
                                                           TestData.EmailAttachmentModels,
@@ -55,23 +55,23 @@ public async Task MessagingDomainService_SendEmailMessage_MessageSent()
         [Fact]
         public async Task MessagingDomainService_SendEmailMessage_SecondSend_MessageNotSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentEmailAggregate());
-            emailAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<EmailAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentEmailAggregate());
+            emailAggregateRepository.SaveChanges(Arg<EmailAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
-
-            MessagingDomainService messagingDomainService = new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
+
+            MessagingDomainService messagingDomainService = new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             var result = await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
                 TestData.EmailAttachmentModels,
@@ -82,24 +82,24 @@ public async Task MessagingDomainService_SendEmailMessage_SecondSend_MessageNotS
 
         [Fact] public async Task MessagingDomainService_SendEmailMessage_SaveFailed_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEmailAggregate());
-            emailAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<EmailAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptyEmailAggregate());
+            emailAggregateRepository.SaveChanges(Arg<EmailAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
                                                           TestData.EmailAttachmentModels,
@@ -109,23 +109,23 @@ await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
         [Fact]
         public async Task MessagingDomainService_SendEmailMessage_EmailSentFailed_APICallFailed_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptyEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedAPICallEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedAPICallEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
                                                           TestData.EmailAttachmentModels,
@@ -135,23 +135,23 @@ await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
         [Fact]
         public async Task MessagingDomainService_SendEmailMessage_EmailSentFailed_APIResponseError_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptyEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
                                                           TestData.EmailAttachmentModels,
@@ -161,23 +161,23 @@ await messagingDomainService.SendEmailMessage(TestData.SendEmailCommand,
         [Fact]
         public async Task MessagingDomainService_ResendEmailMessage_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new MessagingDomainService(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new MessagingDomainService(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
                                                           TestData.MessageId,
@@ -187,23 +187,23 @@ await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_ResendEmailMessage_APICallFailed_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedAPICallEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedAPICallEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
                                                             TestData.MessageId,
@@ -213,23 +213,23 @@ await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_ResendEmailMessage_APIResponseError_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
             emailServiceProxy
-                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<List<String>>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<Boolean>(),
-                                        It.IsAny<List<EmailAttachment>>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedEmailServiceProxyResponse);
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+                .SendEmail(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<List<String>>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<Boolean>.Any(),
+                                        Arg<List<EmailAttachment>>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedEmailServiceProxyResponse);
+            ISMSServiceProxyImposter smsServiceProxy = new();
 
             MessagingDomainService messagingDomainService =
-                new MessagingDomainService(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new MessagingDomainService(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
                                                             TestData.MessageId,
@@ -239,20 +239,20 @@ await messagingDomainService.ResendEmailMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_SendSMSMessage_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptySMSAggregate());
-            smsAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<SMSAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptySMSAggregate());
+            smsAggregateRepository.SaveChanges(Arg<SMSAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<String>(),
-                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
+                .SendSMS(Arg<Guid>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<String>.Any(),
+                                        Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             var result = await messagingDomainService.SendSMSMessage(TestData.ConnectionIdentifier,
                                                         TestData.MessageId,
@@ -268,20 +268,20 @@ public async Task MessagingDomainService_SendSMSMessage_MessageSent()
         [Fact]
         public async Task MessagingDomainService_SendSMSMessage_SecondTime_MessageNotSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentSMSAggregate());
-            smsAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<SMSAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentSMSAggregate());
+            smsAggregateRepository.SaveChanges(Arg<SMSAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Success());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                    It.IsAny<String>(),
-                    It.IsAny<String>(),
-                    It.IsAny<String>(),
-                    It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
+                .SendSMS(Arg<Guid>.Any(),
+                    Arg<String>.Any(),
+                    Arg<String>.Any(),
+                    Arg<String>.Any(),
+                    Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             var result = await messagingDomainService.SendSMSMessage(TestData.ConnectionIdentifier,
                 TestData.MessageId,
@@ -297,20 +297,20 @@ public async Task MessagingDomainService_SendSMSMessage_SecondTime_MessageNotSen
         [Fact]
         public async Task MessagingDomainService_SendSMSMessage_SaveFailed_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptySMSAggregate());
-            smsAggregateRepository.Setup(a => a.SaveChanges(It.IsAny<SMSAggregate>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure);
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetEmptySMSAggregate());
+            smsAggregateRepository.SaveChanges(Arg<SMSAggregate>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(Result.Failure());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                    It.IsAny<String>(),
-                    It.IsAny<String>(),
-                    It.IsAny<String>(),
-                    It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
+                .SendSMS(Arg<Guid>.Any(),
+                    Arg<String>.Any(),
+                    Arg<String>.Any(),
+                    Arg<String>.Any(),
+                    Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.SendSMSMessage(TestData.ConnectionIdentifier,
                 TestData.MessageId,
@@ -323,19 +323,19 @@ await messagingDomainService.SendSMSMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_ReSendSMSMessage_MessageSent()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentSMSAggregate());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentSMSAggregate());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
+                .SendSMS(Arg<Guid>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<CancellationToken>.Any()).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
                                                         TestData.MessageId,
@@ -345,19 +345,19 @@ await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_ReSendSMSMessage_APICallFailed_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentSMSAggregate());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentSMSAggregate());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedAPICallSMSServiceProxyResponse);
+                .SendSMS(Arg<Guid>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedAPICallSMSServiceProxyResponse);
             MessagingDomainService messagingDomainService =
-                new MessagingDomainService(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new MessagingDomainService(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
                                                           TestData.MessageId,
@@ -367,18 +367,18 @@ await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
         [Fact]
         public async Task MessagingDomainService_ReSendSMSMessage_APIResponseError_MessageFailed()
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentSMSAggregate());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentSMSAggregate());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             smsServiceProxy
-                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<String>(),
-                                      It.IsAny<CancellationToken>())).ReturnsAsync(TestData.FailedSMSServiceProxyResponse);
-            MessagingDomainService messagingDomainService = new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                .SendSMS(Arg<Guid>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<String>.Any(),
+                                      Arg<CancellationToken>.Any()).ReturnsAsync(TestData.FailedSMSServiceProxyResponse);
+            MessagingDomainService messagingDomainService = new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
                                                           TestData.MessageId,
@@ -395,13 +395,13 @@ await messagingDomainService.ResendSMSMessage(TestData.ConnectionIdentifier,
         [InlineData(BusinessLogic.Services.SMSServices.MessageStatus.Incoming)]
         public async Task MessagingDomainService_UpdateSMSMessageStatus_MessageUpdated(BusinessLogic.Services.SMSServices.MessageStatus status)
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentSMSAggregate());
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            smsAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentSMSAggregate());
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             SMSCommands.UpdateMessageStatusCommand command = new(TestData.MessageId, status, TestData.ProviderStatusDescription, TestData.BouncedDateTime);
             Should.NotThrow(async () => await messagingDomainService.UpdateMessageStatus(command, CancellationToken.None));
@@ -416,13 +416,13 @@ public async Task MessagingDomainService_UpdateSMSMessageStatus_MessageUpdated(B
 
         public async Task MessagingDomainService_UpdateEmailMessageStatus_MessageUpdated(BusinessLogic.Services.EmailServices.MessageStatus status)
         {
-            Mock<IAggregateRepository<EmailAggregate, DomainEvent>> emailAggregateRepository = new();
-            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetSentEmailAggregate());
-            Mock<IAggregateRepository<SMSAggregate, DomainEvent>> smsAggregateRepository = new();
-            Mock<IEmailServiceProxy> emailServiceProxy = new();
-            Mock<ISMSServiceProxy> smsServiceProxy = new();
+            IAggregateRepositoryImposter<EmailAggregate, DomainEvent> emailAggregateRepository = new();
+            emailAggregateRepository.GetLatestVersion(Arg<Guid>.Any(), Arg<CancellationToken>.Any()).ReturnsAsync(TestData.GetSentEmailAggregate());
+            IAggregateRepositoryImposter<SMSAggregate, DomainEvent> smsAggregateRepository = new();
+            IEmailServiceProxyImposter emailServiceProxy = new();
+            ISMSServiceProxyImposter smsServiceProxy = new();
             MessagingDomainService messagingDomainService =
-                new(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+                new(emailAggregateRepository.Instance(), smsAggregateRepository.Instance(), emailServiceProxy.Instance(), smsServiceProxy.Instance());
 
             EmailCommands.UpdateMessageStatusCommand command = new(TestData.MessageId, status, TestData.ProviderStatusDescription, TestData.BouncedDateTime);
             Should.NotThrow(async () => {
diff --git a/MessagingService.Tests/MessagingService.Tests.csproj b/MessagingService.Tests/MessagingService.Tests.csproj
index a8470e0..225be49 100644
--- a/MessagingService.Tests/MessagingService.Tests.csproj
+++ b/MessagingService.Tests/MessagingService.Tests.csproj
@@ -12,7 +12,6 @@
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Core" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
-    <PackageReference Include="Moq" />
     <PackageReference Include="Shouldly" />
     <PackageReference Include="xunit.v3.mtp-v2" />
     <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage">