Merge pull request #86 from wemogy/85-support-commandquery-definition…

…s-across-multiple-assemblies feat: #85 added support for commands and queries across multiple asse…
wemogy · Jun 3, 2024 · 3e1b3c6 · 3e1b3c6
2 parents b50d0ee + 4a57a02
commit 3e1b3c6
Show file tree

Hide file tree

Showing 12 changed files with 245 additions and 125 deletions.
diff --git a/src/Wemogy.Cqrs.sln b/src/Wemogy.Cqrs.sln
diff --git a/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Commands/TrackUserActivityCommand.cs b/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Commands/TrackUserActivityCommand.cs
@@ -0,0 +1,7 @@
+using Wemogy.CQRS.Commands.Abstractions;
+
+namespace Wemogy.CQRS.UnitTests.AssemblyA.Commands;
+
+public class TrackUserActivityCommand : ICommand
+{
+}
diff --git a/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Queries/GetUserActivityQuery.cs b/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Queries/GetUserActivityQuery.cs
@@ -0,0 +1,7 @@
+using Wemogy.CQRS.Queries.Abstractions;
+
+namespace Wemogy.CQRS.UnitTests.AssemblyA.Queries;
+
+public class GetUserActivityQuery : IQuery<int>
+{
+}
diff --git a/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Wemogy.CQRS.UnitTests.AssemblyA.csproj b/src/core/Wemogy.CQRS.UnitTests.AssemblyA/Wemogy.CQRS.UnitTests.AssemblyA.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net6.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Wemogy.CQRS\Wemogy.CQRS.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/src/core/Wemogy.CQRS.UnitTests/Commands/Mediators/CommandsMediatorTests.cs b/src/core/Wemogy.CQRS.UnitTests/Commands/Mediators/CommandsMediatorTests.cs
@@ -2,8 +2,10 @@
 using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
 using Wemogy.CQRS.Commands.Abstractions;
+using Wemogy.CQRS.UnitTests.AssemblyA.Commands;
 using Wemogy.CQRS.UnitTests.TestApplication;
 using Wemogy.CQRS.UnitTests.TestApplication.Commands.CreateUser;
+using Wemogy.CQRS.UnitTests.TestApplication.Commands.TrackUserActivity;
 using Wemogy.CQRS.UnitTests.TestApplication.Commands.TrackUserLogin;
 using Xunit;
 
@@ -48,4 +50,21 @@ public async Task RunAsync_ShouldReturnSupportVoidCommands()
         // Assert
         exception.Should().BeNull();
     }
+
+    [Fact]
+    public async Task RunAsync_ShouldSupportMultipleAssemblyDefinitions()
+    {
+        // Arrange
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddTestApplication();
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+        var commandsMediator = serviceProvider.GetRequiredService<ICommands>();
+        var createUserCommand = new TrackUserActivityCommand();
+
+        // Act
+        await commandsMediator.RunAsync(createUserCommand);
+
+        // Assert
+        TrackUserActivityCommandHandler.CalledCount.Should().Be(1);
+    }
 }
diff --git a/src/core/Wemogy.CQRS.UnitTests/Queries/Mediators/QueriesMediatorTests.cs b/src/core/Wemogy.CQRS.UnitTests/Queries/Mediators/QueriesMediatorTests.cs
@@ -4,6 +4,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Wemogy.Core.Errors.Exceptions;
 using Wemogy.CQRS.Queries.Abstractions;
+using Wemogy.CQRS.UnitTests.AssemblyA.Queries;
 using Wemogy.CQRS.UnitTests.TestApplication;
 using Wemogy.CQRS.UnitTests.TestApplication.Queries.GetUser;
 using Xunit;
@@ -68,4 +69,21 @@ public async Task QueryAsync_InvalidQueryParam_ShouldThrows()
             .And.BeOfType<FluentValidation.ValidationException>()
             .Which.Message.Should().Contain(nameof(GetUserQuery.FirstName));
     }
