Support open-generic notification handlers with full scenario tests

src/DispatchR/Configuration/ServiceRegistrator.cs

@@ -170,20 +170,33 @@ public static void RegisterHandlers(IServiceCollection services, List<Type> allT
             }
         }
 
-        public static void RegisterNotification(IServiceCollection services, List<Type> allTypes,
-            Type syncNotificationHandlerType)
-        {
-            var allNotifications = allTypes
-                .SelectMany(handlerType => handlerType.GetInterfaces()
-                    .Where(i => i.IsGenericType && syncNotificationHandlerType == i.GetGenericTypeDefinition())
-                    .Select(i => new { HandlerType = handlerType, Interface = i }))
-                .ToList();
-
-            foreach (var notification in allNotifications)
-            {
-                services.AddScoped(notification.Interface, notification.HandlerType);
-            }
-        }
+        public static void RegisterNotification(IServiceCollection services, List<Type> allTypes,
+            Type syncNotificationHandlerType)
+        {
+            var allNotifications = allTypes
+                .SelectMany(handlerType => handlerType.GetInterfaces()
+                    .Where(i => i.IsGenericType && syncNotificationHandlerType == i.GetGenericTypeDefinition())
+                    .Select(i => new { HandlerType = handlerType, Interface = i }))
+                .ToList();
+
+            foreach (var notification in allNotifications)
+            {
+                var serviceType = notification.Interface;
+                var implementationType = notification.HandlerType;
+
+                if (serviceType.ContainsGenericParameters)
+                {
+                    serviceType = serviceType.IsGenericTypeDefinition
+                        ? serviceType
+                        : serviceType.GetGenericTypeDefinition();
+                    implementationType = implementationType.IsGenericTypeDefinition
+                        ? implementationType
+                        : implementationType.GetGenericTypeDefinition();
+                }
+
+                services.AddScoped(serviceType, implementationType);
+            }
+        }
 
         private static bool IsAwaitable(Type type)
         {
@@ -200,4 +213,4 @@ private static bool IsAwaitable(Type type)
             return false;
         }
     }
-}
+}

tests/DispatchR.IntegrationTest/NotificationTests.cs

@@ -74,7 +74,7 @@
 
         // Act
         object notificationObject = new MultiHandlersNotification(Guid.Empty);
         await mediator.Publish(notificationObject, CancellationToken.None);
 
         // Assert
         spyPipelineOneMock.Verify(p => p.Handle(It.IsAny<MultiHandlersNotification>(), It.IsAny<CancellationToken>()), Times.Exactly(1));
@@ -103,4 +103,77 @@
         Assert.Contains(handlers1, h => h is MultiNotificationHandler);
         Assert.Contains(handlers2, h => h is MultiNotificationHandler);
     }
+
+    [Fact]
+    public async Task Publish_CallsOpenGenericAndSpecificHandlers_WhenBothAreRegistered()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddSingleton<OpenGenericNotificationExecutionStore>();
+        services.AddDispatchR(cfg =>
+        {
+            cfg.Assemblies.Add(typeof(Fixture).Assembly);
+            cfg.RegisterPipelines = false;
+            cfg.RegisterNotifications = true;
+        });
+        var serviceProvider = services.BuildServiceProvider();
+        var mediator = serviceProvider.GetRequiredService<IMediator>();
+        var executionStore = serviceProvider.GetRequiredService<OpenGenericNotificationExecutionStore>();
+
+        // Act
+        await mediator.Publish(new OpenGenericTargetNotification(Guid.NewGuid()), CancellationToken.None);
+
+        // Assert
+        Assert.Equal(1, executionStore.Count($"generic:{nameof(OpenGenericTargetNotification)}"));
+        Assert.Equal(1, executionStore.Count($"specific:{nameof(OpenGenericTargetNotification)}"));
+    }
+
+    [Fact]
+    public async Task PublishObject_CallsOpenGenericAndSpecificHandlers_WhenBothAreRegistered()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddSingleton<OpenGenericNotificationExecutionStore>();
+        services.AddDispatchR(cfg =>
+        {
+            cfg.Assemblies.Add(typeof(Fixture).Assembly);
+            cfg.RegisterPipelines = false;
+            cfg.RegisterNotifications = true;
+        });
+        var serviceProvider = services.BuildServiceProvider();
+        var mediator = serviceProvider.GetRequiredService<IMediator>();
+        var executionStore = serviceProvider.GetRequiredService<OpenGenericNotificationExecutionStore>();
+
+        // Act
+        object notificationObject = new OpenGenericTargetNotification(Guid.NewGuid());
+        await mediator.Publish(notificationObject, CancellationToken.None);
+
+        // Assert
+        Assert.Equal(1, executionStore.Count($"generic:{nameof(OpenGenericTargetNotification)}"));
+        Assert.Equal(1, executionStore.Count($"specific:{nameof(OpenGenericTargetNotification)}"));
+    }
+
+    [Fact]
+    public async Task Publish_CallsOpenGenericHandler_WhenNoSpecificHandlerExists()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddSingleton<OpenGenericNotificationExecutionStore>();
+        services.AddDispatchR(cfg =>
+        {
+            cfg.Assemblies.Add(typeof(Fixture).Assembly);
+            cfg.RegisterPipelines = false;
+            cfg.RegisterNotifications = true;
+        });
+        var serviceProvider = services.BuildServiceProvider();
+        var mediator = serviceProvider.GetRequiredService<IMediator>();
+        var executionStore = serviceProvider.GetRequiredService<OpenGenericNotificationExecutionStore>();
+
+        // Act
+        await mediator.Publish(new OpenGenericOnlyNotification(Guid.NewGuid()), CancellationToken.None);
+
+        // Assert
+        Assert.Equal(1, executionStore.Count($"generic:{nameof(OpenGenericOnlyNotification)}"));
+        Assert.Equal(0, executionStore.Count($"specific:{nameof(OpenGenericOnlyNotification)}"));
+    }
 }

