More thoughts & CI tests

.github/workflows/build.yml

@@ -49,6 +49,9 @@ jobs:
     - name: Build
       run: dotnet build Build.slnf /restore -m -property:Configuration=Release -property:PublicRelease=true
 
+    - name: Test
+      run: dotnet test tests/Shiny.Mediator.Tests/Shiny.Mediator.Tests.csproj --no-restore --verbosity normal
+
     - name: Post NuGet Artifacts
       uses: actions/upload-artifact@v2
       with:

readme.md

@@ -168,3 +168,5 @@ Focus on the interfaces from the mediator & the mediator calls itself
 * Explain Event Handlers 
 * Streams - IAsyncEnumerable or IObservable
 * Source Generator Registration
+  * Need to use a different method or not use extension methods - maybe AddHandlersFromAssemblyName or allow it to be custom named 
+* IEventHandler<IEvent> can handle ALL events?

src/Directory.build.props

@@ -8,10 +8,10 @@
         <EnableDefaultCompileItems>true</EnableDefaultCompileItems>
         <Description>Shiny Mediator - a mediator pattern but for apps</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
-        <PackageProjectUrl>https://shinylib.net</PackageProjectUrl>
+        <PackageProjectUrl>https://github.com/shinyorg/mediator</PackageProjectUrl>
         <PackageIcon>icon.png</PackageIcon>
         <PackageReadmeFile>readme.md</PackageReadmeFile>
-        <PackageReleaseNotes>https://shinylib.net</PackageReleaseNotes>
+        <PackageReleaseNotes>https://github.com/shinyorg/mediator</PackageReleaseNotes>
         <PackageTags>mediator maui blazor</PackageTags>
         <RepositoryUrl>https://github.com/shinyorg/mediator</RepositoryUrl>
         <RepositoryType>git</RepositoryType>

src/Shiny.Mediator/IEventExceptionHandler.cs

@@ -0,0 +1,13 @@
+namespace Shiny.Mediator;
+
+public interface IEventExceptionHandler
+{
+    Task Process(EventExceptionContext context);
+}
+
+public record EventExceptionContext(
+    IEvent Event,
+    Exception Exception,
+    bool FireAndForget,  // you may wish to propagate the exception out if events are being await for completion 
+    bool Handled
+);

src/Shiny.Mediator/IRequestExceptionHandler.cs

@@ -0,0 +1,22 @@
+namespace Shiny.Mediator;
+
+public interface IRequestExceptionrHandler
+{
+    // should this be abortable or even async?
+    Task Handle(RequestExceptionContext context, CancellationToken cancellationToken);
+}
+
+// what about events?
+public class RequestExceptionContext
+{
+    public RequestExceptionContext(object request, Exception exception)
+    {
+        this.Request = request;
+        this.Exception = exception;
+    }
+
+
+    public object Request { get; }
+    public Exception Exception { get; }
+    public bool Handled { get; set; }
+}

src/Shiny.Mediator/IRequestMiddleware.cs

@@ -1,10 +1,13 @@
-// namespace Shiny.Mediator;
-//
-// public interface IRequestMiddle<TRequest> where TRequest : notnull, IRequest
-// {
-//     Task Process(TRequest request, IRequestPipeline<TRequest> next, CancellationToken cancellationToken);
-// }
-//
-//
-// public record RequestDelegate(object Request);
+using Shiny.Mediator;
 
+// TODO: how do I register an "ALL" middleware
+
+// TODO: execution duration timer
+
+// TODO: catch all could be IRequest or IRequest<T>?  Could use an IRequest<Void>?
+public interface IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
+{
+    // intercept with connectivity, if offline go to cache, if online go to remote
+    // if went to remote, post execute stores to cache
+    Task<TResult> Process(TRequest request, IRequestHandler<TRequest, TResult> handler);
+}

src/Shiny.Mediator/Impl/Mediator.cs

