Merge pull request #746 from TransactionProcessing/task/#725_merchant_domain)event_hander_retry

Task/#725 merchant domain)event hander retry

Author: StuartFerguson

TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantSettlementDomainEventHandlerTests.cs

@@ -45,8 +45,8 @@ public async Task MerchantSettlementDomainEventHandler_Handle_MerchantFeeSettled
         public async Task MerchantSettlementDomainEventHandler_Handle_MerchantFeeSettledEvent_Retry_EventIsHandled()
         {
             this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-                .ThrowsAsync(new WrongExpectedVersionException("Stream1", StreamRevision.None, StreamRevision.None))
-                .ThrowsAsync(new RpcException(new Status(StatusCode.DeadlineExceeded, "Deadline Exceeded")))
+                .ReturnsAsync(Result.Failure(new List<String>() { "Append failed due to WrongExpectedVersion"}))
+                .ReturnsAsync(Result.Failure(new List<String>() { "DeadlineExceeded"}))
                 .ReturnsAsync(Result.Success());                       
 
             Result result = await this.EventHandler.Handle(TestData.DomainEvents.MerchantFeeSettledEvent, CancellationToken.None);

TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/MerchantStatementDomainEventHandlerTests.cs

@@ -1,4 +1,6 @@
-using System.Threading;
+using System;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using EventStore.Client;
 using Grpc.Core;
@@ -36,8 +38,8 @@ public async Task MerchantStatementDomainEventHandler_Handle_StatementGeneratedE
     public async Task MerchantStatementDomainEventHandler_Handle_StatementGeneratedEvent_Retry_EventIsHandled()
     {
         this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-            .ThrowsAsync(new WrongExpectedVersionException("Stream1", StreamRevision.None, StreamRevision.None))
-            .ThrowsAsync(new RpcException(new Status(StatusCode.DeadlineExceeded, "Deadline Exceeded")))
+            .ReturnsAsync(Result.Failure(new List<String>() { "Append failed due to WrongExpectedVersion" }))
+            .ReturnsAsync(Result.Failure(new List<String>() { "DeadlineExceeded" }))
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.StatementGeneratedEvent, CancellationToken.None);
@@ -58,8 +60,8 @@ public async Task MerchantStatementDomainEventHandler_Handle_TransactionHasBeenC
     public async Task MerchantStatementDomainEventHandler_Handle_TransactionHasBeenCompletedEvent_Retry_EventIsHandled()
     {
         this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-            .ThrowsAsync(new WrongExpectedVersionException("Stream1", StreamRevision.None, StreamRevision.None))
-            .ThrowsAsync(new RpcException(new Status(StatusCode.DeadlineExceeded, "Deadline Exceeded")))
+            .ReturnsAsync(Result.Failure(new List<String>() { "Append failed due to WrongExpectedVersion" }))
+            .ReturnsAsync(Result.Failure(new List<String>() { "DeadlineExceeded" }))
             .ReturnsAsync(Result.Success());
 
         Result result = await this.EventHandler.Handle(TestData.DomainEvents.TransactionHasBeenCompletedEvent, CancellationToken.None);

TransactionProcessor.BusinessLogic.Tests/DomainEventHandlers/TransactionDomainEventHandlerTests.cs

@@ -7,16 +7,17 @@
 
 namespace TransactionProcessor.BusinessLogic.Tests.DomainEventHandlers
 {
-    using System;
-    using System.Threading;
-    using System.Threading.Tasks;
     using EventHandling;
     using Microsoft.Extensions.Configuration;
     using Moq;
     using Shared.DomainDrivenDesign.EventSourcing;
     using Shared.General;
     using Shared.Logger;
     using Shouldly;
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
     using Testing;
     using Xunit;
 
@@ -139,8 +140,8 @@ public async Task TransactionDomainEventHandler_EventPassedIn_EventIsHandled(Typ
         public async Task TransactionDomainEventHandler_EventPassedIn_Retry_EventIsHandled(Type eventType)
         {
             this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-                .ThrowsAsync(new WrongExpectedVersionException("Stream1", StreamRevision.None, StreamRevision.None))
-                .ThrowsAsync(new RpcException(new Status(StatusCode.DeadlineExceeded, "Deadline Exceeded")))
+                .ReturnsAsync(Result.Failure(new List<String>() { "Append failed due to WrongExpectedVersion" }))
+                .ReturnsAsync(Result.Failure(new List<String>() { "DeadlineExceeded" }))
                 .ReturnsAsync(Result.Success());
 
             DomainEvent domainEvent = eventType.Name switch
@@ -159,37 +160,6 @@ public async Task TransactionDomainEventHandler_EventPassedIn_Retry_EventIsHandl
             var result = await this.TransactionDomainEventHandler.Handle(domainEvent, CancellationToken.None);
             result.IsSuccess.ShouldBeTrue();
         }
-
-        [Theory]
-        [InlineData(typeof(FloatDomainEvents.FloatCreditPurchasedEvent))]
-        [InlineData(typeof(TransactionDomainEvents.TransactionCostInformationRecordedEvent))]
-        //[InlineData(typeof(TransactionDomainEvents.TransactionHasBeenCompletedEvent))]
-        [InlineData(typeof(TransactionDomainEvents.MerchantFeePendingSettlementAddedToTransactionEvent))]
-        [InlineData(typeof(TransactionDomainEvents.SettledMerchantFeeAddedToTransactionEvent))]
-        [InlineData(typeof(SettlementDomainEvents.MerchantFeeSettledEvent))]
-        //[InlineData(typeof(CustomerEmailReceiptRequestedEvent))]
-        //[InlineData(typeof(CustomerEmailReceiptResendRequestedEvent))]
-        public async Task TransactionDomainEventHandler_EventPassedIn_ExceptionNotRetrid_EventIsHandled(Type eventType)
-        {
-            this.Mediator.SetupSequence(m => m.Send(It.IsAny<IRequest<Result>>(), It.IsAny<CancellationToken>()))
-                .ThrowsAsync(new ApplicationException());
-
-            DomainEvent domainEvent = eventType.Name switch
-            {
-                nameof(FloatDomainEvents.FloatCreditPurchasedEvent) => new FloatDomainEvents.FloatCreditPurchasedEvent(TestData.FloatAggregateId, TestData.EstateId, TestData.CreditPurchasedDateTime, TestData.FloatCreditAmount, TestData.FloatCreditCostPrice),
-                nameof(TransactionDomainEvents.TransactionCostInformationRecordedEvent) => TestData.TransactionCostInformationRecordedEvent,
-                nameof(TransactionDomainEvents.TransactionHasBeenCompletedEvent) => TestData.DomainEvents.TransactionHasBeenCompletedEvent,
-                nameof(TransactionDomainEvents.MerchantFeePendingSettlementAddedToTransactionEvent) => new TransactionDomainEvents.MerchantFeePendingSettlementAddedToTransactionEvent(TestData.TransactionId, TestData.EstateId, TestData.MerchantId, TestData.CalculatedFeeValue, 0, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeCalculateDateTime, TestData.TransactionFeeSettlementDueDate, TestData.TransactionDateTime),
-                nameof(TransactionDomainEvents.SettledMerchantFeeAddedToTransactionEvent) => TestData.SettledMerchantFeeAddedToTransactionEvent(TestData.SettlementDate),
-                nameof(SettlementDomainEvents.MerchantFeeSettledEvent) => new SettlementDomainEvents.MerchantFeeSettledEvent(TestData.SettlementAggregateId, TestData.EstateId, TestData.MerchantId, TestData.TransactionId, TestData.CalculatedFeeValue, 0, TestData.TransactionFeeId, TestData.TransactionFeeValue, TestData.TransactionFeeCalculateDateTime, TestData.SettlementDate),
-                //nameof(TransactionDomainEvents.CustomerEmailReceiptRequestedEvent) => TestData.CustomerEmailReceiptRequestedEvent,
-                //nameof(TransactionDomainEvents.CustomerEmailReceiptResendRequestedEvent) => TestData.CustomerEmailReceiptResendRequestedEvent,
-                _ => throw new NotSupportedException($"Event {eventType.Name} not supported")
-            };
-
-            var result = await this.TransactionDomainEventHandler.Handle(domainEvent, CancellationToken.None);
-            result.IsFailed.ShouldBeTrue();
-        }
     }
 }
 

TransactionProcessor.BusinessLogic/Common/PolicyFactory.cs

@@ -13,17 +13,13 @@
 namespace TransactionProcessor.BusinessLogic.Common;
 
 public static class PolicyFactory{
-    public static IAsyncPolicy<Result> CreatePolicy(Int32 retryCount=5, TimeSpan? retryDelay = null, String policyTag="", Boolean withFallBack=true) {
+    public static IAsyncPolicy<Result> CreatePolicy(Int32 retryCount=5, TimeSpan? retryDelay = null, String policyTag="", Boolean withFallBack=false) {
 
-        TimeSpan retryDelayValue = retryDelay.GetValueOrDefault(TimeSpan.FromSeconds(1));
+        TimeSpan retryDelayValue = retryDelay.GetValueOrDefault(TimeSpan.FromSeconds(2));
 
         AsyncRetryPolicy<Result> retryPolicy = CreateRetryPolicy(retryCount, retryDelayValue, policyTag);
 
-        IAsyncPolicy<Result> policyWrap = withFallBack switch {
-            true => CreateFallbackPolicy(policyTag, retryPolicy),
-            _ => retryPolicy
-        };
-        return policyWrap;
+        return retryPolicy;
     }
 
     public static async Task<Result> ExecuteWithPolicyAsync(Func<Task<Result>> action, IAsyncPolicy<Result> policy, String policyTag = "")
@@ -52,29 +48,15 @@ public static async Task<Result> ExecuteWithPolicyAsync(Func<Task<Result>> actio
     private static AsyncRetryPolicy<Result> CreateRetryPolicy(int retryCount, TimeSpan retryDelay, String policyTag)
     {
         return Policy<Result>
-            .Handle<WrongExpectedVersionException>()
-            .Or<RpcException>(ex => ex.StatusCode == StatusCode.DeadlineExceeded)
+            .HandleResult(result => !result.IsSuccess && String.Join("|",result.Errors).Contains("Append failed due to WrongExpectedVersion")) // Retry if the result is not successful
+            .OrResult(result => !result.IsSuccess && String.Join("|", result.Errors).Contains("DeadlineExceeded")) // Retry if the result is not successful
             .WaitAndRetryAsync(retryCount,
                 _ => retryDelay, // Fixed delay
-                (exception, timeSpan, retryCount, context) =>
+                (result, timeSpan, retryCount, context) =>
                 {
                     context["RetryCount"] = retryCount;
-                    Logger.LogWarning($"{policyTag} - Retry {retryCount} due to {exception.Exception.GetType().Name}. Waiting {timeSpan} before retrying...");
-                });
-    }
-
-    private static AsyncPolicyWrap<Result> CreateFallbackPolicy(String policyTag, AsyncRetryPolicy<Result> retryPolicy)
-    {
-        var fallbackPolicy = Policy<Result>
-            .Handle<Exception>() // Catch-all for exceptions that aren't retried
-            .FallbackAsync(
-                fallbackValue: Result.Failure("An error occurred, no retry required."), // Ensure a valid Result return
-                onFallbackAsync: (exception, context) =>
-                {
-                    Logger.LogWarning($"{policyTag} - Non-retryable exception encountered: {exception.Exception.GetType().Name}");
-                    return Task.CompletedTask;
+                    Logger.LogWarning($"{policyTag} - Retry {retryCount} due to unsuccessful result  {String.Join(".",result.Result.Errors)}. Waiting {timeSpan} before retrying...");
                 });
 
-        return fallbackPolicy.WrapAsync(retryPolicy);
     }
 }

TransactionProcessor.BusinessLogic/EventHandling/MerchantDomainEventHandler.cs

@@ -61,7 +61,7 @@ public async Task<Result> Handle(IDomainEvent domainEvent,
         private async Task<Result> HandleSpecificDomainEvent(CallbackReceivedEnrichedEvent domainEvent,
                                                      CancellationToken cancellationToken)
         {
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "MerchantSettlementDomainEventHandler - MerchantFeeSettledEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "MerchantSettlementDomainEventHandler - MerchantFeeSettledEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 if (domainEvent.TypeString == typeof(CallbackHandler.DataTransferObjects.Deposit).ToString()) {

TransactionProcessor.BusinessLogic/EventHandling/MerchantSettlementDomainEventHandler.cs

@@ -32,7 +32,7 @@ public async Task<Result> Handle(IDomainEvent domainEvent,
 
     private async Task<Result> HandleSpecificDomainEvent(SettlementDomainEvents.MerchantFeeSettledEvent domainEvent,
                                                          CancellationToken cancellationToken) {
-        IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "MerchantSettlementDomainEventHandler - MerchantFeeSettledEvent");
+        IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "MerchantSettlementDomainEventHandler - MerchantFeeSettledEvent");
 
         return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
             MerchantStatementCommands.AddSettledFeeToMerchantStatementCommand command = new(domainEvent.EstateId, domainEvent.MerchantId, domainEvent.FeeCalculatedDateTime, domainEvent.CalculatedValue, domainEvent.TransactionId, domainEvent.FeeId);

TransactionProcessor.BusinessLogic/EventHandling/MerchantStatementDomainEventHandler.cs

@@ -52,7 +52,7 @@ public async Task<Result> Handle(IDomainEvent domainEvent,
         private async Task<Result> HandleSpecificDomainEvent(MerchantStatementDomainEvents.StatementGeneratedEvent domainEvent,
                                                              CancellationToken cancellationToken) {
 
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "MerchantStatementDomainEventHandler - StatementGeneratedEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "MerchantStatementDomainEventHandler - StatementGeneratedEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 MerchantStatementCommands.EmailMerchantStatementCommand command = new(domainEvent.EstateId, domainEvent.MerchantId, domainEvent.MerchantStatementId);
@@ -63,7 +63,7 @@ private async Task<Result> HandleSpecificDomainEvent(MerchantStatementDomainEven
 
         private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.TransactionHasBeenCompletedEvent domainEvent,
                                                              CancellationToken cancellationToken) {
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "MerchantStatementDomainEventHandler - TransactionHasBeenCompletedEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "MerchantStatementDomainEventHandler - TransactionHasBeenCompletedEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 MerchantStatementCommands.AddTransactionToMerchantStatementCommand command = new(domainEvent.EstateId, domainEvent.MerchantId, domainEvent.CompletedDateTime, domainEvent.TransactionAmount, domainEvent.IsAuthorised, domainEvent.TransactionId);

TransactionProcessor.BusinessLogic/EventHandling/TransactionDomainEventHandler.cs

@@ -59,7 +59,7 @@ public async Task<Result> Handle(IDomainEvent domainEvent,
         private async Task<Result> HandleSpecificDomainEvent(FloatDomainEvents.FloatCreditPurchasedEvent domainEvent,
                                                      CancellationToken cancellationToken) {
 
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "TransactionDomainEventHandler - FloatCreditPurchasedEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - FloatCreditPurchasedEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 FloatActivityCommands.RecordCreditPurchaseCommand command =
@@ -72,7 +72,7 @@ private async Task<Result> HandleSpecificDomainEvent(FloatDomainEvents.FloatCred
 
         private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.TransactionCostInformationRecordedEvent domainEvent, CancellationToken cancellationToken){
 
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "TransactionDomainEventHandler - TransactionCostInformationRecordedEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - TransactionCostInformationRecordedEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 FloatActivityCommands.RecordTransactionCommand command = new(domainEvent.EstateId,
@@ -84,14 +84,19 @@ private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.Tra
 
         private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.TransactionHasBeenCompletedEvent domainEvent,
                                                              CancellationToken cancellationToken) {
-            CalculateFeesForTransactionCommand command = new(domainEvent.TransactionId, domainEvent.CompletedDateTime, domainEvent.EstateId, domainEvent.MerchantId);
+            
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - TransactionHasBeenCompletedEvent");
 
-            return await this.Mediator.Send(command, cancellationToken);
+            return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
+                CalculateFeesForTransactionCommand command = new(domainEvent.TransactionId, domainEvent.CompletedDateTime, domainEvent.EstateId, domainEvent.MerchantId);
+
+                return await this.Mediator.Send(command, cancellationToken);
+            }, retryPolicy, "TransactionDomainEventHandler - TransactionHasBeenCompletedEvent");
         }
 
         private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.MerchantFeePendingSettlementAddedToTransactionEvent domainEvent,
                                                              CancellationToken cancellationToken) {
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "TransactionDomainEventHandler - MerchantFeePendingSettlementAddedToTransactionEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - MerchantFeePendingSettlementAddedToTransactionEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 SettlementCommands.AddMerchantFeePendingSettlementCommand command =
@@ -105,7 +110,7 @@ private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.Mer
 
         private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.SettledMerchantFeeAddedToTransactionEvent domainEvent,
                                                              CancellationToken cancellationToken) {
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "TransactionDomainEventHandler - SettledMerchantFeeAddedToTransactionEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - SettledMerchantFeeAddedToTransactionEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 AddSettledFeeToSettlementCommand command = new AddSettledFeeToSettlementCommand(
@@ -117,7 +122,7 @@ private async Task<Result> HandleSpecificDomainEvent(TransactionDomainEvents.Set
         private async Task<Result> HandleSpecificDomainEvent(SettlementDomainEvents.MerchantFeeSettledEvent domainEvent,
                                                              CancellationToken cancellationToken)
         {
-            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(2, policyTag: "TransactionDomainEventHandler - MerchantFeeSettledEvent");
+            IAsyncPolicy<Result> retryPolicy = PolicyFactory.CreatePolicy(policyTag: "TransactionDomainEventHandler - MerchantFeeSettledEvent");
 
             return await PolicyFactory.ExecuteWithPolicyAsync(async () => {
                 AddSettledMerchantFeeCommand command = new(domainEvent.TransactionId, domainEvent.CalculatedValue,