tests/DispatchR.TestCommon/Fixtures/Notification/OpenGenericNotificationExecutionStore.cs

@@ -0,0 +1,18 @@
+using System.Collections.Concurrent;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed class OpenGenericNotificationExecutionStore
+{
+    private readonly ConcurrentDictionary<string, int> _counters = new();
+
+    public void Increment(string key)
+    {
+        _counters.AddOrUpdate(key, 1, (_, current) => current + 1);
+    }
+
+    public int Count(string key)
+    {
+        return _counters.TryGetValue(key, out var count) ? count : 0;
+    }
+}

tests/DispatchR.TestCommon/Fixtures/Notification/OpenGenericNotificationHandler.cs

@@ -0,0 +1,21 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed class OpenGenericNotificationHandler<TNotification> : INotificationHandler<TNotification>
+    where TNotification : INotification
+{
+    private static readonly OpenGenericNotificationExecutionStore FallbackStore = new();
+    private readonly OpenGenericNotificationExecutionStore _store;
+
+    public OpenGenericNotificationHandler(OpenGenericNotificationExecutionStore? store = null)
+    {
+        _store = store ?? FallbackStore;
+    }
+
+    public ValueTask Handle(TNotification request, CancellationToken cancellationToken)
+    {
+        _store.Increment($"generic:{typeof(TNotification).Name}");
+        return ValueTask.CompletedTask;
+    }
+}

tests/DispatchR.TestCommon/Fixtures/Notification/OpenGenericOnlyNotification.cs

@@ -0,0 +1,5 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed record OpenGenericOnlyNotification(Guid Id) : INotification;

tests/DispatchR.TestCommon/Fixtures/Notification/OpenGenericTargetNotification.cs

@@ -0,0 +1,5 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed record OpenGenericTargetNotification(Guid Id) : INotification;

tests/DispatchR.TestCommon/Fixtures/Notification/OpenGenericTargetNotificationHandler.cs

@@ -0,0 +1,20 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed class OpenGenericTargetNotificationHandler : INotificationHandler<OpenGenericTargetNotification>
+{
+    private static readonly OpenGenericNotificationExecutionStore FallbackStore = new();
+    private readonly OpenGenericNotificationExecutionStore _store;
+
+    public OpenGenericTargetNotificationHandler(OpenGenericNotificationExecutionStore? store = null)
+    {
+        _store = store ?? FallbackStore;
+    }
+
+    public ValueTask Handle(OpenGenericTargetNotification request, CancellationToken cancellationToken)
+    {
+        _store.Increment($"specific:{nameof(OpenGenericTargetNotification)}");
+        return ValueTask.CompletedTask;
+    }
+}

tests/DispatchR.UnitTest/AddDispatchRConfigurationTests.cs

@@ -1,3 +1,4 @@
+using DispatchR.Abstractions.Notification;
 using DispatchR.Abstractions.Stream;
 using DispatchR.Exceptions;
 using DispatchR.Extensions;
@@ -237,4 +238,30 @@ p.IsKeyedService is false &&
 
         Assert.Equal(3, countOfAllSimpleHandlers);
     }
-}
+
+    [Fact]
+    public void AddDispatchR_RegisterNotifications_IncludesOpenGenericNotificationHandler()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+
+        // Act
+        services.AddDispatchR(cfg =>
+        {
+            cfg.Assemblies.Add(typeof(Fixture).Assembly);
+            cfg.RegisterPipelines = false;
+            cfg.RegisterNotifications = true;
+        });
+
+        // Assert
+        var openGenericHandler = services.SingleOrDefault(p =>
+            p.IsKeyedService is false &&
+            p.ServiceType.IsGenericTypeDefinition &&
+            p.ServiceType == typeof(INotificationHandler<>) &&
+            p.ImplementationType is not null &&
+            p.ImplementationType.IsGenericTypeDefinition &&
+            p.ImplementationType == typeof(OpenGenericNotificationHandler<>));
+
+        Assert.NotNull(openGenericHandler);
+    }
+}