execute finally for empty chains of responsibility

ipvalverde · Oct 26, 2024 · 91a0213 · 91a0213
1 parent 30d9e42
commit 91a0213
Show file tree

Hide file tree

Showing 4 changed files with 73 additions and 2 deletions.
diff --git a/src/PipelineNet.Tests/ChainsOfResponsibility/AsyncResponsibilityChainTests.cs b/src/PipelineNet.Tests/ChainsOfResponsibility/AsyncResponsibilityChainTests.cs
@@ -271,5 +271,18 @@ public async Task Execute_ChainOfMiddlewareWithCancellableFinally_CancellableFin
             // The 'FinallyThrowIfCancellationRequested' should throw 'OperationCanceledException'.
             await Assert.ThrowsAsync<OperationCanceledException>(() => responsibilityChain.Execute(exception, cancellationToken));
         }
+
+        [Fact]
+        public async Task Execute_EmptyChainOfMiddlewareWithFinally_FinallyIsExecuted()
+        {
+            var responsibilityChain = new AsyncResponsibilityChain<Exception, bool>(new ActivatorMiddlewareResolver())
+                .Finally<FinallyThrow>();
+
+            // Creates an ArgumentNullException.
+            var exception = new ArgumentNullException();
+
+            // The 'FinallyThrow' should throw 'InvalidOperationException'.
+            await Assert.ThrowsAsync<InvalidOperationException>(() => responsibilityChain.Execute(exception));
+        }
     }
 }
diff --git a/src/PipelineNet.Tests/ChainsOfResponsibility/ResponsibilityChainTests.cs b/src/PipelineNet.Tests/ChainsOfResponsibility/ResponsibilityChainTests.cs
@@ -169,5 +169,17 @@ public void Execute_ChainOfMiddlewareWithFinally_FinallyIsExecuted()
             Assert.Throws<InvalidOperationException>(() => responsibilityChain.Execute(exception));
         }
 
+        [Fact]
+        public void Execute_EmptyChainOfMiddlewareWithFinally_FinallyIsExecuted()
+        {
+            var responsibilityChain = new ResponsibilityChain<Exception, bool>(new ActivatorMiddlewareResolver())
+                .Finally<FinallyThrow>();
+
+            // Creates an ArgumentNullException.
+            var exception = new ArgumentNullException();
+
+            // The 'FinallyThrow' should throw 'InvalidOperationException'.
+            Assert.Throws<InvalidOperationException>(() => responsibilityChain.Execute(exception));
+        }
     }
 }
diff --git a/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChain.cs b/src/PipelineNet/ChainsOfResponsibility/AsyncResponsibilityChain.cs
@@ -92,7 +92,30 @@ public async Task<TReturn> Execute(TParameter parameter) =>
         public async Task<TReturn> Execute(TParameter parameter, CancellationToken cancellationToken)
         {
             if (MiddlewareTypes.Count == 0)
-                return default(TReturn);
+            {
+                MiddlewareResolverResult finallyResolverResult = null;
+                try
+                {
+                    if (_finallyType != null)
+                    {
+                        finallyResolverResult = MiddlewareResolver.Resolve(_finallyType);
+                        EnsureMiddlewareNotNull(finallyResolverResult, _finallyType);
+                        return await RunFinallyAsync(finallyResolverResult, parameter, cancellationToken).ConfigureAwait(false);
+                    }
+                    else if (_finallyFunc != null)
+                    {
+                        return await _finallyFunc(parameter).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        return await Task.FromResult(default(TReturn)).ConfigureAwait(false);
+                    }
+                }
+                finally
+                {
+                    await DisposeMiddlewareAsync(finallyResolverResult).ConfigureAwait(false);
+                }
+            }
 
             int index = 0;
             Func<TParameter, Task<TReturn>> next = null;

diff --git a/src/PipelineNet/ChainsOfResponsibility/ResponsibilityChain.cs b/src/PipelineNet/ChainsOfResponsibility/ResponsibilityChain.cs
@@ -113,7 +113,30 @@ public IResponsibilityChain<TParameter, TReturn> Chain(Type middlewareType)
         public TReturn Execute(TParameter parameter)
         {
             if (MiddlewareTypes.Count == 0)
-                return default(TReturn);
+            {
+                MiddlewareResolverResult finallyResolverResult = null;
+                try
+                {
+                    if (_finallyType != null)
+                    {
+                        finallyResolverResult = MiddlewareResolver.Resolve(_finallyType);
+                        EnsureMiddlewareNotNull(finallyResolverResult, _finallyType);
+                        return RunFinally(finallyResolverResult, parameter);
+                    }
+                    else if (_finallyFunc != null)
+                    {
+                        return _finallyFunc(parameter);
+                    }
+                    else
+                    {
+                        return default(TReturn);
+                    }
+                }
+                finally
+                {
+                    DisposeMiddleware(finallyResolverResult);
+                }
+            }
 
             int index = 0;
             Func<TParameter, TReturn> next = null;