Merge pull request #29 from AMalininHere/add-handler-invoker

[Breaking change] introduce `HandlerInvoker` to call handlers
TechnoBerry · Apr 15, 2021 · 22fc67d · 22fc67d
2 parents ab20380 + 349237e
commit 22fc67d
Show file tree

Hide file tree

Showing 10 changed files with 101 additions and 93 deletions.
diff --git a/README.md b/README.md
@@ -8,9 +8,9 @@
 ```csharp
 [HandlerTopics("sayHello", LockDuration = 10_000)]
 [HandlerVariables("USERNAME")]
-public class SayHelloHandler : ExternalTaskHandler
+public class SayHelloHandler : IExternalTaskHandler
 {
-    public override async Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
+    public async Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
     {
         var username = externalTask.Variables["USERNAME"].Value;
 

diff --git a/samples/SampleCamundaWorker/Handlers/SayHelloGuestHandler.cs b/samples/SampleCamundaWorker/Handlers/SayHelloGuestHandler.cs
@@ -1,13 +1,14 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Camunda.Worker;
 
 namespace SampleCamundaWorker.Handlers
 {
     [HandlerTopics("sayHelloGuest")]
-    public class SayHelloGuestHandler : ExternalTaskHandler
+    public class SayHelloGuestHandler : IExternalTaskHandler
     {
-        public override Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
+        public Task<IExecutionResult> HandleAsync(ExternalTask externalTask, CancellationToken cancellationToken)
         {
             return Task.FromResult<IExecutionResult>(new CompleteResult
             {

diff --git a/samples/SampleCamundaWorker/Handlers/SayHelloHandler.cs b/samples/SampleCamundaWorker/Handlers/SayHelloHandler.cs
@@ -1,14 +1,15 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Camunda.Worker;
 
 namespace SampleCamundaWorker.Handlers
 {
     [HandlerTopics("sayHello", LockDuration = 10000)]
     [HandlerVariables("USERNAME")]
-    public class SayHelloHandler : ExternalTaskHandler
+    public class SayHelloHandler : IExternalTaskHandler
     {
-        public override async Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
+        public async Task<IExecutionResult> HandleAsync(ExternalTask externalTask, CancellationToken cancellationToken)
         {
             if (!externalTask.Variables.TryGetValue("USERNAME", out var usernameVariable))
             {

diff --git a/src/Camunda.Worker/CamundaWorkerBuilderExtensions.cs b/src/Camunda.Worker/CamundaWorkerBuilderExtensions.cs
@@ -52,7 +52,8 @@ private static Task HandlerDelegate<T>(IExternalTaskContext context)
             where T : class, IExternalTaskHandler
         {
             var handler = context.ServiceProvider.GetRequiredService<T>();
-            return handler.HandleAsync(context);
+            var invoker = new HandlerInvoker(handler, context);
+            return invoker.InvokeAsync();
         }
     }
 }
diff --git a/src/Camunda.Worker/Execution/HandlerInvoker.cs b/src/Camunda.Worker/Execution/HandlerInvoker.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Camunda.Worker.Execution
+{
+    public class HandlerInvoker
+    {
+        private readonly IExternalTaskHandler _handler;
+        private readonly IExternalTaskContext _context;
+
+        public HandlerInvoker(IExternalTaskHandler handler, IExternalTaskContext context)
+        {
+            _handler = Guard.NotNull(handler, nameof(handler));
+            _context = Guard.NotNull(context, nameof(context));
+        }
+
+        public async Task InvokeAsync()
+        {
+            IExecutionResult executionResult;
+            try
+            {
+                executionResult = await _handler.HandleAsync(_context.Task, default);
+            }
+            catch (Exception e)
+            {
+                executionResult = new FailureResult(e);
+            }
+
+            await executionResult.ExecuteResultAsync(_context);
+        }
+    }
+}
diff --git a/src/Camunda.Worker/ExternalTaskHandler.cs b/src/Camunda.Worker/ExternalTaskHandler.cs
diff --git a/src/Camunda.Worker/IExternalTaskHandler.cs b/src/Camunda.Worker/IExternalTaskHandler.cs
@@ -1,9 +1,10 @@
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace Camunda.Worker
 {
     public interface IExternalTaskHandler
     {
-        Task HandleAsync(IExternalTaskContext context);
+        Task<IExecutionResult> HandleAsync(ExternalTask externalTask, CancellationToken cancellationToken);
     }
 }
diff --git a/test/Camunda.Worker.Tests/CamundaWorkerBuilderExtensionsTest.cs b/test/Camunda.Worker.Tests/CamundaWorkerBuilderExtensionsTest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Camunda.Worker.Execution;
 using Microsoft.Extensions.DependencyInjection;
@@ -59,9 +60,9 @@ public void TestAddHandlerWithoutTopic()
 
         [HandlerTopics("testTopic_1", "testTopic_1")]
         [HandlerVariables("testVariable", LocalVariables = true)]
-        private class HandlerWithTopics : ExternalTaskHandler
+        private class HandlerWithTopics : IExternalTaskHandler
         {
-            public override Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
+            public Task<IExecutionResult> HandleAsync(ExternalTask externalTask, CancellationToken cancellationToken)
             {
                 return Task.FromResult<IExecutionResult>(new CompleteResult
                 {
@@ -70,9 +71,9 @@ public override Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
             }
         }
 
-        private class HandlerWithoutTopics : ExternalTaskHandler
+        private class HandlerWithoutTopics : IExternalTaskHandler
         {
-            public override Task<IExecutionResult> HandleAsync(ExternalTask externalTask)
+            public Task<IExecutionResult> HandleAsync(ExternalTask externalTask, CancellationToken cancellationToken)
             {
                 return Task.FromResult<IExecutionResult>(new CompleteResult
                 {

diff --git a/test/Camunda.Worker.Tests/Execution/HandlerInvokerTest.cs b/test/Camunda.Worker.Tests/Execution/HandlerInvokerTest.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+using Moq;
+using Xunit;
+
+namespace Camunda.Worker.Execution
+{
+    public class HandlerInvokerTest
+    {
+        private readonly Mock<IExternalTaskHandler> _handlerMock = new();
+        private readonly Mock<IExternalTaskContext> _contextMock = new();
+        private readonly HandlerInvoker _handlerInvoker;
+
+        public HandlerInvokerTest()
+        {
+            _handlerInvoker = new HandlerInvoker(_handlerMock.Object, _contextMock.Object);
+        }
+
+        [Fact]
+        public async Task TestExecuteReturnedFromHandlerResult()
+        {
+            // Arrange
+            var resultMock = new Mock<IExecutionResult>();
+
+            _handlerMock.Setup(handler => handler.HandleAsync(It.IsAny<ExternalTask>(), default))
+                .ReturnsAsync(resultMock.Object);
+
+            // Act
+            await _handlerInvoker.InvokeAsync();
+
+            // Assert
+            resultMock.Verify(result => result.ExecuteResultAsync(It.IsAny<IExternalTaskContext>()), Times.Once());
+        }
+
+        [Fact]
+        public async Task TestReportFailureIfHandlerFails()
+        {
+            // Arrange
+            _handlerMock.Setup(handler => handler.HandleAsync(It.IsAny<ExternalTask>(), default))
+                .ThrowsAsync(new Exception());
+
+            // Act
+            await _handlerInvoker.InvokeAsync();
+
+            // Assert
+            _contextMock.Verify(
+                context => context.ReportFailureAsync(It.IsAny<string>(), It.IsAny<string>(), null, null),
+                Times.Once()
+            );
+        }
+    }
+}
diff --git a/test/Camunda.Worker.Tests/ExternalTaskHandlerTest.cs b/test/Camunda.Worker.Tests/ExternalTaskHandlerTest.cs