merchant aggregate moved over

TransactionProcessor.Aggregates.Tests/EstateAggregateTests.cs

@@ -95,7 +95,7 @@ public void EstateAggregate_GetEstate_WithAnOperator_EstateIsReturned()
             model.Reference.ShouldBe(TestData.EstateReference);
             model.Operators.ShouldHaveSingleItem();
 
-            Models.Estate.Operator? @operator =model.Operators.Single();
+            TransactionProcessor.Models.Estate.Operator? @operator =model.Operators.Single();
             @operator.OperatorId.ShouldBe(TestData.OperatorId);
         }
 

TransactionProcessor.Aggregates.Tests/OperatorAggregateTests.cs

@@ -43,7 +43,7 @@ public void OperatorAggregate_GetOperator_OperatorIsReturned()
         {
             OperatorAggregate aggregate = OperatorAggregate.Create(TestData.OperatorId);
             aggregate.Create(TestData.EstateId, TestData.OperatorName, TestData.RequireCustomMerchantNumber, TestData.RequireCustomTerminalNumber);
-            Models.Operator.Operator @operator = aggregate.GetOperator();
+            TransactionProcessor.Models.Operator.Operator @operator = aggregate.GetOperator();
             @operator.OperatorId.ShouldBe(TestData.OperatorId);
             @operator.Name.ShouldBe(TestData.OperatorName);
             @operator.RequireCustomTerminalNumber.ShouldBe(TestData.RequireCustomTerminalNumber);

TransactionProcessor.Aggregates.Tests/TransactionProcessor.Aggregates.Tests.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-	<DebugType>None</DebugType>
+	<DebugType>Full</DebugType>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>

TransactionProcessor.Aggregates/Models/Address.cs

@@ -0,0 +1,4 @@
+namespace TransactionProcessor.Aggregates.Models
+{
+    internal record Address(String AddressLine1, String AddressLine2, String AddressLine3, String AddressLine4, String Town, String Region, String PostalCode, String Country);
+}

TransactionProcessor.Aggregates/Models/Contact.cs

@@ -0,0 +1,4 @@
+namespace TransactionProcessor.Aggregates.Models
+{
+    internal record Contact(String ContactEmailAddress, String ContactName, String ContactPhoneNumber);
+}

TransactionProcessor.Aggregates/Models/Contract.cs

@@ -0,0 +1,15 @@
+namespace TransactionProcessor.Aggregates.Models;
+
+internal record Contract
+{
+    public Contract(Guid ContractId, Boolean IsDeleted = false)
+    {
+        this.ContractId = ContractId;
+        this.IsDeleted = IsDeleted;
+        this.ContractProducts = new List<Guid>();
+    }
+
+    public List<Guid> ContractProducts { get; init; }
+    public Guid ContractId { get; init; }
+    public Boolean IsDeleted { get; init; }
+}

TransactionProcessor.Aggregates/Models/Device.cs

@@ -0,0 +1,3 @@
+namespace TransactionProcessor.Aggregates.Models;
+
+internal record Device(Guid DeviceId, String DeviceIdentifier, Boolean IsEnabled = true);

TransactionProcessor.Aggregates/Models/Operator.cs

@@ -0,0 +1,4 @@
+namespace TransactionProcessor.Aggregates.Models
+{
+    internal record Operator(Guid OperatorId, String Name, String MerchantNumber, String TerminalNumber, Boolean IsDeleted = false);
+}

TransactionProcessor.Aggregates/Models/SecurityUser.cs

@@ -0,0 +1,4 @@
+namespace TransactionProcessor.Aggregates.Models
+{
+    internal record SecurityUser(Guid SecurityUserId, String EmailAddress);
+}

TransactionProcessor.Aggregates/OperatorAggregate.cs

@@ -13,8 +13,8 @@ namespace TransactionProcessor.Aggregates
 {
     public static class OperatorAggregateExtensions
     {
-        public static Models.Operator.Operator GetOperator(this OperatorAggregate aggregate) {
-            return new Models.Operator.Operator() { Name = aggregate.Name, OperatorId = aggregate.AggregateId, RequireCustomMerchantNumber = aggregate.RequireCustomMerchantNumber, RequireCustomTerminalNumber = aggregate.RequireCustomTerminalNumber };
+        public static TransactionProcessor.Models.Operator.Operator GetOperator(this OperatorAggregate aggregate) {
+            return new TransactionProcessor.Models.Operator.Operator() { Name = aggregate.Name, OperatorId = aggregate.AggregateId, RequireCustomMerchantNumber = aggregate.RequireCustomMerchantNumber, RequireCustomTerminalNumber = aggregate.RequireCustomTerminalNumber };
         }
 
         public static void PlayEvent(this OperatorAggregate aggregate, OperatorDomainEvents.OperatorCreatedEvent domainEvent)

TransactionProcessor.Aggregates/TransactionAggregate.cs

@@ -1,4 +1,5 @@
 using TransactionProcessor.DomainEvents;
+using TransactionProcessor.Models;
 using TransactionProcessor.Models.Contract;
 
 namespace TransactionProcessor.Aggregates

TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantDomainEventHandlerTests.cs

@@ -0,0 +1,279 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using Moq;
+using Shared.DomainDrivenDesign.EventSourcing;
+using Shared.EventStore.Aggregate;
+using Shared.Logger;
+using Shouldly;
+using SimpleResults;
+using TransactionProcessor.Aggregates;
+using TransactionProcessor.BusinessLogic.EventHandling;
+using TransactionProcessor.BusinessLogic.Requests;
+using TransactionProcessor.DomainEvents;
+using TransactionProcessor.Repository;
+using TransactionProcessor.Testing;
+using Xunit;
+
+namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers
+{
+    public class MerchantDomainEventHandlerTests
+    {
+        private Mock<IAggregateRepository<MerchantAggregate, DomainEvent>> MerchantAggregateRepository;
+        private Mock<ITransactionProcessorReadModelRepository> EstateManagementRepository;
+        private Mock<IMediator> Mediator;
+
+        private MerchantDomainEventHandler DomainEventHandler;
+
+        public MerchantDomainEventHandlerTests() {
+            Logger.Initialise(NullLogger.Instance);
+
+            this.Mediator = new Mock<IMediator>();
+            this.MerchantAggregateRepository = new Mock<IAggregateRepository<MerchantAggregate, DomainEvent>>();
+            this.EstateManagementRepository = new Mock<ITransactionProcessorReadModelRepository>();
+
+            this.DomainEventHandler = new MerchantDomainEventHandler(this.MerchantAggregateRepository.Object,
+                                                                                           this.EstateManagementRepository.Object,
+                                                                                           this.Mediator.Object);
+        }
+
+        //[Fact]
+        //public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEvent_Deposit_EventIsHandled()
+        //{
+        //    this.EstateManagementRepository.Setup(e => e.GetMerchantFromReference(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        //                              .ReturnsAsync(Result.Success(TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts()));
+        //    this.Mediator.Setup(m => m.Send(It.IsAny<MerchantCommands.MakeMerchantDepositCommand>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
+        //    CallbackReceivedEnrichedEvent domainEvent = TestData.CallbackReceivedEnrichedEventDeposit;
+
+        //    var result = await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None);
+        //    result.IsSuccess.ShouldBeTrue();
+
+        //}
+
+        //[Fact]
+        //public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEvent_OtherType_EventIsHandled()
+        //{
+        //    this.EstateManagementRepository.Setup(e => e.GetMerchantFromReference(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        //        .ReturnsAsync(TestData.MerchantModelWithAddressesContactsDevicesAndOperatorsAndContracts());
+
+        //    CallbackReceivedEnrichedEvent domainEvent = TestData.CallbackReceivedEnrichedEventOtherType;
+
+        //    var result = await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None);
+        //    result.IsSuccess.ShouldBeTrue();
+        //}
+
+        //[Fact]
+        //public async Task MerchantDomainEventHandler_Handle_CallbackReceivedEnrichedEvent_Deposit_GetMerchantFailed_ResultIsFailure()
+        //{
+        //    this.EstateManagementRepository.Setup(e => e.GetMerchantFromReference(It.IsAny<Guid>(), It.IsAny<String>(), It.IsAny<CancellationToken>()))
+        //        .ReturnsAsync(Result.Failure());
+
+        //    CallbackReceivedEnrichedEvent domainEvent = TestData.CallbackReceivedEnrichedEventDeposit;
+
+        //    var result = await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None);
+        //    result.IsFailed.ShouldBeTrue();
+
+        //}
+
+        #region Methods
+
+        [Fact]
+        public void MerchantDomainEventHandler_AddressAddedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.AddressAddedEvent addressAddedEvent = TestData.DomainEvents.AddressAddedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(addressAddedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_ContactAddedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.ContactAddedEvent contactAddedEvent = TestData.DomainEvents.ContactAddedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(contactAddedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantReferenceAllocatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantReferenceAllocatedEvent merchantReferenceAllocatedEvent = TestData.DomainEvents.MerchantReferenceAllocatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(merchantReferenceAllocatedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_DeviceAddedToMerchantEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.DeviceAddedToMerchantEvent deviceAddedToMerchantEvent = TestData.DomainEvents.DeviceAddedToMerchantEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(deviceAddedToMerchantEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantCreatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantCreatedEvent merchantCreatedEvent = TestData.DomainEvents.MerchantCreatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(merchantCreatedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_OperatorAssignedToMerchantEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.OperatorAssignedToMerchantEvent operatorAssignedToMerchantEvent = TestData.DomainEvents.OperatorAssignedToMerchantEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(operatorAssignedToMerchantEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_SecurityUserAddedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.SecurityUserAddedToMerchantEvent merchantSecurityUserAddedEvent = TestData.DomainEvents.MerchantSecurityUserAddedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(merchantSecurityUserAddedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_SettlementScheduleChangedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.SettlementScheduleChangedEvent settlementScheduleChangedEvent = TestData.DomainEvents.SettlementScheduleChangedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(settlementScheduleChangedEvent, CancellationToken.None); });
+        }
+
+        [Fact(Skip = "No event yet")]
+        public void MerchantDomainEventHandler_SettlementGeneratedEvent_EventIsHandled()
+        {
+            //StatementGeneratedEvent statementGeneratedEvent = TestData.StatementGeneratedEvent;
+
+            //Should.NotThrow(async () => { await this.DomainEventHandler.Handle(statementGeneratedEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_TransactionHasBeenCompletedEvent_EventIsHandled()
+        {
+            TransactionDomainEvents.TransactionHasBeenCompletedEvent domainEvent = TestData.TransactionHasBeenCompletedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantNameUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantNameUpdatedEvent domainEvent = TestData.DomainEvents.MerchantNameUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_DeviceSwappedForMerchantEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.DeviceSwappedForMerchantEvent domainEvent = TestData.DomainEvents.DeviceSwappedForMerchantEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_OperatorRemovedFromMerchantEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.OperatorRemovedFromMerchantEvent domainEvent = TestData.DomainEvents.OperatorRemovedFromMerchantEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantAddressLine1UpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantAddressLine1UpdatedEvent domainEvent = TestData.DomainEvents.MerchantAddressLine1UpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantAddressLine2UpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantAddressLine2UpdatedEvent domainEvent = TestData.DomainEvents.MerchantAddressLine2UpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantAddressLine3UpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantAddressLine3UpdatedEvent domainEvent = TestData.DomainEvents.MerchantAddressLine3UpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantAddressLine4UpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantAddressLine4UpdatedEvent domainEvent = TestData.DomainEvents.MerchantAddressLine4UpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantCountyUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantCountyUpdatedEvent domainEvent = TestData.DomainEvents.MerchantCountyUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantRegionUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantRegionUpdatedEvent domainEvent = TestData.DomainEvents.MerchantRegionUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantTownUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantTownUpdatedEvent domainEvent = TestData.DomainEvents.MerchantTownUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantPostalCodeUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantPostalCodeUpdatedEvent domainEvent = TestData.DomainEvents.MerchantPostalCodeUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantContactNameUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantContactNameUpdatedEvent domainEvent = TestData.DomainEvents.MerchantContactNameUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantContactEmailAddressUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantContactEmailAddressUpdatedEvent domainEvent = TestData.DomainEvents.MerchantContactEmailAddressUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+        [Fact]
+        public void MerchantDomainEventHandler_MerchantContactPhoneNumberUpdatedEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.MerchantContactPhoneNumberUpdatedEvent domainEvent = TestData.DomainEvents.MerchantContactPhoneNumberUpdatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_ContractAddedToMerchantEvent_EventIsHandled()
+        {
+            MerchantDomainEvents.ContractAddedToMerchantEvent domainEvent = TestData.DomainEvents.ContractAddedToMerchantEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+
+        [Fact]
+        public void MerchantDomainEventHandler_EstateCreatedEvent_EventIsHandled()
+        {
+            EstateDomainEvents.EstateCreatedEvent domainEvent = TestData.DomainEvents.EstateCreatedEvent;
+
+            Should.NotThrow(async () => { await this.DomainEventHandler.Handle(domainEvent, CancellationToken.None); });
+        }
+
+        #endregion
+    }
+}

TransactionProcessor.BusinessLogic.Tests/Manager/EstateManagementManagerTests.cs

@@ -26,7 +26,7 @@ public class EstateManagementManagerTests
         private readonly Mock<ITransactionProcessorReadModelRepository> EstateManagementRepository;
         private readonly Mock<IAggregateRepository<EstateAggregate, DomainEvent>> EstateAggregateRepository;
         private readonly Mock<IAggregateRepository<ContractAggregate, DomainEvent>> ContractAggregateRepository;
-        //private readonly Mock<IAggregateRepository<MerchantAggregate, DomainEvent>> MerchantAggregateRepository;
+        private readonly Mock<IAggregateRepository<MerchantAggregate, DomainEvent>> MerchantAggregateRepository;
         private readonly Mock<IAggregateRepository<OperatorAggregate, DomainEvent>> OperatorAggregateRepository;
 
         private readonly EstateManagementManager EstateManagementManager;
@@ -37,12 +37,12 @@ public EstateManagementManagerTests()
 
             this.EstateAggregateRepository = new Mock<IAggregateRepository<EstateAggregate, DomainEvent>>();
             this.ContractAggregateRepository = new Mock<IAggregateRepository<ContractAggregate, DomainEvent>>();
-            //this.MerchantAggregateRepository = new Mock<IAggregateRepository<MerchantAggregate, DomainEvent>>();
+            this.MerchantAggregateRepository = new Mock<IAggregateRepository<MerchantAggregate, DomainEvent>>();
             this.OperatorAggregateRepository = new Mock<IAggregateRepository<OperatorAggregate, DomainEvent>>();
 
             this.EstateManagementManager = new EstateManagementManager(this.EstateManagementRepository.Object, this.EstateAggregateRepository.Object,
             this.ContractAggregateRepository.Object,
-            //this.MerchantAggregateRepository.Object,
+            this.MerchantAggregateRepository.Object,
             this.OperatorAggregateRepository.Object);
         }