public EventReceivePipe(IPipeSpecification <TContext> specification, IPipe <TContext> next, IDependencyScope resolver, MessageHandlerRegistry messageHandlerRegistry) { _specification = specification; _resolver = resolver; _messageHandlerRegistry = messageHandlerRegistry; Next = next; }
public RequestPipe(IPipeSpecification <TContext> specification, IPipe <TContext> next, IDependencyScope resolver, MessageHandlerRegistry messageHandlerRegistry) { Next = next; _specification = specification; _resolver = resolver; _messageHandlerRegistry = messageHandlerRegistry; }
public async Task disposes_consumer_scope_when_consuming_single_message() { var messageResultStub = new MessageResultBuilder().WithTransportLevelMessage(new TransportLevelMessageBuilder().WithType("foo").Build()).Build(); var handlerStub = Dummy.Of <IMessageHandler <FooMessage> >(); var messageRegistrationStub = new MessageRegistrationBuilder() .WithHandlerInstanceType(handlerStub.GetType()) .WithMessageInstanceType(typeof(FooMessage)) .WithMessageType("foo") .Build(); var spy = new ConsumerScopeSpy(messageResultStub); var registry = new MessageHandlerRegistry(); registry.Register(messageRegistrationStub); var consumer = new ConsumerBuilder() .WithConsumerScopeFactory(new ConsumerScopeFactoryStub(spy)) .WithUnitOfWork(new UnitOfWorkStub(handlerStub)) .WithMessageHandlerRegistry(registry) .Build(); await consumer.ConsumeSingle(CancellationToken.None); Assert.Equal(1, spy.Disposed); }
/// <summary> /// Tell legion to scan for message handlers that are marked with the <see cref="MessageHandlerAttribute"/>. /// </summary> /// <param name="context"></param> /// <param name="assembliesToScan">The assemblies that should be scanned for message handlers (if null only entry assembly is scanned).</param> /// <returns></returns> public static IDependencyRegistrationContext ScanForMessageHandlers( this IDependencyRegistrationContext context, IEnumerable <Assembly> assembliesToScan = null) { if (assembliesToScan == null) { assembliesToScan = new[] { Assembly.GetEntryAssembly() }.Distinct(); } context.RegisterTransient( c => new MessageDispatcher(c.Resolve <IMessageListener>(), c.Resolve <IMessageHandlerRegistry>()), typeof(IMessageDispatcher)); var messageHandlerRegistry = new MessageHandlerRegistry(); context.RegisterSingleton(c => { messageHandlerRegistry.ScanForMessageHandlerTypes(assembliesToScan, t => context.RegisterTransient(t, typeof(IMessageHandler), t)); var resolutionContext = c.ResolveForLater(); messageHandlerRegistry.ConnectContainerResolution(t => (IMessageHandler)resolutionContext.Resolve(t)); return(messageHandlerRegistry); }); return(context); }
/// <summary> /// Initialises a server login helper. /// </summary> public ServerLoginHandler(MessageHandlerRegistry messageHandlerRegistry) { foreach (IBootstrapper bootstrapper in messageHandlerRegistry.Bootstrappers) { bootstrapper.EntityBootstrapCompleted += EntityBootstrapCompleted; } }
public async Task expected_order_of_handler_invocation_in_unit_of_work() { var orderOfInvocation = new LinkedList <string>(); var dummyMessageResult = new MessageResultBuilder().WithTransportLevelMessage(new TransportLevelMessageBuilder().WithType("foo").Build()).Build(); var dummyMessageRegistration = new MessageRegistrationBuilder().WithMessageType("foo").Build(); var registry = new MessageHandlerRegistry(); registry.Register(dummyMessageRegistration); var sut = new ConsumerBuilder() .WithUnitOfWork(new UnitOfWorkSpy( handlerInstance: new MessageHandlerSpy <FooMessage>(() => orderOfInvocation.AddLast("during")), pre: () => orderOfInvocation.AddLast("before"), post: () => orderOfInvocation.AddLast("after") )) .WithConsumerScopeFactory(new ConsumerScopeFactoryStub(new ConsumerScopeStub(dummyMessageResult))) .WithMessageHandlerRegistry(registry) .Build(); await sut.ConsumeSingle(CancellationToken.None); Assert.Equal(new[] { "before", "during", "after" }, orderOfInvocation); }
public void GetHandlersReturnHandlerForGivenMessageType() { IEnumerable <Type> MessageHandlerTypes() { return(new [] { typeof(HandlerA), typeof(HandlerB), typeof(NotAHandler) }); } var sut = new MessageHandlerRegistry(MessageHandlerTypes); var sp = A.Fake <IServiceProvider>(); A.CallTo(() => sp.GetService(A <Type> .That.IsEqualTo(typeof(HandlerA)))).Returns(new HandlerA()); var scope = A.Fake <IServiceScope>(); A.CallTo(() => scope.ServiceProvider).Returns(sp); var handlers = sut.GetHandlers(typeof(MessageA), scope).ToList(); Assert.NotEmpty(handlers); Assert.Single(handlers); Assert.Single(handlers, h => h is HandlerA); }
public static MessageHandler GetCachedHandlerForMessage <TMessage>(this MessageHandlerRegistry cache) { var handler = cache.GetHandlersFor(typeof(TMessage)).Single(); handler.Instance = Activator.CreateInstance(handler.HandlerType); return(handler); }
public async Task ShouldIndicateWhetherAHandlerIsATimeoutHandler() { var registry = new MessageHandlerRegistry(); registry.RegisterHandler(typeof(SagaWithTimeoutOfMessage)); var handlers = registry.GetHandlersFor(typeof(MyMessage)); Assert.AreEqual(2, handlers.Count); var timeoutHandler = handlers.SingleOrDefault(h => h.IsTimeoutHandler); Assert.NotNull(timeoutHandler, "Timeout handler should be marked as such"); var timeoutInstance = new SagaWithTimeoutOfMessage(); timeoutHandler.Instance = timeoutInstance; await timeoutHandler.Invoke(new MyMessage(), new TestableInvokeHandlerContext()); Assert.True(timeoutInstance.TimeoutCalled); Assert.False(timeoutInstance.HandlerCalled); var regularHandler = handlers.SingleOrDefault(h => !h.IsTimeoutHandler); Assert.NotNull(regularHandler, "Regular handler should be marked as timeout handler"); var regularInstance = new SagaWithTimeoutOfMessage(); regularHandler.Instance = regularInstance; await regularHandler.Invoke(new MyMessage(), new TestableInvokeHandlerContext()); Assert.False(regularInstance.TimeoutCalled); Assert.True(regularInstance.HandlerCalled); }
public async Task RunNew() { var cache = new MessageHandlerRegistry(new Conventions()); cache.RegisterHandler(typeof(StubMessageHandler)); cache.RegisterHandler(typeof(StubTimeoutHandler)); var stubMessage = new StubMessage(); var stubTimeout = new StubTimeoutState(); var messageHandler = cache.GetCachedHandlerForMessage <StubMessage>(); var timeoutHandler = cache.GetCachedHandlerForMessage <StubTimeoutState>(); await messageHandler.Invoke(stubMessage, null); await timeoutHandler.Invoke(stubTimeout, null); var startNew = Stopwatch.StartNew(); for (var i = 0; i < 100000; i++) { await messageHandler.Invoke(stubMessage, null); await timeoutHandler.Invoke(stubTimeout, null); } startNew.Stop(); Trace.WriteLine(startNew.ElapsedMilliseconds); }
public async Task WhenProcessMessageMarksMessageWithNoHandlersComplete() { IEnumerable <Type> MessageHandlerTypes() { return(new [] { typeof(HandlerB), }); } var scopeFactory = A.Fake <IServiceScopeFactory>(); var scope = A.Fake <IServiceScope>(); var sp = A.Fake <IServiceProvider>(); var handler = A.Fake <HandlerA>(); A.CallTo(() => sp.GetService(A <Type> .That.IsEqualTo(typeof(HandlerA)))).Returns(handler); A.CallTo(() => scopeFactory.CreateScope()).Returns(scope); A.CallTo(() => scope.ServiceProvider).Returns(sp); var client = A.Fake <IReceiverClient>(); var registry = new MessageHandlerRegistry(MessageHandlerTypes); var sut = new MessageDispatcher(scopeFactory, client, registry, new LogCorrelationHandler(false)); var isCompleted = false; await sut.ProcessMessage(typeof(MessageA).FullName, "{aProp1: \"hello\"}", () => { isCompleted = true; return(Task.CompletedTask); }, m => Task.CompletedTask); Assert.True(isCompleted, "the markComplete callback was not called"); }
public Configuration(LogicalAddress logicalAddress, string queueNameBase, string localAddress, string instanceSpecificQueue, TransportTransactionMode transactionMode, PushRuntimeSettings pushRuntimeSettings, bool purgeOnStartup, Notification <ReceivePipelineCompleted> pipelineCompletedSubscribers, bool isSendOnlyEndpoint, List <Type> executeTheseHandlersFirst, MessageHandlerRegistry messageHandlerRegistry, bool createQueues, TransportSeam transportSeam) { LogicalAddress = logicalAddress; QueueNameBase = queueNameBase; LocalAddress = localAddress; InstanceSpecificQueue = instanceSpecificQueue; TransactionMode = transactionMode; PushRuntimeSettings = pushRuntimeSettings; PurgeOnStartup = purgeOnStartup; IsSendOnlyEndpoint = isSendOnlyEndpoint; PipelineCompletedSubscribers = pipelineCompletedSubscribers; ExecuteTheseHandlersFirst = executeTheseHandlersFirst; satelliteDefinitions = new List <SatelliteDefinition>(); this.messageHandlerRegistry = messageHandlerRegistry; CreateQueues = createQueues; this.transportSeam = transportSeam; }
public void GetHandlersDoesNotReturnHandlerForGivenMessageTypeIfHandlerIsntARealHandler() { IEnumerable <Type> MessageHandlerTypes() { return(new[] { typeof(HandlerB), typeof(NotAHandler) }); } var sut = new MessageHandlerRegistry(MessageHandlerTypes); var sp = A.Fake <IServiceProvider>(); A.CallTo(() => sp.GetService(A <Type> .That.IsEqualTo(typeof(NotAHandler)))).Returns(new NotAHandler()); var scope = A.Fake <IServiceScope>(); A.CallTo(() => scope.ServiceProvider).Returns(sp); var scopeFactory = A.Fake <IServiceScopeFactory>(); A.CallTo(() => scopeFactory.CreateScope()).Returns(scope); var handlers = sut.GetHandlers(scopeFactory, typeof(MessageA)).ToList(); Assert.Empty(handlers); }
public async Task WhenProcessMessageIsCalledWithMessageATheMessageAHandlerIsCalled() { IEnumerable <Type> MessageHandlerTypes() { return(new [] { typeof(HandlerA), typeof(HandlerB), typeof(NotAHandler) }); } var scopeFactory = A.Fake <IServiceScopeFactory>(); var scope = A.Fake <IServiceScope>(); var sp = A.Fake <IServiceProvider>(); var handler = A.Fake <HandlerA>(); A.CallTo(() => handler.Handle(A <MessageA> ._)).Returns(Task.FromResult(HandlerResult.Success())); A.CallTo(() => sp.GetService(A <Type> .That.IsEqualTo(typeof(HandlerA)))).Returns(handler); A.CallTo(() => scopeFactory.CreateScope()).Returns(scope); A.CallTo(() => scope.ServiceProvider).Returns(sp); var client = A.Fake <IReceiverClient>(); var registry = new MessageHandlerRegistry(MessageHandlerTypes); var sut = new MessageDispatcher(scopeFactory, client, registry, new LogCorrelationHandler(false)); await sut.ProcessMessage(typeof(MessageA).FullName, "{aProp1: \"hello\"}", () => Task.CompletedTask, m => Task.CompletedTask); A.CallTo(() => handler.Handle(A <MessageA> .That.Matches(m => m.AProp1 == "hello"))) .MustHaveHappenedOnceExactly(); }
/// <summary> /// Scans the given types for types that are message handlers /// then uses the Configurer to configure them into the container as single call components, /// finally passing them to the bus as its MessageHandlerTypes. /// </summary> /// <param name="types"></param> /// <returns></returns> ConfigUnicastBus ConfigureMessageHandlersIn(IEnumerable <Type> types) { var handlerRegistry = new MessageHandlerRegistry(); var handlers = new List <Type>(); foreach (var t in types.Where(IsMessageHandler)) { Configurer.ConfigureComponent(t, DependencyLifecycle.InstancePerUnitOfWork); handlerRegistry.RegisterHandler(t); handlers.Add(t); } Configurer.RegisterSingleton <IMessageHandlerRegistry>(handlerRegistry); var availableDispatcherFactories = TypesToScan .Where( factory => !factory.IsInterface && typeof(IMessageDispatcherFactory).IsAssignableFrom(factory)) .ToList(); var dispatcherMappings = GetDispatcherFactories(handlers, availableDispatcherFactories); //configure the message dispatcher for each handler busConfig.ConfigureProperty(b => b.MessageDispatcherMappings, dispatcherMappings); Configurer.ConfigureProperty <InvokeHandlersBehavior>(b => b.MessageDispatcherMappings, dispatcherMappings); availableDispatcherFactories.ToList().ForEach(factory => Configurer.ConfigureComponent(factory, DependencyLifecycle.InstancePerUnitOfWork)); return(this); }
public async Task ExecuteDeferredEvents_WhenCalled_ShouldCallAllEventHandlers() { // Arrange var @event = new FakeEvent { Id = 1 }; var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>> { _autoSubstitute.SubstituteFor<HandlerDeferringMultipleEvents>(mediator), _autoSubstitute.SubstituteFor<HandlerDeferringSingleEvent>(mediator), _autoSubstitute.SubstituteFor<HandlerWithoutAdditionalEvents>() }); mediator.DeferEvent(@event); // Act await mediator.ExecuteDeferredEvents(); // Assert foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>()) { handler.Received().Handle(Arg.Any<FakeEvent>()).FireAndForget(); } }
public async Task ExecuteDeferredEvents_WhenCalled_ShouldExecuteEventHandlersForEventsFiredInHandlers() { // Arrange var triggerEvent = new FakeEvent { Id = 1 }; var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>> { new HandlerDeferringMultipleEvents(mediator), new HandlerDeferringSingleEvent(mediator), new HandlerWithoutAdditionalEvents() }); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEventFromHandler>> { new DependentEventHandler() }); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEventTwoFromHandler>> { _autoSubstitute.SubstituteFor<ChainedEventHandler>() }); // Act mediator.DeferEvent(triggerEvent); await mediator.ExecuteDeferredEvents(); // Assert foreach (var handler in handlerFactory.GetHandlersFor<FakeEventTwoFromHandler>()) { handler.Received(1).Handle(Arg.Any<FakeEventTwoFromHandler>()).FireAndForget(); } }
static List <Type> GetHandledEvents(MessageHandlerRegistry handlerRegistry, Conventions conventions) { // get all potential messages return(handlerRegistry.GetMessageTypes() // never auto-route system messages and events .Where(t => !conventions.IsInSystemConventionList(t) && conventions.IsEventType(t)) .ToList()); }
static List <Type> GetMessageTypesHandledByThisEndpoint(MessageHandlerRegistry handlerRegistry, Conventions conventions) { var messageTypesHandled = handlerRegistry.GetMessageTypes() //get all potential messages .Where(t => !conventions.IsInSystemConventionList(t)) //never auto-route system messages .ToList(); return(messageTypesHandled); }
public ConsumerConfiguration(IDictionary <string, string> configuration, MessageHandlerRegistry messageHandlerRegistry, IHandlerUnitOfWorkFactory unitOfWorkFactory, IConsumerScopeFactory consumerScopeFactory) { KafkaConfiguration = configuration; MessageHandlerRegistry = messageHandlerRegistry; UnitOfWorkFactory = unitOfWorkFactory; ConsumerScopeFactory = consumerScopeFactory; }
/// <summary> /// Passes the service the reference to the <see cref="IServiceRegistry" />. /// </summary> /// <param name="serviceRegistry">Contains a housing for client services.</param> public ClientService(IServiceRegistry serviceRegistry) { messageHandlerRegistry = new MessageHandlerRegistry(serviceRegistry); this.serviceRegistry = serviceRegistry; const int minimumMillisecondsAllowedBetweenUserTypingMessages = 1000; userTypingThroughputLimiter = new MessageThroughputLimiter <UserTypingRequest>(minimumMillisecondsAllowedBetweenUserTypingMessages); userTypingThroughputLimiter.DeferredSendLastMessage += userTypingThroughputLimiter_DeferredSendLastMessage; }
public ConsumerBuilder() { _unitOfWorkFactory = new HandlerUnitOfWorkFactoryStub(null); var messageStub = new MessageResultBuilder().Build(); _consumerScopeFactory = _ => new ConsumerScopeFactoryStub(new ConsumerScopeStub(messageStub)); _registry = new MessageHandlerRegistry(); }
public async Task ExecuteDeferredEvents_WhenCalledWithoutEvent_ShouldNotThrow() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); // Act await mediator.ExecuteDeferredEvents(); }
public void Should_invoke_handle_method() { var cache = new MessageHandlerRegistry(new Conventions()); cache.CacheMethodForHandler(typeof(StubHandler), typeof(StubMessage)); var handler = new StubHandler(); cache.InvokeHandle(handler, new StubMessage()); Assert.IsTrue(handler.HandleCalled); }
public void Should_invoke_timeout_method() { var cache = new MessageHandlerRegistry(new Conventions()); cache.CacheMethodForHandler(typeof(StubHandler), typeof(StubTimeoutState)); var handler = new StubHandler(); cache.InvokeTimeout(handler, new StubTimeoutState()); Assert.IsTrue(handler.TimeoutCalled); }
protected override List<IDispatcher<object>> GetCommandDispatchers(TinyIoCContainer container) { var widgetCommandHandler = new WidgetCommandHandler(container.Resolve<IAggregateRepository>()); var typedRegistry = new MessageHandlerRegistry<Type>(); typedRegistry.AddByConvention(widgetCommandHandler); var commandsDispatcher = new RawMessageDispatcher<object>(typedRegistry); return new List<IDispatcher<object>> { commandsDispatcher }; }
public ConsumerBuilder() { _unitOfWorkFactory = new HandlerUnitOfWorkFactoryStub(null); _consumerScopeFactory = _ => new ConsumerScopeFactoryStub( new ConsumerScopeStub( new MessageResultBuilder().Build())); _registry = new MessageHandlerRegistry(); _unconfiguredMessageStrategy = new RequireExplicitHandlers(); }
static List<Type> GetMessageTypesHandledByThisEndpoint(MessageHandlerRegistry handlerRegistry, Conventions conventions, SubscribeSettings settings) { var messageTypesHandled = handlerRegistry.GetMessageTypes() //get all potential messages .Where(t => !conventions.IsInSystemConventionList(t)) //never auto-subscribe system messages .Where(t => !conventions.IsCommandType(t)) //commands should never be subscribed to .Where(conventions.IsEventType) //only events unless the user asked for all messages .Where(t => settings.AutoSubscribeSagas || handlerRegistry.GetHandlersFor(t).Any(handler => !typeof(Saga).IsAssignableFrom(handler.HandlerType))) //get messages with other handlers than sagas if needed .ToList(); return messageTypesHandled; }
public void Should_have_passed_through_correct_message() { var cache = new MessageHandlerRegistry(new Conventions()); cache.CacheMethodForHandler(typeof(StubHandler), typeof(StubMessage)); var handler = new StubHandler(); var stubMessage = new StubMessage(); cache.InvokeHandle(handler, stubMessage); Assert.AreEqual(stubMessage, handler.HandledMessage); }
public async Task Should_invoke_handle_method() { var cache = new MessageHandlerRegistry(new Conventions()); cache.RegisterHandler(typeof(StubHandler)); var handler = cache.GetCachedHandlerForMessage <StubMessage>(); await handler.Invoke(new StubMessage(), null); Assert.IsTrue(((StubHandler)handler.Instance).HandleCalled); }
public MyLoadHandlersConnector( CurrentSessionHolder sessionHolder, MessageHandlerRegistry messageHandlerRegistry, ISynchronizedStorage synchronizedStorage, ISynchronizedStorageAdapter adapter) { this.sessionHolder = sessionHolder; this.messageHandlerRegistry = messageHandlerRegistry; this.synchronizedStorage = synchronizedStorage; this.adapter = adapter; }
static List <Type> GetMessageTypesHandledByThisEndpoint(MessageHandlerRegistry handlerRegistry, Conventions conventions, SubscribeSettings settings) { var messageTypesHandled = handlerRegistry.GetMessageTypes() //get all potential messages .Where(t => !conventions.IsInSystemConventionList(t)) //never auto-subscribe system messages .Where(t => !conventions.IsCommandType(t)) //commands should never be subscribed to .Where(t => conventions.IsEventType(t)) //only events unless the user asked for all messages .Where(t => settings.AutoSubscribeSagas || handlerRegistry.GetHandlersFor(t).Any(handler => !typeof(Saga).IsAssignableFrom(handler.HandlerType))) //get messages with other handlers than sagas if needed .ToList(); return(messageTypesHandled); }
protected override List<IDispatcher<ResolvedEvent>> GetDispatchers(TinyIoCContainer container) { var widgetDenormalizer = new WidgetDenormalizer(container.Resolve<IViewModelWriter>()); var typedRegistry = new MessageHandlerRegistry<Type>(); typedRegistry.AddByConvention(widgetDenormalizer); var aggregateDispatcher = new EventStoreAggregateEventDispatcher(typedRegistry); return new List<IDispatcher<ResolvedEvent>>() { aggregateDispatcher }; }
public async Task Should_invoke_timeout_method() { var cache = new MessageHandlerRegistry(new Conventions()); cache.RegisterHandler(typeof(StubHandler)); var handler = cache.GetCachedHandlerForMessage <StubTimeoutState>(); var handlerContext = new TestableMessageHandlerContext(); await handler.Invoke(new StubTimeoutState(), handlerContext); Assert.IsTrue(((StubHandler)handler.Instance).TimeoutCalled); }
public async Task Should_have_passed_through_correct_message() { var cache = new MessageHandlerRegistry(new Conventions()); cache.RegisterHandler(typeof(StubHandler)); var handler = cache.GetCachedHandlerForMessage <StubMessage>(); var stubMessage = new StubMessage(); await handler.Invoke(stubMessage, null); Assert.AreEqual(stubMessage, ((StubHandler)handler.Instance).HandledMessage); }
public async Task Should_have_passed_through_correct_context() { var cache = new MessageHandlerRegistry(new Conventions()); cache.RegisterHandler(typeof(StubHandler)); var handler = cache.GetCachedHandlerForMessage <StubTimeoutState>(); var handlerContext = new TestableMessageHandlerContext(); await handler.Invoke(new StubTimeoutState(), handlerContext); Assert.AreSame(handlerContext, ((StubHandler)handler.Instance).HandlerContext); }
public async Task ExecuteDeferredEvents_WhenCalledWithoutRegisteredHandlers_ShouldNotCallAnyHandlers() { // Arrange var @event = new FakeEvent { Id = 1 }; var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); mediator.DeferEvent(@event); // Act await mediator.ExecuteDeferredEvents(); // Assert foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>()) { handler.DidNotReceive().Handle(Arg.Any<FakeEvent>()).FireAndForget(); } }
static void ConfigureMessageHandlersIn(FeatureConfigurationContext context, IEnumerable<Type> types) { var handlerRegistry = new MessageHandlerRegistry(context.Settings.Get<Conventions>()); foreach (var t in types.Where(IsMessageHandler)) { context.Container.ConfigureComponent(t, DependencyLifecycle.InstancePerUnitOfWork); handlerRegistry.RegisterHandler(t); } List<Action<IConfigureComponents>> propertiesToInject; if (context.Settings.TryGet("NServiceBus.HandlerProperties", out propertiesToInject)) { foreach (var action in propertiesToInject) { action(context.Container); } } context.Container.RegisterSingleton(handlerRegistry); }
public async Task CommandMissing_ShouldThrowEx() { var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>> { _autoSubstitute.SubstituteFor<HandlerWithoutAdditionalEvents>() }); await mediator.Send(new CommandMissing { Id = 1 }); }
public async Task Commands_CanHandleCommandThatFiresOtherCommandsWithAReturnValue() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestCommandWithResult>>(new TestCommandWithResultHandler(mediator)); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestMultipleCommandWithResult>>(new TestMultipleCommandHandlerWithResult(mediator)); // Act var result = await mediator.Send(new TestMultipleCommandWithResult { Name = "bar" }); // Assert Assert.IsTrue(result.Result<TestCommandResult>().ResultingValue == 5); }
public async Task Commands_CanHandleCommandThatFiresOtherCommandsWithANestedError() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestCommandWithResult>>(new TestCommandWithResultHandler(mediator)); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestMultipleCommandWithResult>>(new TestMultipleCommandHandlerWithResult(mediator)); // Act var result = await mediator.Send(new TestMultipleCommandWithResult { Name = "bar", Id = 999 }); // Assert Assert.IsTrue(result.Result<TestCommandResult>() == null && result.ValidationResults.Any()); }
public async Task LookupQuery_CanLookupData() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<ILookupQuery<List<FakeResult>>>(new FindResultForLookup()); // Act var result = await mediator.LoadList<List<FakeResult>>(); // Assert Assert.IsTrue(result.Count == FakeDataStore.Results.Count); }
public async Task Queries_ShouldAllowMultipleQueryDefinitionsPerObject() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<IQuery<SingleIdCriteria, FakeResult>>(new MultipleQueryTypesInOneObject()); handlerFactory.AddHandlersForCommandOrQuery<IQuery<SingleNameCriteria, FakeResult>>(new MultipleQueryTypesInOneObject()); // Act var resultByName = await mediator.Query<SingleNameCriteria, FakeResult>(new SingleNameCriteria { Name = "Name2" }); var resultById = await mediator.Query<SingleIdCriteria, FakeResult>(new SingleIdCriteria { Id = 1 }); // Assert Assert.IsTrue(resultByName.Id == 2); Assert.IsTrue(resultById.Id == 1); }
public async Task ExecuteDeferredEvents_CanAddFromMultipleThreads() { var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>> { _autoSubstitute.SubstituteFor<HandlerWithoutAdditionalEvents>() }); var options = new ParallelOptions { MaxDegreeOfParallelism = 10 }; //Make sure the mediator can handle events being added from multiple threads (should never lose events) Parallel.For(0, 10, options, i => { for (var j = 0; j < 1000; ++j) mediator.DeferEvent(new FakeEvent { Id = (i * 1000) + j }); }); await mediator.ExecuteDeferredEvents(); foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>()) { handler.Received(10000).Handle(Arg.Any<FakeEvent>()).FireAndForget(); } }
public async Task Queries_CanReturnPrimitiveTypes() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<IQuery<SingleNameCriteria, int>>(new FindPrimitiveTypeByCriteria()); // Act var result = await mediator.Query<SingleNameCriteria, int>(new SingleNameCriteria { Name = "Name1" }); // Assert Assert.IsTrue(result == 1); }
public async Task Queries_WhenCalledWithPrimitiveCriteria_ShouldReturnResult() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<IQuery<int, List<FakeResult>>>(new FindFakeResultByPrimitiveType()); // Act var result = await mediator.Query<int, List<FakeResult>>(1); // Assert Assert.IsTrue(result.FirstOrDefault() != null); Assert.IsTrue(result.First().Id == 1); }
public async Task Queries_WhenCalledWithCriteria_ShouldReturnResult() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<IQuery<FakeRangeCriteria, List<FakeResult>>>(new FindFakeResultByRangeCriteria()); // Act var result = await mediator.Query<FakeRangeCriteria, List<FakeResult>>(new FakeRangeCriteria { MinValue = 0, MaxValue = 5 }); // Assert Assert.IsTrue(result.Count == 5); }
public async Task Commands_WhenExecuting_CanSuccessfulCompleteValidCommand() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestCommand>>(new TestCommandHandler(mediator)); // Act var result = await mediator.Send(new TestCommand { Id = 1 }); // Assert Assert.IsFalse(result.ValidationResults.Any()); }
public async Task Commands_CanHandleCommandWithAReturnValueWithValidationFailures() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestCommandWithResult>>(new TestCommandWithResultHandler(mediator)); // Act var result = await mediator.Send(new TestCommandWithResult { Id = 999 }); var returnedValue = result.Result<TestCommandResult>(); // Assert Assert.IsTrue(returnedValue == null && result.ValidationResults.Any()); }
public async Task DeferEvents_CanDeferMultipleEvents() { // Arrange var handlerFactory = new MessageHandlerRegistry(); var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>> { Substitute.For<HandlerDeferringMultipleEvents>(mediator), Substitute.For<HandlerDeferringSingleEvent>(mediator), Substitute.For<HandlerWithoutAdditionalEvents>() }); handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEventFromHandler>> { Substitute.For<DependentEventHandler>() }); handlerFactory.AddHandlersForCommandOrQuery<ICommandHandler<TestCommand>>(new TestCommandHandler(mediator)); // Act var result = await mediator.Send(new TestCommand { Id = 1 }); Assert.IsFalse(result.ValidationResults.Any()); // Assert foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>()) { handler.Received().Handle(Arg.Any<FakeEvent>()).FireAndForget(); } foreach (var handler in handlerFactory.GetHandlersFor<FakeEventFromHandler>()) { handler.Received().Handle(Arg.Any<FakeEventFromHandler>()).FireAndForget(); } }