public void If_Handler_Can_Not_Be_Resolved_Then_An_Invalid_Operation_Exception_Will_Be_Thrown()
{
//ARRANGE
var handlerResolver =
new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object);
//ACT
try
{
handlerResolver.ResolveAllHandlersFor(typeof(TestMessage));
}
catch (Exception exception)
{
//ASSERT
var type = typeof(TestMessageHandler);
var ctors = type.GetConstructors();
var ctor = ctors.OrderByDescending(c => c.GetParameters().Length).First();
var parameters = ctor.GetParameters();
Assert.That(exception, Is.TypeOf(typeof(InvalidOperationException)));
Assert.That(exception.Message,
Is.EqualTo(
$"Cannot resolve dependency for type: {type.Name}. Dependency type: {parameters.First().ParameterType.Name}"));
}
}
public void Handler_Can_Be_Resolved_When_Not_Registered_With_Assembly_Filtering()
{
//ARRANGE
object action;
object boolean;
object logger = new Mock <IGWLogger <BaseMessageHandler <TestMessage> > >().Object;
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(Action), out action))
.Returns(true);
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(IGWLogger <BaseMessageHandler <TestMessage> >), out logger))
.Returns(true);
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(bool), out boolean))
.Returns(true);
_mockHandlerResolverSettings.Setup(x => x.LimitAssembliesTo)
.Returns(new List <Assembly> {
GetType().Assembly
});
_mockHandlerResolverSettings.Setup(x => x.HasCustomAssemblyList).Returns(true);
var handlerResolver =
new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestMessage));
//ASSERT
Assert.That(handler.Single(), Is.AssignableFrom(typeof(TestMessageHandler)));
}
public IEnumerable <ISubscriptionHandler> GetHandlers(ModifiedFileModel modifiedFile)
{
List <ISubscriptionHandler> subscriptionHandlers = new List <ISubscriptionHandler>();
HandlerResolver resolver = new HandlerResolver(this);
foreach (Subscription subscription in GetSubscriptions(modifiedFile))
{
try
{
var parameterSubstitutions = new Dictionary <string, string>
{
{ "<trigger-repo>", modifiedFile.RepoName },
{ "<trigger-branch>", modifiedFile.BranchName },
{ "<trigger-path>", modifiedFile.FullPath },
{ "<trigger-commit>", modifiedFile.CommitId }
};
ISubscriptionHandler subscriptionHandler = resolver.Resolve(subscription, parameterSubstitutions);
subscriptionHandlers.Add(subscriptionHandler);
}
catch (Exception e)
{
Trace.TraceError(e.Message);
}
}
return(subscriptionHandlers);
}
public void Can_resolve_handler()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
var handlers = resolver.ResolveAll<TestEvent>();
handlers.Should().HaveCount(1);
}
public void SubscriptionsJsonShouldHaveValidHandlers()
{
SubscriptionsModel subscriptionsModel = InitializeSubscriptionsModel();
HandlerResolver resolver = new HandlerResolver(subscriptionsModel);
foreach (Subscription subscription in subscriptionsModel.Subscriptions)
{
resolver.Resolve(subscription);
}
}
public void ReturnNullWhenHandlerDoesNotMatch()
{
var sut = new HandlerResolver();
var handlerMock = new Mock <IHandlerAsync <TestMessage> >();
var handlerWrapper = new HandlerWrapper <TestMessage>(handlerMock.Object);
sut.Add(handlerWrapper);
var actual = sut.Resolve <AnotherTestMessage>();
actual.Should().BeNull();
}
public void ReturnHandler()
{
var sut = new HandlerResolver();
var handlerMock = new Mock <IHandlerAsync <TestMessage> >();
var handlerWrapper = new HandlerWrapper <TestMessage>(handlerMock.Object);
sut.Add(handlerWrapper);
var actual = sut.Resolve <TestMessage>();
actual.Should().Be(handlerMock.Object);
}
public void Can_handle_message()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
IEnumerable<Handler<TestMessage>> handlersFor = resolver.ResolveAll<TestMessage>();
foreach (var handler in handlersFor)
{
handler(new TestMessage(), CancellationToken.None);
}
module.MiddlewareCalled.Should().BeTrue();
module.FinallyCalled.Should().BeTrue();
}
public void CommandHandlerResolverTest_resolve_by_assembly_scanning_no_limit()
{
//ARRANGE
var dependencyResolver = new DependencyResolverMock();
var handlerFactorySettings = new HandlerFactorySettingsMock();
var handlerResolver = new HandlerResolver(dependencyResolver, handlerFactorySettings);
dependencyResolver.RegisterFactory <Action>(t => () => { }, Lifetime.Singleton);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestCommand));
//ASSERT
Assert.IsInstanceOf <TestCommandHandler>(handler.Single());
}
public void EventHandlerResolverTest()
{
//ARRANGE
var dependencyResolver = new DependencyResolverMock();
var handlerFactorySettings = new HandlerFactorySettingsMock();
var handlerResolver = new HandlerResolver(dependencyResolver, handlerFactorySettings);
dependencyResolver.RegisterFactory <Action>(t => () => { }, Lifetime.Singleton);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestEvent));
//ASSERT
Assert.IsInstanceOf <TestEventHandler>(handler.Single());
}
public void Handler_Can_Be_Resolved_When_Registered_Without_Any_Assembly_Filtering()
{
//ARRANGE
var logger = new Mock <IGWLogger <BaseMessageHandler <TestMessage> > >();
_mockDependenyResolver.Setup(x => x.ResolveAll(typeof(IMessageHandler <TestMessage>)))
.Returns(new[] { new TestMessageHandler(() => { }, logger.Object, false) });
var handlerResolver =
new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestMessage));
//ASSERT
Assert.That(handler.Single(), Is.AssignableFrom(typeof(TestMessageHandler)));
}
public static void Main(string[] args)
{
IHandlerResolver resolver = new HandlerResolver(typeof(CustomerRequestHandler).Assembly.GetTypes());
var customerRequest = new CustomerRequest {
Name = "Joe", Surname = "Bloggs"
};
var customerResponse = resolver.GetRequestHandler <CustomerRequest, CustomerResponse>().Handle(customerRequest);
var billRequest = new BillRequest {
Amount = 100m
};
var billResponse = resolver.GetRequestHandler <BillRequest, BillResponse>().Handle(billRequest);
Console.WriteLine(billResponse.Success);
Console.WriteLine(customerResponse.Success);
Console.ReadKey();
}
protected virtual async Task RunInternalAsync(
CommandContext context, CancellationToken cancellationToken = default)
{
using var _1 = context;
using var _2 = context.Activate();
try {
var command = context.UntypedCommand;
var handlers = HandlerResolver.GetCommandHandlers(command.GetType());
context.ExecutionState = new CommandExecutionState(handlers);
if (handlers !.Count == 0)
{
await OnUnhandledCommandAsync(command, context, cancellationToken).ConfigureAwait(false);
}
await context.InvokeRemainingHandlersAsync(cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException) {
context.TrySetCancelled(
cancellationToken.IsCancellationRequested ? cancellationToken : default);
public IEnumerable <ISubscriptionHandler> GetHandlers(ModifiedFileModel modifiedFile)
{
List <ISubscriptionHandler> subscriptionHandlers = new List <ISubscriptionHandler>();
HandlerResolver resolver = new HandlerResolver(this);
foreach (Subscription subscription in GetSubscriptions(modifiedFile))
{
try
{
ISubscriptionHandler subscriptionHandler = resolver.Resolve(subscription);
subscriptionHandlers.Add(subscriptionHandler);
}
catch (Exception e)
{
Trace.TraceError(e.Message);
}
}
return(subscriptionHandlers);
}
protected virtual async Task <CommandContext> RunAsync(
Func <CommandContext> contextFactory, ICommand command,
CancellationToken cancellationToken = default)
{
using var context = contextFactory.Invoke();
try {
var handlers = HandlerResolver.GetCommandHandlers(command.GetType());
context.ExecutionState = new CommandExecutionState(handlers);
if (handlers.Count == 0)
{
await OnUnhandledCommandAsync(command, context, cancellationToken).ConfigureAwait(false);
}
else
{
await context.InvokeRemainingHandlersAsync(cancellationToken).ConfigureAwait(false);
}
}
catch (OperationCanceledException) {
context.TrySetCancelled(
cancellationToken.IsCancellationRequested ? cancellationToken : default);
protected virtual async Task RunInternal(
CommandContext context, CancellationToken cancellationToken = default)
{
var activationScope = context.Activate();
try {
var command = context.UntypedCommand;
var handlers = HandlerResolver.GetCommandHandlers(command.GetType());
context.ExecutionState = new CommandExecutionState(handlers);
if (handlers !.Count == 0)
{
await OnUnhandledCommand(command, context, cancellationToken).ConfigureAwait(false);
}
await context.InvokeRemainingHandlers(cancellationToken).ConfigureAwait(false);
}
catch (Exception e) {
context.SetResult(e);
}
finally {
context.TryComplete(cancellationToken);
activationScope.Dispose();
await context.DisposeAsync().ConfigureAwait(false);
}
}
If_No_Handlers_Can_Be_Found_For_Message_Type_Then_An_Invalid_Operation_Exception_Will_Be_Thrown()
{
//ARRANGE
_mockHandlerResolverSettings.Setup(x => x.LimitAssembliesTo)
.Returns(new List <Assembly>());
_mockHandlerResolverSettings.Setup(x => x.HasCustomAssemblyList).Returns(true);
var handlerResolver =
new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object);
//ACT
try
{
handlerResolver.ResolveAllHandlersFor(typeof(TestMessage));
}
catch (Exception exception)
{
//ASSERT
Assert.That(exception, Is.TypeOf(typeof(InvalidOperationException)));
Assert.That(exception.Message,
Is.EqualTo(
$"No command handler of type: {typeof(IMessageHandler<TestMessage>).FullName} found."));
}
}
public MessageHandlerFactory(HandlerResolver resolver)
{
_resolver = resolver;
}
protected override void Given()
{
HandlerResolver.ResolveHandler <Message>(new HandlerResolutionContext("queue-name")).Returns(_handler);
}
public PollingSubscriberChannel(IMessageQueue queue)
{
_queue = queue;
_handlers = new HandlerResolver();
}
