make calls in repo idempodent

TransactionProcessor.Database/Contexts/EstateManagementGenericContext.cs

@@ -665,7 +665,7 @@ public static class DomainEventHelper
 
     public static Guid GetContractProductId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "ProductId");
 
-    public static Guid GetContractProductTransactionFeeId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "FeeId");
+    public static Guid GetContractProductTransactionFeeId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "TransactionFeeId");
 
     public static Guid GetEstateId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "EstateId");
     public static Guid GetOperatorId(IDomainEvent domainEvent) => DomainEventHelper.GetProperty<Guid>(domainEvent, "OperatorId");

TransactionProcessor.DatabaseTests/ContractEventTests.cs

@@ -46,13 +46,64 @@ public async Task AddContract_ContractIsAdded()
         }
 
         [Fact]
-        public async Task AddContract_EventReplayHandled() {
-            Result result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
-            result.IsSuccess.ShouldBeTrue();
+    public async Task AddContract_EventReplayHandled() {
+        Result result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
 
-            result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
-            result.IsSuccess.ShouldBeTrue();
-        }
+        result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task AddContractToMerchant_ContractIsAddedToMerchant()
+    {
+        Result result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        result = await this.Repository.AddContractToMerchant(TestData.DomainEvents.ContractAddedToMerchantEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        MerchantContract? merchantContract = await context.MerchantContracts.SingleOrDefaultAsync(c => c.MerchantId == TestData.DomainEvents.ContractAddedToMerchantEvent.MerchantId && c.ContractId == TestData.DomainEvents.ContractAddedToMerchantEvent.ContractId);
+        merchantContract.ShouldNotBeNull();
+        merchantContract.IsDeleted.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task RemoveContractFromMerchant_ContractIsMarkedDeleted()
+    {
+        Result result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+        result = await this.Repository.AddContractToMerchant(TestData.DomainEvents.ContractAddedToMerchantEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        result = await this.Repository.RemoveContractFromMerchant(TestData.DomainEvents.ContractRemovedFromMerchantEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        MerchantContract? merchantContract = await context.MerchantContracts.SingleOrDefaultAsync(c => c.MerchantId == TestData.DomainEvents.ContractRemovedFromMerchantEvent.MerchantId && c.ContractId == TestData.DomainEvents.ContractRemovedFromMerchantEvent.ContractId);
+        merchantContract.ShouldNotBeNull();
+        merchantContract.IsDeleted.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task DisableContractProductTransactionFee_TransactionFeeIsDisabled()
+    {
+        Result result = await this.Repository.AddContract(TestData.DomainEvents.ContractCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue("Add");
+        result = await this.Repository.AddContractProduct(TestData.DomainEvents.FixedValueProductAddedToContractEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue("Product Add");
+        result = await this.Repository.AddContractProductTransactionFee(TestData.DomainEvents.TransactionFeeForProductAddedToContractEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue("Fee Add");
+
+        result = await this.Repository.DisableContractProductTransactionFee(TestData.DomainEvents.TransactionFeeForProductDisabledEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue(result.Message);
+
+        EstateManagementContext context = this.GetContext();
+        ContractProductTransactionFee? contractProductTransactionFee = await context.ContractProductTransactionFees.SingleOrDefaultAsync(c => c.ContractProductTransactionFeeId == TestData.DomainEvents.TransactionFeeForProductDisabledEvent.TransactionFeeId);
+        contractProductTransactionFee.ShouldNotBeNull();
+        contractProductTransactionFee.IsEnabled.ShouldBeFalse();
+    }
 
         [Fact]
         public async Task AddContractProduct_ContractProductIsAdded()

TransactionProcessor.DatabaseTests/EstateEventTests.cs

@@ -1,11 +1,31 @@
 using Microsoft.EntityFrameworkCore;
+using Shared.Logger;
 using Shouldly;
 using SimpleResults;
 using TransactionProcessor.Database.Contexts;
 using TransactionProcessor.Testing;
 
 namespace TransactionProcessor.DatabaseTests;
 
+public class MigrationTests : BaseTest {
+    public override async ValueTask InitializeAsync() {
+
+        Logger.Initialise(new Shared.Logger.NullLogger());
+
+        this.TestId = Guid.NewGuid();
+
+        await this.StartSqlContainer();
+        await this.GetRepository();
+    }
+
+    [Fact]
+    public async Task CreateReadModel_EstateDatabaseIsMigrated()
+    {
+        Result result = await this.Repository.CreateReadModel(TestData.DomainEvents.EstateCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+}
+
 public class EstateEventTests : BaseTest {
     [Fact]
     public async Task AddEstate_EstateIsAdded()
@@ -15,6 +35,7 @@ public async Task AddEstate_EstateIsAdded()
         EstateManagementContext context = this.GetContext();
         var estate = await context.Estates.SingleOrDefaultAsync(f => f.EstateId == TestData.DomainEvents.EstateCreatedEvent.EstateId);
         estate.ShouldNotBeNull();
+        estate.Name.ShouldBe(TestData.DomainEvents.EstateCreatedEvent.EstateName);
     }
 
     [Fact]
@@ -46,4 +67,19 @@ public async Task AddEstateSecurityUser_EventReplayHandled()
         result = await this.Repository.AddEstateSecurityUser(TestData.DomainEvents.EstateSecurityUserAddedEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
-}
+
+    [Fact]
+    public async Task UpdateEstate_EstateReferenceIsUpdated()
+    {
+        Result result = await this.Repository.AddEstate(TestData.DomainEvents.EstateCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        result = await this.Repository.UpdateEstate(TestData.DomainEvents.EstateReferenceAllocatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        var estate = await context.Estates.SingleOrDefaultAsync(f => f.EstateId == TestData.DomainEvents.EstateReferenceAllocatedEvent.EstateId);
+        estate.ShouldNotBeNull();
+        estate.Reference.ShouldBe(TestData.DomainEvents.EstateReferenceAllocatedEvent.EstateReference);
+    }
+}

TransactionProcessor.DatabaseTests/FileImportLogEventTests.cs

@@ -1,12 +1,35 @@
-using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
 using Shouldly;
 using SimpleResults;
 using TransactionProcessor.Database.Contexts;
+using TransactionProcessor.Database.Entities;
 using TransactionProcessor.Testing;
 
 namespace TransactionProcessor.DatabaseTests;
 
 public class FileImportLogEventTests : BaseTest {
+    private async Task CreateFileImportLogAsync()
+    {
+        Result result = await this.Repository.AddFileImportLog(TestData.DomainEvents.ImportLogCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    private async Task CreateFileAsync()
+    {
+        await this.CreateFileImportLogAsync();
+
+        Result result = await this.Repository.AddFile(TestData.DomainEvents.FileCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    private async Task CreateFileLineAsync()
+    {
+        await this.CreateFileAsync();
+
+        Result result = await this.Repository.AddFileLineToFile(TestData.DomainEvents.FileLineAddedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
     [Fact]
     public async Task AddFileImportLog_FileImportLogIsAdded()
     {
@@ -15,6 +38,8 @@ public async Task AddFileImportLog_FileImportLogIsAdded()
         EstateManagementContext context = this.GetContext();
         var fileImportLog = await context.FileImportLogs.SingleOrDefaultAsync(f => f.FileImportLogId == TestData.DomainEvents.ImportLogCreatedEvent.FileImportLogId);
         fileImportLog.ShouldNotBeNull();
+        fileImportLog.EstateId.ShouldBe(TestData.DomainEvents.ImportLogCreatedEvent.EstateId);
+        fileImportLog.ImportLogDate.ShouldBe(TestData.DomainEvents.ImportLogCreatedEvent.ImportLogDateTime.Date);
     }
 
     [Fact]
@@ -35,6 +60,8 @@ public async Task AddFileImportLogFile_FileImportLogIsAdded()
         EstateManagementContext context = this.GetContext();
         var fileImportLogFile = await context.FileImportLogFiles.SingleOrDefaultAsync(f => f.FileImportLogId == TestData.DomainEvents.FileAddedToImportLogEvent.FileImportLogId && f.FileId == TestData.DomainEvents.FileAddedToImportLogEvent.FileId);
         fileImportLogFile.ShouldNotBeNull();
+        fileImportLogFile.FilePath.ShouldBe(TestData.DomainEvents.FileAddedToImportLogEvent.FilePath);
+        fileImportLogFile.OriginalFileName.ShouldBe(TestData.DomainEvents.FileAddedToImportLogEvent.OriginalFileName);
     }
 
     [Fact]
@@ -46,4 +73,118 @@ public async Task AddFileImportLogFile_EventReplayHandled()
         result = await this.Repository.AddFileToImportLog(TestData.DomainEvents.FileAddedToImportLogEvent, CancellationToken.None);
         result.IsSuccess.ShouldBeTrue();
     }
-}
+
+    [Fact]
+    public async Task AddFile_FileIsAdded()
+    {
+        await this.CreateFileImportLogAsync();
+
+        Result result = await this.Repository.AddFile(TestData.DomainEvents.FileCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        TransactionProcessor.Database.Entities.File? file = await context.Files.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileCreatedEvent.FileId);
+        file.ShouldNotBeNull();
+        file.EstateId.ShouldBe(TestData.DomainEvents.FileCreatedEvent.EstateId);
+        file.MerchantId.ShouldBe(TestData.DomainEvents.FileCreatedEvent.MerchantId);
+        file.FileLocation.ShouldBe(TestData.DomainEvents.FileCreatedEvent.FileLocation);
+        file.FileReceivedDate.ShouldBe(TestData.DomainEvents.FileCreatedEvent.FileReceivedDateTime.Date);
+        file.IsCompleted.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task AddFile_EventReplayHandled()
+    {
+        await this.CreateFileImportLogAsync();
+
+        Result result = await this.Repository.AddFile(TestData.DomainEvents.FileCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+        result = await this.Repository.AddFile(TestData.DomainEvents.FileCreatedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task AddFileLineToFile_FileLineIsAdded()
+    {
+        await this.CreateFileAsync();
+
+        Result result = await this.Repository.AddFileLineToFile(TestData.DomainEvents.FileLineAddedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        FileLine? fileLine = await context.FileLines.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileLineAddedEvent.FileId && f.LineNumber == TestData.DomainEvents.FileLineAddedEvent.LineNumber);
+        fileLine.ShouldNotBeNull();
+        fileLine.FileLineData.ShouldBe(TestData.DomainEvents.FileLineAddedEvent.FileLine);
+        fileLine.Status.ShouldBe("P");
+    }
+
+    [Fact]
+    public async Task AddFileLineToFile_EventReplayHandled()
+    {
+        await this.CreateFileAsync();
+
+        Result result = await this.Repository.AddFileLineToFile(TestData.DomainEvents.FileLineAddedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+        result = await this.Repository.AddFileLineToFile(TestData.DomainEvents.FileLineAddedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task UpdateFileAsComplete_FileIsCompleted()
+    {
+        await this.CreateFileAsync();
+
+        Result result = await this.Repository.UpdateFileAsComplete(TestData.DomainEvents.FileProcessingCompletedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        TransactionProcessor.Database.Entities.File? file = await context.Files.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileProcessingCompletedEvent.FileId);
+        file.ShouldNotBeNull();
+        file.IsCompleted.ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task UpdateFileLineSuccessful_FileLineIsUpdated()
+    {
+        await this.CreateFileLineAsync();
+
+        Result result = await this.Repository.UpdateFileLine(TestData.DomainEvents.FileLineProcessingSuccessfulEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        FileLine? fileLine = await context.FileLines.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileLineProcessingSuccessfulEvent.FileId && f.LineNumber == TestData.DomainEvents.FileLineProcessingSuccessfulEvent.LineNumber);
+        fileLine.ShouldNotBeNull();
+        fileLine.Status.ShouldBe("S");
+        fileLine.TransactionId.ShouldBe(TestData.DomainEvents.FileLineProcessingSuccessfulEvent.TransactionId);
+    }
+
+    [Fact]
+    public async Task UpdateFileLineFailed_FileLineIsUpdated()
+    {
+        await this.CreateFileLineAsync();
+
+        Result result = await this.Repository.UpdateFileLine(TestData.DomainEvents.FileLineProcessingFailedEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        FileLine? fileLine = await context.FileLines.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileLineProcessingFailedEvent.FileId && f.LineNumber == TestData.DomainEvents.FileLineProcessingFailedEvent.LineNumber);
+        fileLine.ShouldNotBeNull();
+        fileLine.Status.ShouldBe("F");
+        fileLine.TransactionId.ShouldBe(TestData.DomainEvents.FileLineProcessingFailedEvent.TransactionId);
+    }
+
+    [Fact]
+    public async Task UpdateFileLineIgnored_FileLineIsUpdated()
+    {
+        await this.CreateFileLineAsync();
+
+        Result result = await this.Repository.UpdateFileLine(TestData.DomainEvents.FileLineProcessingIgnoredEvent, CancellationToken.None);
+        result.IsSuccess.ShouldBeTrue();
+
+        EstateManagementContext context = this.GetContext();
+        FileLine? fileLine = await context.FileLines.SingleOrDefaultAsync(f => f.FileId == TestData.DomainEvents.FileLineProcessingIgnoredEvent.FileId && f.LineNumber == TestData.DomainEvents.FileLineProcessingIgnoredEvent.LineNumber);
+        fileLine.ShouldNotBeNull();
+        fileLine.Status.ShouldBe("I");
+        fileLine.TransactionId.ShouldBe(Guid.Empty);
+    }
+}