IEventHandler

src/Altinn.App.Core/Features/IEventHandler.cs

@@ -5,6 +5,7 @@ namespace Altinn.App.Core.Features;
 /// <summary>
 /// Class handling a dedicated type of event from the Event system ie. an external event.
 /// </summary>
+[ImplementableByApps]
 public interface IEventHandler
 {
     /// <summary>

src/Altinn.App.Core/Internal/Events/EventHandlerResolver.cs

@@ -1,16 +1,17 @@
 using Altinn.App.Core.Features;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Altinn.App.Core.Internal.Events;
 
 /// <inheritdoc/>
 public class EventHandlerResolver : IEventHandlerResolver
 {
-    private readonly IEnumerable<IEventHandler> _eventHandlers;
+    private readonly AppImplementationFactory _appImplementationFactory;
 
     /// <inheritdoc/>
-    public EventHandlerResolver(IEnumerable<IEventHandler> eventHandlers)
+    public EventHandlerResolver(IServiceProvider serviceProvider)
     {
-        _eventHandlers = eventHandlers;
+        _appImplementationFactory = serviceProvider.GetRequiredService<AppImplementationFactory>();
     }
 
     /// <inheritdoc/>
@@ -21,7 +22,8 @@ public IEventHandler ResolveEventHandler(string eventType)
             return new UnhandledEventHandler();
         }
 
-        foreach (var handler in _eventHandlers)
+        var handlers = _appImplementationFactory.GetAll<IEventHandler>();
+        foreach (var handler in handlers)
         {
             if (!handler.EventType.Equals(eventType, StringComparison.OrdinalIgnoreCase))
             {

test/Altinn.App.Core.Tests/Internal/Events/EventHandlerResolverTests.cs

@@ -1,17 +1,42 @@
-#nullable disable
 using Altinn.App.Core.Features;
 using Altinn.App.Core.Internal.Events;
 using Altinn.App.Core.Models;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Altinn.App.PlatformServices.Tests.Internal.Events;
 
 public class EventHandlerResolverTests
 {
+    private sealed record Fixture(IServiceProvider ServiceProvider) : IDisposable
+    {
+        public IEventHandlerResolver Factory => ServiceProvider.GetRequiredService<IEventHandlerResolver>();
+
+        public static Fixture Create(IEnumerable<IEventHandler> eventHandlers)
+        {
+            var services = new ServiceCollection();
+            services.AddTestAppImplementationFactory();
+
+            services.AddTransient<IEventHandlerResolver, EventHandlerResolver>();
+
+            foreach (var eventHandler in eventHandlers)
+                services.AddTransient(_ => eventHandler);
+
+            return new Fixture(
+                services.BuildServiceProvider(
+                    new ServiceProviderOptions { ValidateOnBuild = true, ValidateScopes = true }
+                )
+            );
+        }
+
+        public void Dispose() => (ServiceProvider as IDisposable)?.Dispose();
+    }
+
     [Fact]
     public async Task ResolveEventHandler_SubscriptionValidationHandler_ShouldReturnSubscriptionValidationHandler()
     {
-        var factory = new EventHandlerResolver(new List<IEventHandler>() { new SubscriptionValidationHandler() });
+        using var fixture = Fixture.Create([new SubscriptionValidationHandler()]);
+        var factory = fixture.Factory;
 
         IEventHandler eventHandler = factory.ResolveEventHandler("platform.events.validatesubscription");
 
@@ -24,7 +49,8 @@ public async Task ResolveEventHandler_SubscriptionValidationHandler_ShouldReturn
     [Fact]
     public void ResolveEventHandler_InvalidEventType_ShouldReturnUnhandledEventHandler()
     {
-        var factory = new EventHandlerResolver(new List<IEventHandler>());
+        using var fixture = Fixture.Create([]);
+        var factory = fixture.Factory;
 
         IEventHandler eventHandler = factory.ResolveEventHandler("this.event.should.not.exists");
         Action action = () => eventHandler.ProcessEvent(new CloudEvent());
@@ -37,9 +63,10 @@ public void ResolveEventHandler_InvalidEventType_ShouldReturnUnhandledEventHandl
     [Fact]
     public void ResolveEventHandler_Null_ShouldReturnUnhandledEventHandler()
     {
-        var factory = new EventHandlerResolver(new List<IEventHandler>());
+        using var fixture = Fixture.Create([]);
+        var factory = fixture.Factory;
 
-        IEventHandler eventHandler = factory.ResolveEventHandler(null);
+        IEventHandler eventHandler = factory.ResolveEventHandler(null!);
 
         eventHandler.Should().BeOfType<UnhandledEventHandler>();
     }