Dependency Injection tests for various providers

MediatR.sln

@@ -48,6 +48,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MediatR.Examples.SimpleInje
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MediatR.Examples.Stashbox", "samples\MediatR.Examples.Stashbox\MediatR.Examples.Stashbox.csproj", "{F9148E20-5856-484C-8410-B515C6C56214}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MediatR.DependencyInjectionTests", "test\MediatR.DependencyInjectionTests\MediatR.DependencyInjectionTests.csproj", "{C761C0E2-0655-40FB-98E9-1504D03DD930}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -106,6 +108,10 @@ Global
 		{F9148E20-5856-484C-8410-B515C6C56214}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F9148E20-5856-484C-8410-B515C6C56214}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F9148E20-5856-484C-8410-B515C6C56214}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C761C0E2-0655-40FB-98E9-1504D03DD930}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C761C0E2-0655-40FB-98E9-1504D03DD930}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C761C0E2-0655-40FB-98E9-1504D03DD930}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C761C0E2-0655-40FB-98E9-1504D03DD930}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -124,6 +130,7 @@ Global
 		{004D029A-43E7-47B0-BA74-D0A9F7FC7713} = {E372BF0B-90E8-4DC1-A332-F023095A3C2A}
 		{7CEB57F2-B6DC-4A18-A040-D12555C3D32F} = {E372BF0B-90E8-4DC1-A332-F023095A3C2A}
 		{F9148E20-5856-484C-8410-B515C6C56214} = {E372BF0B-90E8-4DC1-A332-F023095A3C2A}
+		{C761C0E2-0655-40FB-98E9-1504D03DD930} = {962C5ACA-AB2B-4E9B-9EBB-7E7EE28CDBB1}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {D58286E3-878B-4ACB-8E76-F61E708D4339}

test/MediatR.DependencyInjectionTests/Abstractions/BaseAssemblyResolutionTests.cs

@@ -0,0 +1,66 @@
+using MediatR.DependencyInjectionTests.Contracts.Notifications;
+using MediatR.DependencyInjectionTests.Contracts.StreamRequests;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MediatR.DependencyInjectionTests.Abstractions;
+
+public abstract class BaseAssemblyResolutionTests(BaseServiceProviderFixture fixture) : IClassFixture<BaseServiceProviderFixture>
+{
+    private readonly IServiceProvider _provider = fixture.Provider;
+
+    [Fact]
+    public void Should_Resolve_Mediator() =>
+        _provider.GetService<IMediator>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Public_RequestHandler() =>
+        _provider.GetService<IRequestHandler<PublicPing, Pong>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Internal_RequestHandler() =>
+        _provider.GetService<IRequestHandler<InternalPing, Pong>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Private_RequestHandler() =>
+        _provider.GetService<IRequestHandler<PrivatePing, Pong>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Public_Void_RequestHandler() =>
+        _provider.GetService<IRequestHandler<PublicVoidPing>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Internal_Void_RequestHandler() =>
+        _provider.GetService<IRequestHandler<InternalVoidPing>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Private_Void_RequestHandler() =>
+        _provider.GetService<IRequestHandler<PrivateVoidPing>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Public_Private_Internal_Notification_Handlers() =>
+        _provider.GetServices<INotificationHandler<Ding>>()
+            .Count()
+            .ShouldBe(3);
+
+    [Fact]
+    public void Should_Resolve_Public_Stream_Request_Handlers() =>
+        _provider.GetService<IStreamRequestHandler<PublicZing, Zong>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Internal_Stream_Request_Handlers() =>
+        _provider.GetService<IStreamRequestHandler<InternalZing, Zong>>()
+            .ShouldNotBeNull();
+
+    [Fact]
+    public void Should_Resolve_Private_Stream_Request_Handlers() =>
+        _provider.GetService<IStreamRequestHandler<PrivateZing, Zong>>()
+            .ShouldNotBeNull();
+}

test/MediatR.DependencyInjectionTests/Abstractions/BaseServiceProviderFixture.cs

@@ -0,0 +1,6 @@
+namespace MediatR.DependencyInjectionTests.Abstractions;
+
+public class BaseServiceProviderFixture
+{
+    public virtual IServiceProvider Provider => throw new NotImplementedException();
+}

