Add InvokeHandlerAsync hook and test (#15)

Introduce a protected virtual InvokeHandlerAsync method on RoutedQueueHandler to allow subclasses to wrap handler execution with cross-cutting concerns (default implementation simply invokes the handler). Update the route dispatch to call InvokeHandlerAsync instead of invoking the handler directly. Add a unit test and WrappedInvocationHandler in RoutedQueueHandlerTests to verify the hook is used and that the resolved handler is still executed.

Author: KrastyTC

DotQueue.Tests/RoutedQueueHandlerTests.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using DotQueue;
@@ -57,6 +57,43 @@ private async Task HandleB(
         }
     }
 
+    private sealed class WrappedInvocationHandler : RoutedQueueHandler<TestMessage, Act>
+    {
+        public bool WasWrapped { get; private set; }
+        public Act? LastAction { get; private set; }
+        public int Calls { get; private set; }
+
+        public WrappedInvocationHandler(ILogger logger) : base(logger) { }
+
+        protected override Act GetAction(TestMessage message) => message.Action;
+
+        protected override void Configure(RouteBuilder r) => r
+            .On(Act.A, HandleA);
+
+        protected override async Task InvokeHandlerAsync(
+            Act action,
+            HandlerDelegate handler,
+            TestMessage message,
+            IReadOnlyDictionary<string, string>? metadata,
+            Func<Task> renewLock,
+            CancellationToken ct)
+        {
+            WasWrapped = true;
+            LastAction = action;
+            await handler(message, metadata, renewLock, ct);
+        }
+
+        private Task HandleA(
+            TestMessage m,
+            IReadOnlyDictionary<string, string>? meta,
+            Func<Task> renew,
+            CancellationToken ct)
+        {
+            Calls++;
+            return Task.CompletedTask;
+        }
+    }
+
     [Fact]
     public async Task Routes_To_Registered_Handlers_And_Passes_Metadata_And_RenewLock()
     {
@@ -93,4 +130,21 @@ public async Task Unknown_Action_Is_NonRetryable_From_DotQueue_Base()
         await act.Should().ThrowAsync<NonRetryableException>()
                  .WithMessage("*No handler registered for action*");
     }
+
+    [Fact]
+    public async Task HandleAsync_Uses_InvokeHandlerAsync_For_Resolved_Routes()
+    {
+        var logger = Mock.Of<ILogger>();
+        var handler = new WrappedInvocationHandler(logger);
+
+        await handler.HandleAsync(
+            new TestMessage { Action = Act.A },
+            null,
+            () => Task.CompletedTask,
+            CancellationToken.None);
+
+        handler.WasWrapped.Should().BeTrue();
+        handler.LastAction.Should().Be(Act.A);
+        handler.Calls.Should().Be(1);
+    }
 }

DotQueue/DotQueue.csproj

@@ -6,7 +6,7 @@
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageId>DotQueue</PackageId>
-    <Version>1.1.0</Version>
+    <Version>1.1.1</Version>
     <Authors>Alexander Kulyabin</Authors>
     <Company>Zionet</Company>
     <Description>Generic queue listener</Description>

DotQueue/RoutedQueueHandler.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 
 namespace DotQueue;
 
@@ -26,6 +26,18 @@ protected delegate Task HandlerDelegate(
 
     protected void Register(TAction action, HandlerDelegate handler) => _routes[action] = handler;
 
+    /// <summary>
+    /// Invokes the resolved handler for the given action.
+    /// Override to wrap handler execution with cross-cutting concerns.
+    /// </summary>
+    protected virtual Task InvokeHandlerAsync(
+        TAction action,
+        HandlerDelegate handler,
+        TMessage message,
+        IReadOnlyDictionary<string, string>? metadata,
+        Func<Task> renewLock,
+        CancellationToken ct) => handler(message, metadata, renewLock, ct);
+
     protected sealed class RouteBuilder
     {
         private readonly RoutedQueueHandler<TMessage, TAction> _owner;
@@ -48,7 +60,7 @@ public Task HandleAsync(
 
         if (_routes.TryGetValue(action, out var handler))
         {
-            return handler(message, metadata, renewLock, ct);
+            return InvokeHandlerAsync(action, handler, message, metadata, renewLock, ct);
         }
 
         _logger.LogWarning("No handler registered for action {Action}", action);