Fix awaitable response type comparison in async pipelines (#43)

* Add test for request handler with async enumerable response

* Fix awaitable response type comparison in async pipelines

Author: wassim-k

src/DispatchR/Configuration/ServiceRegistrator.cs

@@ -125,6 +125,14 @@ public static void RegisterHandlers(IServiceCollection services, List<Type> allT
                                         continue;
                                     }
 
+                                    // If both are non-generic (Task vs ValueTask), then compare directly
+                                    if (!responseTypeArg.GenericTypeArguments.Any() &&
+                                        !genericHandlerResponseType.GenericTypeArguments.Any() &&
+                                        responseTypeArg != genericHandlerResponseType)
+                                    {
+                                        continue; // Task != ValueTask, so skip
+                                    }
+
                                     // register async generic pipelines
                                     if (responseTypeArg.GenericTypeArguments.Any())
                                     {

tests/DispatchR.TestCommon/Fixtures/Interfaces/INonGenericInterface.cs

@@ -0,0 +1,3 @@
+namespace DispatchR.TestCommon.Fixtures.Interfaces;
+
+public interface INonGenericInterface;

tests/DispatchR.TestCommon/Fixtures/SendRequest/AsyncEnumerable/AsyncEnumerableHandler.cs

@@ -0,0 +1,14 @@
+using System.Runtime.CompilerServices;
+using DispatchR.Abstractions.Send;
+
+namespace DispatchR.TestCommon.Fixtures.SendRequest.AsyncEnumerable;
+
+public class AsyncEnumerableHandler : IRequestHandler<AsyncEnumerableRequest, IAsyncEnumerable<int>>
+{
+    public async IAsyncEnumerable<int> Handle(AsyncEnumerableRequest request, [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        yield return await System.Threading.Tasks.Task.FromResult(1);
+        yield return await System.Threading.Tasks.Task.FromResult(2);
+        yield return await System.Threading.Tasks.Task.FromResult(3);
+    }
+}

tests/DispatchR.TestCommon/Fixtures/SendRequest/AsyncEnumerable/AsyncEnumerableRequest.cs

@@ -0,0 +1,5 @@
+using DispatchR.Abstractions.Send;
+
+namespace DispatchR.TestCommon.Fixtures.SendRequest.AsyncEnumerable;
+
+public class AsyncEnumerableRequest : IRequest<AsyncEnumerableRequest, IAsyncEnumerable<int>>;

tests/DispatchR.TestCommon/Fixtures/SendRequest/AsyncEnumerablePipelineBehavior.cs

@@ -0,0 +1,21 @@
+using System.Runtime.CompilerServices;
+using DispatchR.Abstractions.Send;
+using DispatchR.TestCommon.Fixtures.Interfaces;
+
+namespace DispatchR.TestCommon.Fixtures.SendRequest;
+
+public class AsyncEnumerablePipelineBehavior<TRequest, TResponse>
+    : INonGenericInterface,
+    IPipelineBehavior<TRequest, IAsyncEnumerable<TResponse>>
+    where TRequest : class, IRequest<TRequest, IAsyncEnumerable<TResponse>>, new()
+{
+    public required IRequestHandler<TRequest, IAsyncEnumerable<TResponse>> NextPipeline { get; set; }
+
+    public async IAsyncEnumerable<TResponse> Handle(TRequest request, [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        await foreach (var item in NextPipeline.Handle(request, cancellationToken))
+        {
+            yield return item;
+        }
+    }
+}

tests/DispatchR.TestCommon/Fixtures/SendRequest/GenericPipelineBehaviorTaskWithoutResponse.cs

@@ -0,0 +1,15 @@
+using DispatchR.Abstractions.Send;
+
+namespace DispatchR.TestCommon.Fixtures.SendRequest;
+
+public class GenericPipelineBehaviorTaskWithoutResponse<TRequest, TResponse>()
+    : IPipelineBehavior<TRequest, System.Threading.Tasks.Task>
+    where TRequest : class, IRequest<TRequest, System.Threading.Tasks.Task>, new()
+{
+    public System.Threading.Tasks.Task Handle(TRequest request, CancellationToken cancellationToken)
+    {
+        return NextPipeline.Handle(request, cancellationToken);
+    }
+
+    public required IRequestHandler<TRequest, System.Threading.Tasks.Task> NextPipeline { get; set; }
+}