@@ -15,6 +15,7 @@ IEnumerable<IEventCollector> collectors
 
     public async Task Send<TRequest>(TRequest request, CancellationToken cancellationToken = default) where TRequest : IRequest
     {
+        // TODO: middleware execution should support contravariance
         using var scope = services.CreateScope();
         var handlers = scope.ServiceProvider.GetServices<IRequestHandler<TRequest>>().ToList();
         AssertRequestHandlers(handlers.Count, request);
@@ -31,6 +32,7 @@ public async Task<TResult> Send<TResult>(IRequest<TResult> request, Cancellation
     {
         var handlerType = typeof(IRequestHandler<,>).MakeGenericType(request.GetType(), typeof(TResult));
 
+        // TODO: middleware execution should support contravariance
         using var scope = services.CreateScope();
         var handlers = scope.ServiceProvider.GetServices(handlerType).ToList();
         AssertRequestHandlers(handlers.Count, request);
@@ -39,8 +41,7 @@ public async Task<TResult> Send<TResult>(IRequest<TResult> request, Cancellation
         var handleMethod = handlerType.GetMethod("Handle", BindingFlags.Instance | BindingFlags.Public)!;
         var resultTask = (Task<TResult>)handleMethod.Invoke(handler, [request, cancellationToken])!;
         var result = await resultTask.ConfigureAwait(false);
-
-        // TODO: pipelines
+
         return result;
     }
 
@@ -55,6 +56,8 @@ public async Task Publish<TEvent>(
         // allow registered services to be transient/scoped/singleton
         using var scope = services.CreateScope();
         var handlers = scope.ServiceProvider.GetServices<IEventHandler<TEvent>>().ToList();
+        //var globalHandlers = scope.ServiceProvider.GetServices<IEventHandler<IEvent>>().ToList();
+
         AppendHandlersIf(handlers, this.subscriptions);
         foreach (var collector in collectors)
             AppendHandlersIf(handlers, collector);
@@ -65,7 +68,6 @@ public async Task Publish<TEvent>(
         Task executor = null!;
         if (executeInParallel)
         {
-            // TODO: pipelines? error management?
             executor = Task.WhenAll(handlers.Select(x => x.Handle(@event, cancellationToken)).ToList());
         }
         else
@@ -85,7 +87,7 @@ await handler
             });
         }
 
-        // TODO: pipelines
+        // TODO: middleware
         if (fireAndForget)
         {
             this.FireAndForget(executor);
@@ -121,13 +123,10 @@ async void FireAndForget(Task task)
     static void AppendHandlersIf<TEvent>(List<IEventHandler<TEvent>> list, IEventCollector collector) where TEvent : IEvent
     {
         var handlers = collector.GetHandlers<TEvent>();
-        if (handlers.Count > 0)
+        foreach (var handler in handlers)
         {
-            foreach (var handler in handlers)
-            {
-                if (!list.Contains(handler))
-                    list.Add(handler);
-            }
+            if (!list.Contains(handler))
+                list.Add(handler);
         }
     }
 

src/Shiny.Mediator/Middleware/TimedMiddleware.cs

@@ -0,0 +1,9 @@
+// namespace Shiny.Mediator.Middleware;
+//
+// public class TimedMiddleware<IRequest<TResult>> : IRequestMiddleware<IRequest<TResult>>
+// {
+//     public Task Process(IRequest request, IRequestHandler<IRequest> handler)
+//     {
+//         throw new NotImplementedException();
+//     }
+// }

src/Shiny.Mediator/Unit.cs

@@ -0,0 +1,6 @@
+namespace Shiny.Mediator;
+
+public sealed class Unit
+{
+    public static Unit Value { get; } = new();
+}

tests/Shiny.Mediator.Tests/MediatorTests.cs → tests/Shiny.Mediator.Tests/EventHandlerTests.cs

@@ -1,11 +1,16 @@
-using System.Diagnostics;
-using FluentAssertions;
+
 
 namespace Shiny.Mediator.Tests;
 
 
-public class MediatorTests
+public class EventHandlerTests
 {
+    public EventHandlerTests()
+    {
+        CatchAllEventHandler.Executed = false;
+    }
+
+
     [Theory]
     [InlineData(10000, 1000, false, true, false)]
     [InlineData(3000, 6000, true, false, false)]
@@ -29,52 +34,7 @@ public async Task Events_TriggerTypes(int delayMs, int expectedTime, bool timeIs
         else
             sw.ElapsedMilliseconds.Should().BeLessOrEqualTo(expectedTime);
     }
-
-
-    [Fact]
-    public async Task Missing_RequestHandler()
-    {
-        try
-        {
-            var services = new ServiceCollection();
-            services.AddShinyMediator();
-            var sp = services.BuildServiceProvider();
-            var mediator = sp.GetRequiredService<IMediator>();
-            await mediator.Send(new TestRequest());
-            Assert.Fail("This should not have passed");
-        }
-        catch (InvalidOperationException ex)
-        {
-            ex.Message.Should().Be("No request handler found for Shiny.Mediator.Tests.TestRequest");
-        }
-    }
 
-    [Fact]
-    public async Task Registration_OnlyOneRequestHandler_NoResponse()
-    {
-        try
-        {
-            var services = new ServiceCollection();
-            services.AddShinyMediator();
-            services.AddSingletonAsImplementedInterfaces<Test1RequestHandler>();
-            services.AddSingletonAsImplementedInterfaces<Test2RequestHandler>();
-            var sp = services.BuildServiceProvider();
-            var mediator = sp.GetRequiredService<IMediator>();
-            await mediator.Send(new TestRequest());
-            Assert.Fail("This should not have passed");
-        }
-        catch (InvalidOperationException ex)
-        {
-            ex.Message.Should().Be("More than 1 request handlers found for Shiny.Mediator.Tests.TestRequest");
-        }
-    }
-
-    // [Fact]
-    // public void Registration_OnlyOneRequestHandler_WithResponse()
-    // {
-    //     
-    // }
-
 
     [Fact]
     public async Task Events_SubscriptionFired()
@@ -85,7 +45,7 @@ public async Task Events_SubscriptionFired()
         var mediator = sp.GetRequiredService<IMediator>();
 
         var tcs = new TaskCompletionSource();
-        mediator.Subscribe<TestEvent>((@event, ct) =>
+        mediator.Subscribe<TestEvent>((_, _) =>
         {
             tcs.SetResult();
             return Task.CompletedTask;
@@ -94,37 +54,27 @@ public async Task Events_SubscriptionFired()
         await mediator.Publish(new TestEvent());
         tcs.Task.IsCompletedSuccessfully.Should().BeTrue();
     }
-}
 
 
-public class TestRequest : IRequest
-{
-    public int Delay { get; set; }
+    [Fact]
+    public async Task Events_CatchAllHandler()
+    {
+        // TODO: test against event collectors as well
+        var services = new ServiceCollection();
+        services.AddShinyMediator();
+        services.AddSingletonAsImplementedInterfaces<CatchAllEventHandler>();
+        var sp = services.BuildServiceProvider();
+        var mediator = sp.GetRequiredService<IMediator>();
+
+        await mediator.Publish(new TestEvent());
+        CatchAllEventHandler.Executed.Should().BeTrue();
+    }    
 }
 
 public class TestEvent : IEvent
 {
     public int Delay { get; set; }
 }
-
-
-public class Test1RequestHandler : IRequestHandler<TestRequest>
-{
-    public async Task Handle(TestRequest request, CancellationToken cancellationToken)
-    {
-        if (request.Delay > 0)
-            await Task.Delay(request.Delay);
-    }
-}
-
-
-public class Test2RequestHandler : IRequestHandler<TestRequest>
-{
-    public async Task Handle(TestRequest request, CancellationToken cancellationToken)
-    {
-    }
-}
-
 public class Test1EventHandler : IEventHandler<TestEvent>
 {
     public async Task Handle(TestEvent @event, CancellationToken cancellationToken)
@@ -140,4 +90,14 @@ public async Task Handle(TestEvent @event, CancellationToken cancellationToken)
         if (@event.Delay > 0)
             await Task.Delay(@event.Delay);
     }
+}
+
+public class CatchAllEventHandler : IEventHandler<IEvent>
+{
+    public static bool Executed { get; set; }
+    public Task Handle(IEvent @event, CancellationToken cancellationToken)
+    {
+        Executed = true;
+        return Task.CompletedTask;
+    }
 }

tests/Shiny.Mediator.Tests/GlobalUsings.cs

@@ -1,3 +1,5 @@
 global using Xunit;
 global using Shiny.Mediator;
 global using Microsoft.Extensions.DependencyInjection;
+global using System.Diagnostics;
+global using FluentAssertions;