Add tests (#4)

Sergi0Martin · web-flow · commit 77abeb4e4b52 · 2025-04-13T19:14:00.000+02:00
* Add middleware support (#1) Add functionality for configuring and executing custom middlewares before or after commands. * update example * update example * Add tests and fix Command with response Command with response when middleware configured was not working properly * Tests done
diff --git a/.github/workflows/open-mediator-nuget-package.yml b/.github/workflows/open-mediator-nuget-package.yml
@@ -37,33 +37,32 @@ jobs:
         name: solution-build
         path: OpenMediator.*.nupkg
 
-  # tests:
-  #   name: Run tests
-  #   runs-on: ubuntu-latest
-  #   needs: [build]
-  #   steps:
-  #   - uses: actions/checkout@v4
-  #   # - name: Test
-  #   #   run: dotnet test OpenMediator.sln
-  #   - name: Test
-  #     run: dotnet test --collect:"XPlat Code Coverage" --results-directory:./CoverageResults/ OpenMediator.sln
-  #   - name: Move coverage result files
-  #     run: |
-  #       echo MOVER COVERAGE RESULTS
-  #       cp CoverageResults/*/*.xml CoverageResults/
-  #   - name: Codecov
-  #     uses: codecov/codecov-action@v3.1.0
-  #     with:
-  #       name: Code coverage report
-  #       files: CoverageResults/coverage.cobertura.xml
-  #       flags: unittests
-  #       verbose: false
+  tests:
+    name: Run tests
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Test
+      run: dotnet test OpenMediator.sln
+    - name: Test
+      run: dotnet test --collect:"XPlat Code Coverage" --results-directory:./CoverageResults/ OpenMediator.sln
+    - name: Move coverage result files
+      run: |
+        echo MOVER COVERAGE RESULTS
+        cp CoverageResults/*/*.xml CoverageResults/
+    - name: Codecov
+      uses: codecov/codecov-action@v3.1.0
+      with:
+        name: Code coverage report
+        files: CoverageResults/coverage.cobertura.xml
+        flags: unittests
+        verbose: false
 
   publish-github-package:
     name: Publish GitHub package
     runs-on: ubuntu-latest
-     # needs: [build, tests]
-    needs: [build]
+    needs: [build, tests]
     steps:
     - uses: actions/download-artifact@v4
       with:
@@ -76,8 +75,7 @@ jobs:
     name: Publish GitHub release
     if: ${{ false }}  # step disabled with false
     runs-on: ubuntu-latest
-     # needs: [build, tests]
-    needs: [build]
+    needs: [build, tests]
     steps:
     - uses: actions/download-artifact@v4
       with:
@@ -98,8 +96,7 @@ jobs:
     environment: 
       name: production
       url: https://www.nuget.org/packages/OpenMediator/
-    # needs: [build, tests]
-    needs: [build]
+    needs: [build, tests]
     steps:
     - uses: actions/download-artifact@v4
       with:
diff --git a/OpenMediator.sln b/OpenMediator.sln
@@ -16,9 +16,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{18DC
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{00CDF08F-6557-44E0-9B54-D0FC0CB1879A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenMediator.Integration.Test", "test\OpenMediator.Integration.Test\OpenMediator.Integration.Test.csproj", "{D06610C3-70D7-48FD-9075-A40CA685B58A}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenMediator.Unit.Test", "test\OpenMediator.Unit.Test\OpenMediator.Unit.Test.csproj", "{D06610C3-70D7-48FD-9075-A40CA685B58A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenMediator.Shared.Integration.Test", "test\OpenMediator.Shared.Integration.Test\OpenMediator.Shared.Integration.Test.csproj", "{2436B77B-FA64-4DF2-A93D-DA175B411C44}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenMediator.Shared.Test", "test\OpenMediator.Shared.Test\OpenMediator.Shared.Test.csproj", "{2436B77B-FA64-4DF2-A93D-DA175B411C44}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/README.md b/README.md
@@ -55,18 +55,32 @@ Also you can configure and execute custom middlewares before or after the comman
 1. Define your middleware by implementing the `IMiddleware` interface:
 
 ```csharp
-public class CustomMediatorMiddleware(ILogger<CustomMediatorMiddleware> _logger) : IMediatorMiddleware
+public class CustomMediatorMiddleware() : IMediatorMiddleware
 {
     public async Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next)
         where TCommand : ICommand
     {
         // Do something before the command
-        Task.Delay(1000).Wait();
+        await Task.Delay(500);
 
         await next();
 
         // Do something after the command
-        Task.Delay(1000).Wait();
+        await Task.Delay(500);
+    }
+
+    public async Task<TResponse> ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next)
+        where TCommand : ICommand<TResponse>
+    {
+        // Do something before the command
+        await Task.Delay(500);
+
+        var result = await next();
+
+        // Do something after the command
+        await Task.Delay(500);
+
+        return result;
     }
 }
 ```
diff --git a/examples/WebApplicationAPI/MediatorMiddleware/CustomMediatorMiddleware.cs b/examples/WebApplicationAPI/MediatorMiddleware/CustomMediatorMiddleware.cs
@@ -10,12 +10,27 @@ public async Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next)
     {
         // Do something before the command
         _logger.LogInformation("=========> Before command: {Command}", command.GetType().Name);
-        Task.Delay(1000).Wait();
+        await Task.Delay(1000);
 
         await next();
 
         // Do something after the command
         _logger.LogInformation("=========> After command: {Command}", command.GetType().Name);
-        Task.Delay(1000).Wait();
+        await Task.Delay(1000);
+    }
+
+    public Task ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next) where TCommand : ICommand<TResponse>
+    {
+        // Do something before the command
+        _logger.LogInformation("=========> Before command: {Command}", command.GetType().Name);
+        //await Task.Delay(1000);
+
+        var result = next();
+
+        // Do something after the command
+        _logger.LogInformation("=========> After command: {Command}", command.GetType().Name);
+        //await Task.Delay(1000);
+
+        return result;
     }
 }
diff --git a/examples/WebApplicationAPI/WebApplicationAPI.csproj b/examples/WebApplicationAPI/WebApplicationAPI.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.1" />
-    <PackageReference Include="OpenMediator" Version="0.0.5" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.4" />
+    <PackageReference Include="OpenMediator" Version="1.1.0" />
   </ItemGroup>
 
 </Project>
diff --git a/examples/WebApplicationAPI/WebApplicationAPI.http b/examples/WebApplicationAPI/WebApplicationAPI.http
@@ -8,3 +8,7 @@ POST {{WebApplicationAPI_HostAddress}}/api/user
 GET {{WebApplicationAPI_HostAddress}}/api/user/{{id}}
 
 ###
+
+GET {{WebApplicationAPI_HostAddress}}/api/user/{{id}}
+
+###
diff --git a/src/Buses/DefaultMediatorBus.cs b/src/Buses/DefaultMediatorBus.cs
@@ -19,9 +19,9 @@ public async Task<TResponse> SendAsync<TCommand, TResponse>(TCommand request)
     }
 
     private async Task<TResponse> ExecuteMiddlewares<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next)
-     where TCommand : ICommand<TResponse>
+        where TCommand : ICommand<TResponse>
     {
-        var middlewareTask = _middlewares.Aggregate(() => next(), (nextMiddleware, middleware) => () => (Task<TResponse>)middleware.ExecuteAsync(command, nextMiddleware));
+        var middlewareTask = _middlewares.Aggregate(() => next(), (nextMiddleware, middleware) => async () => await middleware.ExecuteAsync(command, nextMiddleware));
         return await middlewareTask();
     }
 
diff --git a/src/Middlewares/IMediatorMiddleware.cs b/src/Middlewares/IMediatorMiddleware.cs
@@ -4,5 +4,5 @@ public interface IMediatorMiddleware
 {
     Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next) where TCommand : ICommand;
 
-    Task ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next) where TCommand : ICommand<TResponse>;
+    Task<TResponse> ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next) where TCommand : ICommand<TResponse>;
 }
diff --git a/src/OpenMediator.csproj b/src/OpenMediator.csproj
@@ -11,7 +11,7 @@
 		<PackageTags>mediator;mediator-pattern</PackageTags>
 		<Description>Alternative for those who do not want to pay for a mediator implementation.</Description>
 		<Authors>Sergio Martin</Authors>
-		<Version>1.1.0</Version>
+		<Version>1.1.1</Version>
 		<RepositoryUrl>https://github.com/Sergi0Martin/OpenMediator</RepositoryUrl>
 		<PackageProjectUrl>https://sergi0martin.github.io/OpenMediator</PackageProjectUrl>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
diff --git a/test/OpenMediator.Shared.Test/Commands/CreateUserCommand.cs b/test/OpenMediator.Shared.Test/Commands/CreateUserCommand.cs
@@ -0,0 +1,12 @@
+﻿namespace OpenMediator.Shared.Test.Commands;
+
+public record CreateUserCommand(int Id, string Name) : ICommand;
+
+public record CreateUserCommandHandler(TestDependency testDependency) : ICommandHandler<CreateUserCommand>
+{
+    public async Task HandleAsync(CreateUserCommand command)
+    {
+        await Task.Delay(500);
+        testDependency.Call();
+    }
+}
diff --git a/test/OpenMediator.Shared.Test/Commands/GetUserCommand.cs b/test/OpenMediator.Shared.Test/Commands/GetUserCommand.cs
@@ -0,0 +1,19 @@
+﻿namespace OpenMediator.Shared.Test.Commands;
+
+public record GetUserCommand(int Id) : ICommand<User>;
+
+public record User(int Id, string Name, string Email);
+
+public record GetUserCommandHandler(TestDependency testDependency) : ICommandHandler<GetUserCommand, User>
+{
+    public async Task<User> HandleAsync(GetUserCommand command)
+    {
+        await Task.Delay(500);
+        testDependency.Call();
+
+        return new User(
+            Id: 1,
+            Name: "Ralph",
+            Email: "ralp@company.com");
+    }
+}
diff --git a/test/OpenMediator.Shared.Test/MediatorMiddlewares/CustomMediatorMiddleware.cs b/test/OpenMediator.Shared.Test/MediatorMiddlewares/CustomMediatorMiddleware.cs
@@ -0,0 +1,36 @@
+﻿using OpenMediator.Middlewares;
+
+namespace OpenMediator.Shared.Test.MediatorMiddlewares;
+
+public class CustomMediatorMiddleware(TestDependency testDependency) : IMediatorMiddleware
+{
+    public async Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next)
+        where TCommand : ICommand
+    {
+        // Do something before the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        await next();
+
+        // Do something after the command
+        testDependency.Call();
+        await Task.Delay(500);
+    }
+
+    public async Task<TResponse> ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next)
+        where TCommand : ICommand<TResponse>
+    {
+        // Do something before the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        var result = await next();
+
+        // Do something after the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        return result;
+    }
+}
diff --git a/test/OpenMediator.Shared.Test/MediatorMiddlewares/SecondCustomMediatorMiddleware.cs b/test/OpenMediator.Shared.Test/MediatorMiddlewares/SecondCustomMediatorMiddleware.cs
@@ -0,0 +1,36 @@
+﻿using OpenMediator.Middlewares;
+
+namespace OpenMediator.Shared.Test.MediatorMiddlewares;
+
+public class SecondCustomMediatorMiddleware(TestDependency testDependency) : IMediatorMiddleware
+{
+    public async Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next)
+        where TCommand : ICommand
+    {
+        // Do something before the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        await next();
+
+        // Do something after the command
+        testDependency.Call();
+        await Task.Delay(500);
+    }
+
+    public async Task<TResponse> ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next)
+        where TCommand : ICommand<TResponse>
+    {
+        // Do something before the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        var result = await next();
+
+        // Do something after the command
+        testDependency.Call();
+        await Task.Delay(500);
+
+        return result;
+    }
+}
diff --git a/test/OpenMediator.Shared.Test/OpenMediator.Shared.Test.csproj b/test/OpenMediator.Shared.Test/OpenMediator.Shared.Test.csproj
@@ -0,0 +1,18 @@
+﻿<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.4" />
+    <PackageReference Include="xunit.extensibility.core" Version="2.9.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\OpenMediator.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/test/OpenMediator.Shared.Test/TestDependency.cs b/test/OpenMediator.Shared.Test/TestDependency.cs
@@ -0,0 +1,12 @@
+﻿namespace OpenMediator.Shared.Test;
+
+public sealed class TestDependency
+{
+    public int Counter { get; set; }
+    public bool Called => Counter > 0;
+
+    public void Call()
+    {
+        Counter++;
+    }
+}
diff --git a/test/OpenMediator.Shared.Test/UnitTestCollection.cs b/test/OpenMediator.Shared.Test/UnitTestCollection.cs
@@ -0,0 +1,6 @@
+﻿using Xunit;
+
+namespace OpenMediator.Shared.Test;
+
+[CollectionDefinition("CommandTests")]
+public class UnitTestCollection : ICollectionFixture<UnitTestFixture> { }
diff --git a/test/OpenMediator.Shared.Test/UnitTestFixture.cs b/test/OpenMediator.Shared.Test/UnitTestFixture.cs
@@ -0,0 +1,24 @@
+﻿using Microsoft.Extensions.DependencyInjection;
+using OpenMediator.Buses;
+using OpenMediator.Shared.Test.Commands;
+
+namespace OpenMediator.Shared.Test;
+
+public class UnitTestFixture
+{
+    public readonly IServiceProvider ServiceProvider;
+    public readonly IMediatorBus Mediator;
+
+    public UnitTestFixture()
+    {
+        var testDependency = new TestDependency();
+        var services = new ServiceCollection();
+        services.AddOpenMediator(config =>
+        {
+            config.RegisterCommandsFromAssembly(typeof(CreateUserCommand).Assembly);
+        });
+        services.AddSingleton(testDependency);
+        ServiceProvider = services.BuildServiceProvider();
+        Mediator = ServiceProvider.GetService<IMediatorBus>()!;
+    }
+}
diff --git a/test/OpenMediator.Unit.Test/Commands/CommandResponseTest.cs b/test/OpenMediator.Unit.Test/Commands/CommandResponseTest.cs
diff --git a/test/OpenMediator.Unit.Test/Commands/CommandTest.cs b/test/OpenMediator.Unit.Test/Commands/CommandTest.cs
diff --git a/test/OpenMediator.Unit.Test/MediatorMiddleware/CustomMediatorMiddlewareTest.cs b/test/OpenMediator.Unit.Test/MediatorMiddleware/CustomMediatorMiddlewareTest.cs
diff --git a/test/OpenMediator.Unit.Test/OpenMediator.Unit.Test.csproj b/test/OpenMediator.Unit.Test/OpenMediator.Unit.Test.csproj

Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,9 @@ public async Task<TResponse> SendAsync<TCommand, TResponse>(TCommand request)`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`private async Task<TResponse> ExecuteMiddlewares<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next)`
`22`		`- where TCommand : ICommand<TResponse>`
	`22`	`+ where TCommand : ICommand<TResponse>`
`23`	`23`	`{`
`24`		`- var middlewareTask = _middlewares.Aggregate(() => next(), (nextMiddleware, middleware) => () => (Task<TResponse>)middleware.ExecuteAsync(command, nextMiddleware));`
	`24`	`+ var middlewareTask = _middlewares.Aggregate(() => next(), (nextMiddleware, middleware) => async () => await middleware.ExecuteAsync(command, nextMiddleware));`
`25`	`25`	`return await middlewareTask();`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,5 @@ public interface IMediatorMiddleware`
`4`	`4`	`{`
`5`	`5`	`Task ExecuteAsync<TCommand>(TCommand command, Func<Task> next) where TCommand : ICommand;`
`6`	`6`
`7`		`- Task ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next) where TCommand : ICommand<TResponse>;`
	`7`	`+ Task<TResponse> ExecuteAsync<TCommand, TResponse>(TCommand command, Func<Task<TResponse>> next) where TCommand : ICommand<TResponse>;`
`8`	`8`	`}`