feat: create request projects for basic CQRS

src/request.dispatcher.tests/.editorconfig

@@ -0,0 +1,15 @@
+
+[*.{cs,vb}]
+# disable CA1822: Mark members as static
+# -> TUnit requiring instance methods for test cases
+dotnet_diagnostic.CA1822.severity = none
+# disable CA1707: Identifiers should not contain underscores
+dotnet_diagnostic.CA1707.severity = none
+# disable IDE0060: Remove unused parameter
+dotnet_diagnostic.IDE0060.severity = none
+# disable IDE0005: Unnecessary using directive
+dotnet_diagnostic.IDE0005.severity = none
+# disable IDE0390: Method can be made synchronous
+dotnet_diagnostic.IDE0390.severity = none
+# disable IDE0391: Method can be made synchronous
+dotnet_diagnostic.IDE0391.severity = none

src/request.dispatcher.tests/Geekeey.Request.Dispatcher.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TUnit" />
+    <!-- additional packages -->
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Remove="_fixtures/roslyn/**/*.cs" />
+    <EmbeddedResource Include="_fixtures/roslyn/**/*.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\request.dispatcher\Geekeey.Request.Dispatcher.csproj" />
+  </ItemGroup>
+
+</Project>

src/request.dispatcher.tests/PackageContentsTests.cs

@@ -0,0 +1,49 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Diagnostics;
+using System.IO.Compression;
+
+namespace Geekeey.Request.Tests;
+
+internal sealed class PackageContentsTests
+{
+	private static string RepoRoot => Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..");
+	private static string ArtifactsDir => Path.Combine(RepoRoot, "artifacts");
+	private static string ProjectPath => Path.Combine(RepoRoot, "src", "request.dispatcher", "Geekeey.Request.Dispatcher.csproj");
+
+	private readonly string _outputDir;
+
+	public PackageContentsTests()
+	{
+		_outputDir = Path.Combine(ArtifactsDir, Path.GetRandomFileName());
+	}
+
+	[Before(Test)]
+	public async Task SetUpAsync()
+	{
+		Directory.CreateDirectory(_outputDir);
+	}
+
+	[After(Test)]
+	public async Task CleanUpAsync()
+	{
+		Directory.Delete(_outputDir, true);
+	}
+
+	[Test]
+	public async Task I_can_verify_the_package_contains_the_expected_contents()
+	{
+		using var process = Process.Start("dotnet", $"pack \"{ProjectPath}\" -o \"{_outputDir}\" -c Release");
+		await process.WaitForExitAsync();
+
+		var pkgs = Directory.GetFiles(_outputDir, "*.nupkg");
+		await Assert.That(pkgs.Length).IsGreaterThanOrEqualTo(1);
+
+		await using var archive = await ZipFile.OpenReadAsync(pkgs[0]);
+		var entries = archive.Entries.Select(entry => entry.FullName.Replace('\\', '/')).ToHashSet();
+
+		await Assert.That(entries).Contains("lib/net10.0/Geekeey.Request.Dispatcher.dll");
+		await Assert.That(entries).Contains("lib/net10.0/Geekeey.Request.Dispatcher.xml");
+	}
+}

src/request.dispatcher.tests/RequestDispatcherBuilderExtensionsTests.cs

