Support open-generic notification handlers with full scenario tests

src/DispatchR/Configuration/ServiceRegistrator.cs

@@ -170,20 +170,28 @@ 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.GetGenericTypeDefinition();
+                }
+
+                services.AddScoped(serviceType, implementationType);
+            }
+        }
 
         private static bool IsAwaitable(Type type)
         {
@@ -200,4 +208,4 @@ private static bool IsAwaitable(Type type)
             return false;
         }
     }
-}
+}

src/Sample/DispatchR/Notification/AllNotificationsLogger.cs

@@ -0,0 +1,19 @@
+using DispatchR.Abstractions.Notification;
+
+namespace Sample.DispatchR.Notification;
+
+/// <summary>
+/// Open-generic notification handler — handles every INotification published through DispatchR.
+/// Useful for cross-cutting concerns such as logging, auditing or telemetry.
+/// </summary>
+public sealed class AllNotificationsLogger<TNotification>(ILogger<AllNotificationsLogger<TNotification>> logger)
+    : INotificationHandler<TNotification>
+    where TNotification : INotification
+{
+    public ValueTask Handle(TNotification notification, CancellationToken cancellationToken)
+    {
+        logger.LogInformation("[Generic] Received notification of type {NotificationType}: {@Notification}",
+            typeof(TNotification).Name, notification);
+        return ValueTask.CompletedTask;
+    }
+}

src/Sample/DispatchR/Notification/GenericAwareNotification.cs

@@ -0,0 +1,5 @@
+using DispatchR.Abstractions.Notification;
+
+namespace Sample.DispatchR.Notification;
+
+public sealed record GenericAwareNotification(Guid Id, string Message) : INotification;

src/Sample/Program.cs

@@ -124,6 +124,16 @@
     return "It works";
 });
 
+// Demonstrates open-generic INotificationHandler<TNotification>:
+// AllNotificationsLogger<TNotification> is registered once and handles every INotification.
+// GenericAwareNotification is handled by both its own specific handler (if any) and the generic one.
+app.MapGet("/Notification/DispatchR/Generic", async (DispatchR.IMediator mediator, ILogger<Program> logger) =>
+{
+    var notification = new DispatchRNotificationSample.GenericAwareNotification(Guid.NewGuid(), "Hello from open-generic handler!");
+    await mediator.Publish(notification, CancellationToken.None);
+    return "It works";
+});
+
 app.Run();
 
 namespace Sample

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);
+    }
+}