+
+    [Fact]
+    public async Task QueryAsync_ShouldSupportMultipleAssemblyDefinitions()
+    {
+        // Arrange
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddTestApplication();
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+        var queries = serviceProvider.GetRequiredService<IQueries>();
+        var getUserQuery = new GetUserActivityQuery();
+
+        // Act
+        var userActivity = await queries.QueryAsync(getUserQuery);
+
+        // Assert
+        userActivity.Should().Be(1);
+    }
 }
diff --git a/...S.UnitTests/TestApplication/Commands/TrackUserActivity/TrackUserActivityCommandHandler.cs b/...S.UnitTests/TestApplication/Commands/TrackUserActivity/TrackUserActivityCommandHandler.cs
@@ -0,0 +1,15 @@
+using System.Threading.Tasks;
+using Wemogy.CQRS.Commands.Abstractions;
+using Wemogy.CQRS.UnitTests.AssemblyA.Commands;
+
+namespace Wemogy.CQRS.UnitTests.TestApplication.Commands.TrackUserActivity;
+
+public class TrackUserActivityCommandHandler : ICommandHandler<TrackUserActivityCommand>
+{
+    public static int CalledCount { get; private set; }
+    public Task HandleAsync(TrackUserActivityCommand command)
+    {
+        CalledCount++;
+        return Task.CompletedTask;
+    }
+}
diff --git a/src/core/Wemogy.CQRS.UnitTests/TestApplication/DependencyInjection.cs b/src/core/Wemogy.CQRS.UnitTests/TestApplication/DependencyInjection.cs
@@ -3,6 +3,7 @@
 using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
 using Wemogy.CQRS.Setup;
+using Wemogy.CQRS.UnitTests.AssemblyA.Commands;
 using Wemogy.CQRS.UnitTests.TestApplication.Common.Contexts;
 
 namespace Wemogy.CQRS.UnitTests.TestApplication;