@@ -0,0 +1,142 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class RequestDispatcherBuilderExtensionsTests
+{
+	[Test]
+	public async Task I_can_add_a_type_and_register_the_options()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var type = typeof(TestHandler);
+
+		builder.Add(type);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		var handlers = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+		await Assert.That(handlers).Count().IsEqualTo(1);
+		await Assert.That(handlers.First()).IsTypeOf<TestHandler>();
+	}
+
+	[Test]
+	public async Task I_can_add_a_type_with_a_lifetime_and_register_the_options_and_service()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var type = typeof(TestHandler);
+		var lifetime = ServiceLifetime.Scoped;
+
+		builder.Add(type, lifetime);
+
+		var serviceDescriptor = services.FirstOrDefault(sd => sd.ServiceType == type);
+		await Assert.That(serviceDescriptor).IsNotNull();
+		await Assert.That(serviceDescriptor.Lifetime).IsEqualTo(lifetime);
+		await Assert.That(serviceDescriptor.ImplementationType).IsEqualTo(type);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		var handlers = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+
+		await Assert.That(handlers).Count().IsEqualTo(1);
+	}
+
+	[Test]
+	public async Task I_can_add_an_enumerable_of_types_and_register_the_options()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var types = new[] { typeof(TestHandler), typeof(AnotherTestHandler) };
+
+		builder.Add(types);
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		var handlers1 = options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider);
+		await Assert.That(handlers1).Count().IsEqualTo(1);
+		await Assert.That(handlers1.First()).IsTypeOf<TestHandler>();
+
+		var handlers2 = options.GetRequestHandlers<IScalarRequestHandler<AnotherTestRequest, string>>(provider);
+		await Assert.That(handlers2).Count().IsEqualTo(1);
+		await Assert.That(handlers2.First()).IsTypeOf<AnotherTestHandler>();
+	}
+
+	[Test]
+	public async Task I_can_add_an_enumerable_of_types_with_a_lifetime_and_register_the_options_and_services()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var types = new[] { typeof(TestHandler), typeof(AnotherTestHandler) };
+		var lifetime = ServiceLifetime.Singleton;
+
+		builder.Add(types, lifetime);
+
+		foreach (var type in types)
+		{
+			var serviceDescriptor = services.FirstOrDefault(sd => sd.ServiceType == type);
+			await Assert.That(serviceDescriptor).IsNotNull();
+			await Assert.That(serviceDescriptor.Lifetime).IsEqualTo(lifetime);
+		}
+
+		var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+
+		await Assert.That(options.GetRequestHandlers<IScalarRequestHandler<TestRequest, string>>(provider)).Count().IsEqualTo(1);
+		await Assert.That(options.GetRequestHandlers<IScalarRequestHandler<AnotherTestRequest, string>>(provider)).Count().IsEqualTo(1);
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_when_the_builder_is_null()
+	{
+		IRequestDispatcherBuilder builder = null!;
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(() => builder.Add(typeof(TestHandler))).Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add(typeof(TestHandler), ServiceLifetime.Transient))
+				.Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add([typeof(TestHandler)])).Throws<ArgumentNullException>();
+			await Assert.That(() => builder.Add([typeof(TestHandler)], ServiceLifetime.Transient))
+				.Throws<ArgumentNullException>();
+		}
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_adding_a_nested_request_handler()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var assembly = Roslyn.Compile(options =>
+		{
+			options.AddFromEmbeddedSource("BuilderNestedHandler.cs");
+		});
+		var nestedHandlerType = assembly.GetType("Sample.Container+PingHandler", throwOnError: true)!;
+
+		var exception = await Assert.That(() => builder.Add(nestedHandlerType)).Throws<InvalidOperationException>();
+		await Assert.That(exception?.Message).Contains(nestedHandlerType.FullName!);
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_adding_nested_request_handlers_with_a_lifetime()
+	{
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+		var assembly = Roslyn.Compile(options =>
+		{
+			options.AddFromEmbeddedSource("BuilderNestedHandler.cs");
+		});
+		var nestedHandlerType = assembly.GetType("Sample.Container+PingHandler", throwOnError: true)!;
+
+		var exception = await Assert
+			.That(() => builder.Add([typeof(TestHandler), nestedHandlerType], ServiceLifetime.Transient))
+			.Throws<InvalidOperationException>();
+		await Assert.That(exception?.Message).Contains(nestedHandlerType.FullName!);
+	}
+}

src/request.dispatcher.tests/ScalarBehaviourTests.cs

