Add custom error handler for execute workflow middleware and tests

Author: glucaci

src/WorkflowCore/Models/WorkflowDefinition.cs

@@ -18,6 +18,7 @@ public class WorkflowDefinition
         public WorkflowErrorHandling DefaultErrorBehavior { get; set; }
 
         public Type OnPostMiddlewareError { get; set; }
+        public Type OnExecuteMiddlewareError { get; set; }
 
         public TimeSpan? DefaultErrorRetryInterval { get; set; }
 

src/WorkflowCore/Services/WorkflowMiddlewareRunner.cs

@@ -43,11 +43,7 @@ public async Task RunPostMiddleware(WorkflowInstance workflow, WorkflowDefinitio
             }
             catch (Exception exception)
             {
-                // TODO: 
-                // OnPostMiddlewareError should be IWorkflowMiddlewareErrorHandler
-                // because we don't know to run other error handler type
-                var errorHandlerType = def.OnPostMiddlewareError ?? typeof(IWorkflowMiddlewareErrorHandler);
-                await HandleWorkflowMiddlewareError(exception);
+                await HandleWorkflowMiddlewareError(def.OnPostMiddlewareError, exception);
             }
         }
 
@@ -63,19 +59,7 @@ public async Task RunExecuteMiddleware(WorkflowInstance workflow, WorkflowDefini
             }
             catch (Exception exception)
             {
-                await HandleWorkflowMiddlewareError(exception);
-            }
-        }
-
-        private async Task HandleWorkflowMiddlewareError(Exception exception)
-        {
-            using (var scope = _serviceProvider.CreateScope())
-            {
-                var handler = scope.ServiceProvider.GetService<IWorkflowMiddlewareErrorHandler>();
-                if (handler != null)
-                {
-                    await handler.HandleAsync(exception);
-                }
+                await HandleWorkflowMiddlewareError(def.OnExecuteMiddlewareError, exception);
             }
         }
 
@@ -89,5 +73,19 @@ private static Task RunWorkflowMiddleware(
                     (previous, middleware) =>
                         () => middleware.HandleAsync(workflow, previous))();
         }
+
+        private async Task HandleWorkflowMiddlewareError(Type middlewareErrorType, Exception exception)
+        {
+            var errorHandlerType = middlewareErrorType ?? typeof(IWorkflowMiddlewareErrorHandler);
+
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                var typeInstance = scope.ServiceProvider.GetService(errorHandlerType);
+                if (typeInstance is IWorkflowMiddlewareErrorHandler handler)
+                {
+                    await handler.HandleAsync(exception);
+                }
+            }
+        }
     }
 }

test/WorkflowCore.UnitTests/Services/WorkflowMiddlewareRunnerTests.cs

@@ -238,6 +238,120 @@ public async Task
                 .MustHaveHappenedOnceExactly();
         }
 
+        [Fact(DisplayName = "RunExecuteMiddleware should run nothing when no middleware")]
+        public void RunExecuteMiddleware_should_run_nothing_when_no_middleware()
+        {
+            // Act
+            Func<Task> action = async () => await Runner.RunExecuteMiddleware(Workflow, Definition);
+
+            // Assert
+            action.ShouldNotThrow();
+        }
+
+        [Fact(DisplayName = "RunExecuteMiddleware should run middleware when one middleware")]
+        public async Task RunExecuteMiddleware_should_run_middleware_when_one_middleware()
+        {
+            // Arrange
+            var middleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow);
+            Middleware.Add(middleware);
+
+            // Act
+            await Runner.RunExecuteMiddleware(Workflow, Definition);
+
+            // Assert
+            A
+                .CallTo(HandleMethodFor(middleware))
+                .MustHaveHappenedOnceExactly();
+        }
+
+        [Fact(DisplayName = "RunExecuteMiddleware should run all middleware when multiple middleware")]
+        public async Task RunExecuteMiddleware_should_run_all_middleware_when_multiple_middleware()
+        {
+            // Arrange
+            var middleware1 = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 1);
+            var middleware2 = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 2);
+            var middleware3 = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 3);
+            Middleware.AddRange(new[] { middleware1, middleware2, middleware3 });
+
+            // Act
+            await Runner.RunPostMiddleware(Workflow, Definition);
+
+            // Assert
+            A
+                .CallTo(HandleMethodFor(middleware3))
+                .MustHaveHappenedOnceExactly()
+                .Then(A
+                    .CallTo(HandleMethodFor(middleware2))
+                    .MustHaveHappenedOnceExactly())
+                .Then(A
+                    .CallTo(HandleMethodFor(middleware1))
+                    .MustHaveHappenedOnceExactly());
+        }
+
+        [Fact(DisplayName = "RunExecuteMiddleware should run middleware in ExecuteWorkflow and PostWorkflow phase")]
+        public async Task RunExecuteMiddleware_should_run_middleware_in_ExecuteWorkflow_and_PostWorkflow_phase()
+        {
+            // Arrange
+            var executeMiddleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 1);
+            var postMiddleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.PostWorkflow, 2);
+            var preMiddleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.PreWorkflow, 3);
+            Middleware.AddRange(new[] { preMiddleware, postMiddleware, executeMiddleware });
+
+            // Act
+            // TODO: add same test when workflow not completed
+            await Runner.RunExecuteMiddleware(Workflow, Definition);
+
+            // Assert
+            A
+                .CallTo(HandleMethodFor(executeMiddleware))
+                .MustHaveHappenedOnceExactly()
+                .Then(A
+                    .CallTo(HandleMethodFor(postMiddleware))
+                    .MustHaveHappenedOnceExactly());
+
+            A.CallTo(HandleMethodFor(preMiddleware)).MustNotHaveHappened();
+        }
+
+        [Fact(DisplayName = "RunExecuteMiddleware should call top level error handler when middleware throws")]
+        public async Task RunExecuteMiddleware_should_call_top_level_error_handler_when_middleware_throws()
+        {
+            // Arrange
+            var middleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 1);
+            A.CallTo(HandleMethodFor(middleware)).ThrowsAsync(new ApplicationException("Something went wrong"));
+            Middleware.AddRange(new[] { middleware });
+
+            // Act
+            await Runner.RunExecuteMiddleware(Workflow, Definition);
+
+            // Assert
+            A
+                .CallTo(HandleMethodFor(TopLevelErrorHandler))
+                .MustHaveHappenedOnceExactly();
+        }
+
+        [Fact(DisplayName =
+            "RunExecuteMiddleware should call error handler on workflow def when middleware throws and def has handler defined")]
+        public async Task
+            RunExecuteMiddleware_should_call_error_handler_on_workflow_def_when_middleware_throws_and_def_has_handler()
+        {
+            // Arrange
+            var middleware = BuildWorkflowMiddleware(WorkflowMiddlewarePhase.ExecuteWorkflow, 1);
+            A.CallTo(HandleMethodFor(middleware)).ThrowsAsync(new ApplicationException("Something went wrong"));
+            Middleware.AddRange(new[] { middleware });
+            Definition.OnExecuteMiddlewareError = typeof(IDefLevelErrorHandler);
+
+            // Act
+            await Runner.RunExecuteMiddleware(Workflow, Definition);
+
+            // Assert
+            A
+                .CallTo(HandleMethodFor(TopLevelErrorHandler))
+                .MustNotHaveHappened();
+            A
+                .CallTo(HandleMethodFor(DefLevelErrorHandler))
+                .MustHaveHappenedOnceExactly();
+        }
+
         #region Helpers
 
         private IWorkflowMiddleware BuildWorkflowMiddleware(