test/MediatR.DependencyInjectionTests/AutoFacDependencyInjectionTests.cs

@@ -0,0 +1,9 @@
+using MediatR.DependencyInjectionTests.Abstractions;
+using MediatR.DependencyInjectionTests.Providers;
+
+namespace MediatR.DependencyInjectionTests;
+
+public class AutoFacDependencyInjectionTests : BaseAssemblyResolutionTests
+{
+    public AutoFacDependencyInjectionTests() : base(new AutoFacServiceProviderFixture()) { }
+}

test/MediatR.DependencyInjectionTests/Contracts/Notifications/Ding.cs

@@ -0,0 +1,22 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Notifications;
+
+public record Ding : INotification
+{
+    public class Door1 : INotificationHandler<Ding>
+    {
+        public Task Handle(Ding notification, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+
+    internal class Door2 : INotificationHandler<Ding>
+    {
+        public Task Handle(Ding notification, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+
+    private class Door3 : INotificationHandler<Ding>
+    {
+        public Task Handle(Ding notification, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/InternalPing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+internal record InternalPing : IRequest<Pong>
+{
+    internal class Handler : IRequestHandler<InternalPing, Pong>
+    {
+        public Task<Pong> Handle(InternalPing request, CancellationToken cancellationToken) =>
+            Task.FromResult(new Pong());
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/InternalVoidPing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+internal record InternalVoidPing : IRequest
+{
+    internal class Handler : IRequestHandler<InternalVoidPing>
+    {
+        public Task Handle(InternalVoidPing request, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/PrivatePing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+public record PrivatePing : IRequest<Pong>
+{
+    private class Handler : IRequestHandler<PrivatePing, Pong>
+    {
+        public Task<Pong> Handle(PrivatePing request, CancellationToken cancellationToken) =>
+            Task.FromResult(new Pong());
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/PrivateVoidPing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+public record PrivateVoidPing : IRequest
+{
+    private class Handler : IRequestHandler<PrivateVoidPing>
+    {
+        public Task Handle(PrivateVoidPing request, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/PublicPing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+public record PublicPing : IRequest<Pong>
+{
+    public class Handler : IRequestHandler<PublicPing, Pong>
+    {
+        public Task<Pong> Handle(PublicPing request, CancellationToken cancellationToken) =>
+            Task.FromResult(new Pong());
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Requests/PublicVoidPing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Requests;
+
+public record PublicVoidPing : IRequest
+{
+    public class Handler : IRequestHandler<PublicVoidPing>
+    {
+        public Task Handle(PublicVoidPing request, CancellationToken cancellationToken) =>
+            Task.CompletedTask;
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/Responses/Pong.cs

@@ -0,0 +1,4 @@
+namespace MediatR.DependencyInjectionTests.Contracts.Responses;
+
+public record Pong;
+public record Zong;

test/MediatR.DependencyInjectionTests/Contracts/StreamRequests/InternalZing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.StreamRequests;
+
+internal record InternalZing : IStreamRequest<Zong>
+{
+    internal class Handler : IStreamRequestHandler<InternalZing, Zong>
+    {
+        public IAsyncEnumerable<Zong> Handle(InternalZing request, CancellationToken token) =>
+            throw new NotImplementedException();
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/StreamRequests/PrivateZing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.StreamRequests;
+
+internal record PrivateZing : IStreamRequest<Zong>
+{
+    private class Handler : IStreamRequestHandler<PrivateZing, Zong>
+    {
+        public IAsyncEnumerable<Zong> Handle(PrivateZing request, CancellationToken token) =>
+            throw new NotImplementedException();
+    }
+}

test/MediatR.DependencyInjectionTests/Contracts/StreamRequests/PublicZing.cs

@@ -0,0 +1,10 @@
+namespace MediatR.DependencyInjectionTests.Contracts.StreamRequests;
+
+public record PublicZing : IStreamRequest<Zong>
+{
+    public class Handler : IStreamRequestHandler<PublicZing, Zong>
+    {
+        public IAsyncEnumerable<Zong> Handle(PublicZing request, CancellationToken token) =>
+            throw new NotImplementedException();
+    }
+}

test/MediatR.DependencyInjectionTests/DryIocDependencyInjectionTests.cs

@@ -0,0 +1,7 @@
+using MediatR.DependencyInjectionTests.Abstractions;
+using MediatR.DependencyInjectionTests.Providers;
+
+namespace MediatR.DependencyInjectionTests;
+
+public class DryIocDependencyInjectionTests() 
+    : BaseAssemblyResolutionTests(new DryIocServiceProviderFixture());

test/MediatR.DependencyInjectionTests/MediatR.DependencyInjectionTests.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\src\MediatR\MediatR.csproj"/>
+    </ItemGroup>
+
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
+        <PackageReference Include="Shouldly" Version="4.2.1"/>
+        <PackageReference Include="xunit" Version="2.5.3"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3"/>
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0"/>
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.0"/>
+        <PackageReference Include="Microsoft.Extensions.Diagnostics.Testing" Version="8.0.0"/>
+        <PackageReference Include="DryIoc.Microsoft.DependencyInjection" Version="6.2.0"/>
+        <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="8.0.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="Xunit"/>
+    </ItemGroup>
+
+</Project>

test/MediatR.DependencyInjectionTests/MicrosoftDependencyInjectionTests.cs

@@ -0,0 +1,9 @@
+using MediatR.DependencyInjectionTests.Abstractions;
+using MediatR.DependencyInjectionTests.Providers;
+
+namespace MediatR.DependencyInjectionTests;
+
+public class MicrosoftDependencyInjectionTests : BaseAssemblyResolutionTests
+{
+    public MicrosoftDependencyInjectionTests() : base(new MicrosoftServiceProviderFixture()) { }
+}

test/MediatR.DependencyInjectionTests/Providers/AutoFacServiceProviderFixture.cs

@@ -0,0 +1,25 @@
+using Autofac;
+using Autofac.Extensions.DependencyInjection;
+using MediatR.DependencyInjectionTests.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MediatR.DependencyInjectionTests.Providers;
+
+public class AutoFacServiceProviderFixture : BaseServiceProviderFixture
+{
+    public override IServiceProvider Provider
+    {
+        get
+        {
+            var services = new ServiceCollection();
+            services.AddFakeLogging();
+            services.AddMediatR(x => x.RegisterServicesFromAssemblyContaining(typeof(Pong)));
+
+            var builder = new ContainerBuilder();
+            builder.Populate(services);
+
+            var container = builder.Build();
+            return new AutofacServiceProvider(container);
+        }
+    }
+}

test/MediatR.DependencyInjectionTests/Providers/DryIocServiceProviderFixture.cs

@@ -0,0 +1,23 @@
+using DryIoc;
+using DryIoc.Microsoft.DependencyInjection;
+using MediatR.DependencyInjectionTests.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MediatR.DependencyInjectionTests.Providers;
+
+public class DryIocServiceProviderFixture : BaseServiceProviderFixture
+{
+    public override IServiceProvider Provider
+    {
+        get
+        {
+            var services = new ServiceCollection();
+            services.AddFakeLogging();
+            services.AddMediatR(x => x.RegisterServicesFromAssemblyContaining(typeof(Pong)));
+
+            var container = new Container(Rules.MicrosoftDependencyInjectionRules);
+            container.WithDependencyInjectionAdapter(services);
+            return container.BuildServiceProvider();
+        }
+    }
+}

test/MediatR.DependencyInjectionTests/Providers/MicrosoftServiceProviderFixture.cs

@@ -0,0 +1,12 @@
+using MediatR.DependencyInjectionTests.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MediatR.DependencyInjectionTests.Providers;
+
+public class MicrosoftServiceProviderFixture : BaseServiceProviderFixture
+{
+    public override IServiceProvider Provider => new ServiceCollection()
+        .AddFakeLogging()
+        .AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(PublicPing).Assembly))
+        .BuildServiceProvider();
+}

test/MediatR.DependencyInjectionTests/Usings.cs

@@ -0,0 +1,3 @@
+global using MediatR.DependencyInjectionTests.Contracts.Requests;
+global using MediatR.DependencyInjectionTests.Contracts.Responses;
+global using Shouldly;