@@ -19,7 +20,8 @@ public static CQRSSetupEnvironment AddTestApplication(this IServiceCollection se
             new List<Assembly>()
             {
                 Assembly.GetCallingAssembly(),
-                Assembly.GetExecutingAssembly()
+                Assembly.GetExecutingAssembly(),
+                typeof(TrackUserActivityCommand).Assembly
             },
             new Dictionary<Type, Type>()
             {

diff --git a/...ogy.CQRS.UnitTests/TestApplication/Queries/GetUserActivity/GetUserActivityQueryHandler.cs b/...ogy.CQRS.UnitTests/TestApplication/Queries/GetUserActivity/GetUserActivityQueryHandler.cs
@@ -0,0 +1,14 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Wemogy.CQRS.Queries.Abstractions;
+using Wemogy.CQRS.UnitTests.AssemblyA.Queries;
+
+namespace Wemogy.CQRS.UnitTests.TestApplication.Queries.GetUserActivity;
+
+public class GetUserActivityQueryHandler : IQueryHandler<GetUserActivityQuery, int>
+{
+    public Task<int> HandleAsync(GetUserActivityQuery query, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(1);
+    }
+}
diff --git a/src/core/Wemogy.CQRS.UnitTests/Wemogy.CQRS.UnitTests.csproj b/src/core/Wemogy.CQRS.UnitTests/Wemogy.CQRS.UnitTests.csproj
@@ -23,5 +23,6 @@
 
   <ItemGroup>
     <ProjectReference Include="../Wemogy.CQRS/Wemogy.CQRS.csproj" />
+    <ProjectReference Include="..\Wemogy.CQRS.UnitTests.AssemblyA\Wemogy.CQRS.UnitTests.AssemblyA.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/core/Wemogy.CQRS/DependencyInjection.cs b/src/core/Wemogy.CQRS/DependencyInjection.cs
@@ -47,6 +47,9 @@ public static CQRSSetupEnvironment AddCQRS(
         List<Assembly> assemblies,
         Dictionary<Type, Type>? dependencies = null)
     {
+        // remove duplicates from assemblies, which can happen, if Assembly.GetCallingAssembly() and Assembly.GetExecutingAssembly() are both added
+        assemblies = assemblies.Distinct().ToList();
+
         dependencies ??= new Dictionary<Type, Type>();
         serviceCollection.AddCommands(assemblies, dependencies);
         serviceCollection.AddQueries(assemblies);
@@ -60,7 +63,6 @@ private static void AddCommands(this IServiceCollection serviceCollection, List<
 
         foreach (var commandType in commandTypes)
         {
-            var assembly = commandType.Assembly;
             if (!commandType.InheritsOrImplements(typeof(ICommand<>), out Type? genericCommandType) || genericCommandType == null)
             {
                 if (!commandType.InheritsOrImplements(typeof(ICommand), out genericCommandType) || genericCommandType == null)
@@ -72,27 +74,27 @@ private static void AddCommands(this IServiceCollection serviceCollection, List<
             var resultType = genericCommandType.GenericTypeArguments.ElementAtOrDefault(0);
 
             // pre-processing
-            serviceCollection.AddPreProcessing(assembly, commandType);
+            serviceCollection.AddPreProcessing(assemblies, commandType);
 
             if (resultType == null)
             {
                 // command handler
                 serviceCollection.AddScopedGenericTypeWithImplementationFromAssembly(
-                    assembly,
+                    assemblies,
                     typeof(ICommandHandler<>),
                     commandType);
 
                 // command runners
                 serviceCollection.AddCommandRunners(commandType);
 
                 // post-processing
-                serviceCollection.AddPostProcessing(assembly, commandType);
+                serviceCollection.AddPostProcessing(assemblies, commandType);
             }
             else
             {
                 // command handler
                 serviceCollection.AddScopedGenericTypeWithImplementationFromAssembly(
-                    assembly,
+                    assemblies,
                     typeof(ICommandHandler<,>),
                     commandType,
                     resultType);
@@ -101,14 +103,15 @@ private static void AddCommands(this IServiceCollection serviceCollection, List<
                 serviceCollection.AddCommandRunners(commandType, resultType);
 
                 // post-processing
-                serviceCollection.AddPostProcessing(assembly, commandType, resultType);
+                serviceCollection.AddPostProcessing(assemblies, commandType, resultType);
             }
         }
 
         // ScheduledCommandDependencyResolver
         serviceCollection.AddSingleton(
             new ScheduledCommandDependencies(dependencies));
-        serviceCollection.AddScoped<IScheduledCommandDependencyResolver>(provider =>
+        serviceCollection.AddScoped<IScheduledCommandDependencyResolver>(
+            provider =>
             new ScheduledCommandDependencyResolver(provider, dependencies));
 
         // Add ICommands mediator
@@ -126,7 +129,6 @@ private static void AddQueries(this IServiceCollection serviceCollection, List<A
 
         foreach (var queryType in queryTypes)
         {
-            var assembly = queryType.Assembly;
             if (!queryType.InheritsOrImplements(typeof(IQuery<>), out Type? genericQueryType) || genericQueryType == null)
             {
                 throw new Exception("Query type must inherit from IQuery<>");
@@ -135,14 +137,14 @@ private static void AddQueries(this IServiceCollection serviceCollection, List<A
             var resultType = genericQueryType.GenericTypeArguments[0];
 
             // validators
-            serviceCollection.AddImplementationCollection(assembly, queryType, typeof(IQueryValidator<>));
+            serviceCollection.AddImplementationCollection(assemblies, queryType, typeof(IQueryValidator<>));
 
             // authorization
-            serviceCollection.AddImplementationCollection(assembly, queryType, typeof(IQueryAuthorization<>));
+            serviceCollection.AddImplementationCollection(assemblies, queryType, typeof(IQueryAuthorization<>));
 
             // handlers
             var queryHandlerType = typeof(IQueryHandler<,>).MakeGenericType(queryType, resultType);
-            var queryHandlers = assembly.GetClassTypesWhichImplementInterface(queryHandlerType);
+            var queryHandlers = assemblies.GetClassTypesWhichImplementInterface(queryHandlerType);
             if (queryHandlers.Count != 1)
             {
                 throw new Exception(
@@ -185,31 +187,31 @@ private static void AddImplementation(
 
     private static void AddPreProcessing(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type commandType)
     {
         // validators
-        serviceCollection.AddImplementationCollection(assembly, commandType, typeof(ICommandValidator<>));
+        serviceCollection.AddImplementationCollection(assemblies, commandType, typeof(ICommandValidator<>));
 
         // authorization
-        serviceCollection.AddImplementationCollection(assembly, commandType, typeof(ICommandAuthorization<>));
+        serviceCollection.AddImplementationCollection(assemblies, commandType, typeof(ICommandAuthorization<>));
 
         // pre-processors
-        serviceCollection.AddImplementationCollection(assembly, commandType, typeof(ICommandPreProcessor<>));
+        serviceCollection.AddImplementationCollection(assemblies, commandType, typeof(ICommandPreProcessor<>));
 
         // PreProcessingRunner
         serviceCollection.AddImplementation(typeof(PreProcessingRunner<>), commandType);
     }
 
     private static void AddPostProcessing(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type commandType,
         Type resultType)
     {
         // validators
         serviceCollection.AddImplementationCollection(
-            assembly,
+            assemblies,
             commandType,
             resultType,
             typeof(ICommandPostProcessor<,>));
@@ -220,12 +222,12 @@ private static void AddPostProcessing(
 
     private static void AddPostProcessing(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type commandType)
     {
         // validators
         serviceCollection.AddImplementationCollection(
-            assembly,
+            assemblies,
             commandType,
             typeof(ICommandPostProcessor<>));
 
@@ -282,14 +284,16 @@ private static void AddCommandRunners(
 
     private static void AddImplementationCollection(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type commandType,
         Type genericInterfaceType)
     {
         var interfaceType = genericInterfaceType.MakeGenericType(commandType);
-        var implementationTypes = assembly.GetClassTypesWhichImplementInterface(interfaceType);
+        var implementationTypes = assemblies.GetClassTypesWhichImplementInterface(interfaceType);
         var implementationCollectionType = typeof(List<>).MakeGenericType(interfaceType);
-        serviceCollection.AddScoped(implementationCollectionType, serviceProvider =>
+        serviceCollection.AddScoped(
+            implementationCollectionType,
+            serviceProvider =>
         {
             var implementationInstances =
                 implementationTypes
@@ -301,15 +305,17 @@ private static void AddImplementationCollection(
 
     private static void AddImplementationCollection(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type commandType,
         Type resultType,
         Type genericInterfaceType)
     {
         var interfaceType = genericInterfaceType.MakeGenericType(commandType, resultType);
-        var implementationTypes = assembly.GetClassTypesWhichImplementInterface(interfaceType);
+        var implementationTypes = assemblies.GetClassTypesWhichImplementInterface(interfaceType);
         var implementationCollectionType = typeof(List<>).MakeGenericType(interfaceType);
-        serviceCollection.AddScoped(implementationCollectionType, serviceProvider =>
+        serviceCollection.AddScoped(
+            implementationCollectionType,
+            serviceProvider =>
         {
             var implementationInstances =
                 implementationTypes

diff --git a/src/core/Wemogy.CQRS/Extensions/ServiceCollectionExtensions.cs b/src/core/Wemogy.CQRS/Extensions/ServiceCollectionExtensions.cs
@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
+using Wemogy.Core.Errors;
 using Wemogy.Core.Extensions;
 
 namespace Wemogy.CQRS.Extensions;
@@ -18,16 +21,18 @@ public static void AddScopedGenericType(
 
     public static void AddScopedGenericTypeWithImplementationFromAssembly(
         this IServiceCollection serviceCollection,
-        Assembly assembly,
+        List<Assembly> assemblies,
         Type genericType,
         params Type[] genericTypeArguments)
     {
         var serviceType = genericType.MakeGenericType(genericTypeArguments);
-        var serviceImplementations = assembly.GetClassTypesWhichImplementInterface(serviceType);
+        var serviceImplementations = assemblies.GetClassTypesWhichImplementInterface(serviceType);
+
         if (serviceImplementations.Count != 1)
         {
-            throw new Exception(
-                $"There must be exactly one {serviceType.FullName} registered in {assembly.FullName}.");
+            throw Error.Unexpected(
+                "InvalidServiceImplementation",
+                $"There must be exactly one {serviceType.FullName} declared in the assemblies.");
         }
 
         var serviceImplementationType = serviceImplementations[0];