@@ -0,0 +1,111 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class ScalarBehaviourTests
+{
+	[Test]
+	public async Task I_can_execute_the_closed_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarTestBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_execute_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarOpenBehavior<,>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_chain_the_behaviours_in_order()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarChainedBehaviour1))
+			.Add(typeof(ScalarChainedBehaviour2)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Hello" };
+		await dispatcher.DispatchAsync(request);
+
+		// They are discovered in the order they appear in the assembly.
+		// In this file: ChainedBehaviour1, ChainedBehaviour2
+		await Assert.That(tracker.Log).Count().IsEqualTo(2);
+		await Assert.That(tracker.Log[0]).IsEquivalentTo("Behaviour1");
+		await Assert.That(tracker.Log[1]).IsEquivalentTo("Behaviour2");
+	}
+
+	[Test]
+	public async Task I_can_work_with_a_generic_wrapper_request_and_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestWrapperHandler<>))
+			.Add(typeof(ScalarWrapperBehavior<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestWrapperRequest<int> { Item = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Handled-42");
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_maintain_the_ordering_between_open_and_closed_behaviours()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<ScalarTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ScalarTestHandler))
+			.Add(typeof(ScalarOrderingOpenBehavior<,>))
+			.Add(typeof(ScalarOrderingClosedBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<ScalarTestTracker>();
+
+		var request = new ScalarTestRequest { Value = "Order" };
+		await dispatcher.DispatchAsync(request);
+
+		await Assert.That(tracker.Log).Contains("OrderingOpen");
+		await Assert.That(tracker.Log).Contains("OrderingClosed");
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/ScalarDispatcherTests.cs

@@ -0,0 +1,251 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class ScalarDispatcherTests
+{
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new OpenScalarRequest { Data = "Hello" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Hello-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler_that_has_constraints()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ConstrainedScalarRequest { Value = 123 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("123-Constrained");
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_no_handler_is_found_even_with_an_open_generic_available()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new UnhandledScalarRequest();
+		await Assert.ThrowsAsync<InvalidOperationException>(async () => await dispatcher.DispatchAsync(request));
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		// InheritedScalarRequest : OpenScalarRequest.
+		// There is no Handler<InheritedScalarRequest> but there is OpenScalarHandler<TRequest> where TRequest : OpenScalarRequest.
+		// It should be able to handle InheritedScalarRequest.
+		var request = new InheritedScalarRequest { Data = "Sub" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Sub-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(DerivedScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DerivedScalarRequest { Value = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Derived: 42");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedScalarRequest { Name = "InterfaceTest" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("InterfaceTest-InterfaceHandled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_deep_inheritance_in_the_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DeepDerivedScalarRequest { Data = "Deep", DeepValue = 99 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// OpenScalarHandler<TRequest> where TRequest : OpenScalarRequest should handle this
+		await Assert.That(result).IsEquivalentTo("Deep-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_constrained_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedScalarHandler))
+			.Add(typeof(InterfaceConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedScalarRequest { Name = "Constrained" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// Both InterfaceInheritedScalarHandler and InterfaceConstrainedScalarHandler could match.
+		// InterfaceInheritedScalarHandler is a concrete match for InterfaceInheritedScalarRequest.
+		// InterfaceConstrainedScalarHandler is an open generic match.
+		// Currently Dispatcher.SendAsync checks concrete handlers first.
+		await Assert.That(result).IsEquivalentTo("Constrained-InterfaceHandled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_only_match()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceConstrainedScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AnotherNamedScalarRequest { Name = "InterfaceOnly" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		// No concrete handler for AnotherNamedScalarRequest, but InterfaceConstrainedScalarHandler<T> where T : INamedScalarRequest matches.
+		await Assert.That(result).IsEquivalentTo("InterfaceOnly-ConstrainedByInterface");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_nested_generic_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(WrapperScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new WrapperScalarRequest<int> { Item = 42 };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Handled-42");
+	}
+
+	[Test]
+	public async Task I_can_handle_multiple_interface_implementations()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(MultiInterfaceScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new MultiInterfaceScalarRequest();
+		var result1 = await dispatcher.DispatchAsync<int>(request);
+		var result2 = await dispatcher.DispatchAsync<string>(request);
+
+		await Assert.That(result1).IsEqualTo(1);
+		await Assert.That(result2).IsEquivalentTo("One");
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_there_are_ambiguous_handle_methods()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(AmbiguousScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AmbiguousScalarRequest();
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Interface-Handled");
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_generic_interface_explicit_implementation()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ExplicitGenericScalarHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ExplicitGenericScalarRequest { Value = "Explicit" };
+		var result = await dispatcher.DispatchAsync(request);
+
+		await Assert.That(result).IsEquivalentTo("Explicit-ExplicitHandled");
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_the_original_exception()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new FailingScalarRequest();
+		var ex = await Assert.That(async () => await dispatcher.DispatchAsync(request)).Throws<InvalidOperationException>();
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(ex?.Message).IsEquivalentTo("Handler failed");
+			// Assert that the stack trace contains the handler's method name,
+			// which proves the exception was rethrown while preserving its origin.
+			await Assert.That(ex?.StackTrace).Contains(nameof(FailingScalarHandler.HandleAsync));
+		}
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_if_dispatcher_options_are_modified_after_build()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingScalarHandler)));
+		var provider = sc.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		options.GetRequestBehaviors<IScalarRequestHandler<FailingScalarRequest, string>>(default!);
+
+		await Assert.That(() => options.Inspect([])).Throws<InvalidOperationException>();
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/SearchHandlerInAssemblyTests.cs

@@ -0,0 +1,70 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using System.Collections;
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class SearchHandlerInAssemblyTests
+{
+	[Test]
+	public async Task I_can_search_handlers_in_an_assembly()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchTopLevelHandler.cs"));
+
+		var services = new ServiceCollection();
+		services.AddRequestDispatcher(builder => builder
+			.SearchHandlerInAssembly(assembly));
+		await using var provider = services.BuildServiceProvider();
+		var options = provider.GetRequiredService<IOptions<RequestDispatcherOptions>>().Value;
+		var requestType = assembly.GetType("Sample.Ping", throwOnError: true)!;
+		var handlerType = assembly.GetType("Sample.PingHandler", throwOnError: true)!;
+		var handlerInterface = typeof(IScalarRequestHandler<,>).MakeGenericType(requestType, typeof(string));
+		var handlers = GetRequestHandlers(options, handlerInterface, provider).ToArray();
+
+		using var scope = Assert.Multiple();
+		await Assert.That(handlers).Count().IsEqualTo(1);
+		await Assert.That(handlers.Single()!.GetType()).IsEqualTo(handlerType);
+	}
+
+	[Test]
+	public async Task I_can_search_handlers_in_an_assembly_with_a_lifetime()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchTopLevelHandler.cs"));
+
+		var services = new ServiceCollection();
+		services.AddRequestDispatcher(builder => builder
+			.SearchHandlerInAssembly(assembly, ServiceLifetime.Singleton));
+		var handlerType = assembly.GetType("Sample.PingHandler", throwOnError: true)!;
+		var descriptor = services.SingleOrDefault(service => service.ServiceType == handlerType);
+
+		using var scope = Assert.Multiple();
+		await Assert.That(descriptor).IsNotNull();
+		await Assert.That(descriptor!.Lifetime).IsEqualTo(ServiceLifetime.Singleton);
+	}
+
+	[Test]
+	public async Task I_can_get_an_exception_when_nested_handlers_are_present()
+	{
+		var assembly = Roslyn.Compile(options => options.AddFromEmbeddedSource("SearchNestedHandler.cs"));
+
+		var services = new ServiceCollection();
+		var builder = services.AddRequestDispatcher();
+
+		await Assert.That(() => builder.SearchHandlerInAssembly(assembly))
+			.Throws<InvalidOperationException>().And.HasMessageContaining("Sample.Container+PingHandler");
+	}
+
+	private static IEnumerable<object?> GetRequestHandlers(RequestDispatcherOptions options, Type handlerInterface,
+		IServiceProvider provider)
+	{
+		return ((IEnumerable)typeof(RequestDispatcherOptions)
+				.GetMethod(nameof(RequestDispatcherOptions.GetRequestHandlers))!
+				.MakeGenericMethod(handlerInterface)
+				.Invoke(options, [provider])!)
+			.Cast<object?>();
+	}
+}

src/request.dispatcher.tests/StreamBehaviourTests.cs

@@ -0,0 +1,110 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class StreamBehaviourTests
+{
+	[Test]
+	public async Task I_can_execute_the_closed_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamTestBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Handled-0", "Hello-Handled-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_execute_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamOpenBehavior<,>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Handled-0", "Hello-Handled-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_chain_the_behaviours_in_order()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamChainedBehaviour1))
+			.Add(typeof(StreamChainedBehaviour2)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Hello" };
+		await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(tracker.Log).Count().IsEqualTo(2);
+		await Assert.That(tracker.Log[0]).IsEquivalentTo("Behaviour1");
+		await Assert.That(tracker.Log[1]).IsEquivalentTo("Behaviour2");
+	}
+
+	[Test]
+	public async Task I_can_work_with_a_generic_wrapper_request_and_the_open_behaviour()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestWrapperHandler<>))
+			.Add(typeof(StreamWrapperBehavior<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestWrapperRequest<int> { Item = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Handled-42-0", "Handled-42-1"]);
+		await Assert.That(tracker.Executed).IsTrue();
+	}
+
+	[Test]
+	public async Task I_can_maintain_the_ordering_between_open_and_closed_behaviours()
+	{
+		var sc = new ServiceCollection();
+		sc.AddSingleton<StreamTestTracker>();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(StreamTestHandler))
+			.Add(typeof(StreamOrderingOpenBehavior<,>))
+			.Add(typeof(StreamOrderingClosedBehavior)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+		var tracker = provider.GetRequiredService<StreamTestTracker>();
+
+		var request = new StreamTestRequest { Value = "Order" };
+		await dispatcher.DispatchAsync(request).ToListAsync();
+
+		var log = tracker.Log.ToList();
+		await Assert.That(log).Contains("Open");
+		await Assert.That(log).Contains("Closed");
+	}
+}
+
+// Moved to _fixtures

src/request.dispatcher.tests/StreamDispatcherTests.cs

@@ -0,0 +1,243 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class StreamDispatcherTests
+{
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new OpenStreamRequest { Data = "Hello" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Hello-Stream-0", "Hello-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_open_generic_handler_that_has_constraints()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ConstrainedStreamRequest { Value = 123 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["123-Constrained-0", "123-Constrained-1"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_no_handler_is_found_even_with_an_open_generic_available()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new UnhandledStreamRequest();
+		await Assert.ThrowsAsync<InvalidOperationException>(async () => await dispatcher.DispatchAsync(request).FirstOrDefaultAsync().AsTask());
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InheritedStreamRequest { Data = "Sub" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Sub-Stream-0", "Sub-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_inherited_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(DerivedStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DerivedStreamRequest { Value = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Derived: 42-0", "Derived: 42-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_inherited_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedStreamRequest { Name = "InterfaceTest" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["InterfaceTest-InterfaceHandled-0", "InterfaceTest-InterfaceHandled-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_deep_inheritance_in_the_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(OpenStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new DeepDerivedStreamRequest { Data = "Deep", DeepValue = 99 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Deep-Stream-0", "Deep-Stream-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_constrained_handler()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceInheritedStreamHandler))
+			.Add(typeof(InterfaceConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new InterfaceInheritedStreamRequest { Name = "Constrained" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		// Both InterfaceInheritedStreamHandler and InterfaceConstrainedStreamHandler could match.
+		// InterfaceInheritedStreamHandler is a concrete match for InterfaceInheritedStreamRequest.
+		// InterfaceConstrainedStreamHandler is an open generic match.
+		// Currently Dispatcher checks concrete handlers first.
+		await Assert.That(results).IsEquivalentTo(["Constrained-InterfaceHandled-0", "Constrained-InterfaceHandled-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_an_interface_only_match()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(InterfaceConstrainedStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AnotherNamedStreamRequest { Name = "InterfaceOnly" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["InterfaceOnly-ConstrainedByInterface-0", "InterfaceOnly-ConstrainedByInterface-1"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_nested_generic_request()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(WrapperStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new WrapperStreamRequest<int> { Item = 42 };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Handled-42-0", "Handled-42-1"]);
+	}
+
+	[Test]
+	public async Task I_can_handle_multiple_interface_implementations()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(MultiInterfaceStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new MultiInterfaceStreamRequest();
+
+		var results1 = await dispatcher.DispatchAsync<int>(request).ToListAsync();
+		var results2 = await dispatcher.DispatchAsync<string>(request).ToListAsync();
+
+		await Assert.That(results1).IsEquivalentTo([1, 2]);
+		await Assert.That(results2).IsEquivalentTo(["One", "Two"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_fail_if_there_are_ambiguous_handle_methods()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(AmbiguousStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new AmbiguousStreamRequest();
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Interface-Handled"]);
+	}
+
+	[Test]
+	public async Task I_can_dispatch_a_request_async_with_a_generic_interface_explicit_implementation()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(ExplicitGenericStreamHandler<>)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new ExplicitGenericStreamRequest { Value = "Explicit" };
+		var results = await dispatcher.DispatchAsync(request).ToListAsync();
+
+		await Assert.That(results).IsEquivalentTo(["Explicit-ExplicitHandled"]);
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_the_original_exception()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var dispatcher = provider.GetRequiredService<IRequestDispatcher>();
+
+		var request = new FailingStreamRequest();
+		var enumerable = dispatcher.DispatchAsync(request);
+		var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await enumerable.ToListAsync().AsTask());
+
+		using (Assert.Multiple())
+		{
+			await Assert.That(ex?.Message).IsEquivalentTo("Handler failed");
+			await Assert.That(ex?.StackTrace).Contains(nameof(FailingStreamHandler.HandleAsync));
+		}
+	}
+
+	[Test]
+	public async Task I_can_see_it_throw_if_dispatcher_options_are_modified_after_build()
+	{
+		var sc = new ServiceCollection();
+		sc.AddRequestDispatcher(builder => builder
+			.Add(typeof(FailingStreamHandler)));
+		var provider = sc.BuildServiceProvider();
+		var options = provider.GetRequiredService<Microsoft.Extensions.Options.IOptions<RequestDispatcherOptions>>().Value;
+		options.GetRequestHandlers<IStreamRequestHandler<FailingStreamRequest, string>>(default!);
+
+		await Assert.That(() => options.Inspect([])).Throws<InvalidOperationException>();
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousScalarHandler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousScalarHandler : IScalarRequestHandler<AmbiguousScalarRequest, string>
+{
+	// Public method with the same name and signature
+	public Task<string> HandleAsync(AmbiguousScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("Public-Handled");
+	}
+
+	// Explicit interface implementation
+	Task<string> IScalarRequestHandler<AmbiguousScalarRequest, string>.HandleAsync(AmbiguousScalarRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("Interface-Handled");
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousScalarRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousScalarRequest : IScalarRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/AmbiguousStreamHandler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousStreamHandler : IStreamRequestHandler<AmbiguousStreamRequest, string>
+{
+	// Public method with the same name and signature
+	public async IAsyncEnumerable<string> HandleAsync(AmbiguousStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return "Public-Handled";
+	}
+
+	// Explicit interface implementation
+	async IAsyncEnumerable<string> IStreamRequestHandler<AmbiguousStreamRequest, string>.HandleAsync(AmbiguousStreamRequest request, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+	{
+		yield return "Interface-Handled";
+	}
+}

src/request.dispatcher.tests/_fixtures/AmbiguousStreamRequest.cs

@@ -0,0 +1,8 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AmbiguousStreamRequest : IStreamRequest<string>
+{
+}

src/request.dispatcher.tests/_fixtures/AnotherNamedScalarRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AnotherNamedScalarRequest : INamedScalarRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/AnotherNamedStreamRequest.cs

@@ -0,0 +1,9 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class AnotherNamedStreamRequest : INamedStreamRequest
+{
+	public string Name { get; set; } = string.Empty;
+}

src/request.dispatcher.tests/_fixtures/AnotherTestHandler.cs

@@ -0,0 +1,12 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class AnotherTestHandler : IScalarRequestHandler<AnotherTestRequest, string>
+{
+	public Task<string> HandleAsync(AnotherTestRequest request, CancellationToken ct)
+	{
+		return Task.FromResult("ok");
+	}
+}

src/request.dispatcher.tests/_fixtures/AnotherTestRequest.cs

@@ -0,0 +1,6 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+internal sealed class AnotherTestRequest : IScalarRequest<string> { }

src/request.dispatcher.tests/_fixtures/BaseScalarHandler.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public abstract class BaseScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+	where TRequest : IScalarRequest<string>
+{
+	public abstract Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}

src/request.dispatcher.tests/_fixtures/BaseStreamHandler.cs

@@ -0,0 +1,10 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public abstract class BaseStreamHandler<TRequest> : IStreamRequestHandler<TRequest, string>
+	where TRequest : IStreamRequest<string>
+{
+	public abstract IAsyncEnumerable<string> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}

src/request.dispatcher.tests/_fixtures/ConstrainedScalarHandler.cs

@@ -0,0 +1,13 @@
+// Copyright (c) The Geekeey Authors
+// SPDX-License-Identifier: EUPL-1.2
+
+namespace Geekeey.Request.Dispatcher.Tests;
+
+public class ConstrainedScalarHandler<TRequest> : IScalarRequestHandler<TRequest, string>
+	where TRequest : ConstrainedScalarRequest
+{
+	public Task<string> HandleAsync(TRequest request, CancellationToken cancellationToken)
+	{
+		return Task.FromResult($"{request.Value}-Constrained");
+	}
+}