public When_a_user_handler_is_executed() { var consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>(); var eventBus = new EventBus(); var handlerRunner = new HandlerRunner(consumerErrorStrategy, eventBus); Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) => Task.Factory.StartNew(() => { deliveredBody = body; deliveredProperties = properties; deliveredInfo = info; }); var consumer = Substitute.For <IBasicConsumer>(); channel = Substitute.For <IModel>(); consumer.Model.Returns(channel); var context = new ConsumerExecutionContext( userHandler, messageInfo, messageProperties, messageBody, consumer); var autoResetEvent = new AutoResetEvent(false); eventBus.Subscribe <AckEvent>(x => autoResetEvent.Set()); handlerRunner.InvokeUserMessageHandler(context); autoResetEvent.WaitOne(1000); }
public When_a_user_handler_is_cancelled() { consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>(); var eventBus = new EventBus(); var handlerRunner = new HandlerRunner(consumerErrorStrategy, eventBus); Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) => Task.Run(() => throw new OperationCanceledException()); var consumer = Substitute.For <IBasicConsumer>(); var channel = Substitute.For <IModel>(); consumer.Model.Returns(channel); context = new ConsumerExecutionContext(userHandler, messageInfo, messageProperties, messageBody, consumer); var autoResetEvent = new AutoResetEvent(false); eventBus.Subscribe <AckEvent>(x => autoResetEvent.Set()); handlerRunner.InvokeUserMessageHandler(context); autoResetEvent.WaitOne(1000); }
public When_a_user_handler_is_failed() { consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>(); consumerErrorStrategy.HandleConsumerError(null, null).ReturnsForAnyArgs(AckStrategies.Ack); var handlerRunner = new HandlerRunner(consumerErrorStrategy); var consumer = Substitute.For <IBasicConsumer>(); channel = Substitute.For <IModel>(); consumer.Model.Returns(channel); context = new ConsumerExecutionContext( async(body, properties, info) => throw new Exception(), messageInfo, messageProperties, messageBody ); var handlerTask = handlerRunner.InvokeUserMessageHandlerAsync(context) .ContinueWith(async x => { var ackStrategy = await x.ConfigureAwait(false); return(ackStrategy(channel, 42)); }, TaskContinuationOptions.ExecuteSynchronously) .Unwrap(); if (!handlerTask.Wait(5000)) { throw new TimeoutException(); } }
public static void Run <THandler, TInput, TOutput>() where THandler : IHandler <TInput, TOutput>, new() { AppDomain.CurrentDomain.UnhandledException += HandleException; IHandlerRunner runner = new HandlerRunner <THandler, TInput, TOutput>(); Run(runner); }
public void Handle_CallsHandlerHandleWithInputAndContext_AndReturnsOutput() { // arrange var runner = new HandlerRunner <TestHandler, string, string>(); var handler = A.Fake <TestHandler>(); var context = A.Fake <ILambdaContext>(); runner.GetType().GetField("Handler", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(runner, handler); A.CallTo(() => handler.Handle("input", context)).Returns("output"); // act var output = runner.Handle("input", context); // assert A.CallTo(() => handler.Handle("input", context)).MustHaveHappened(); }
public ThreadPooledClient(int subscribePort) : base(subscribePort) { Queue <IMessage> backlog = new Queue <IMessage>(); bool fillBacklog() { bool filled = false; lock (queueHandlers) { foreach (QueueHandlerBinder binder in queueHandlers.Values) { if (binder.Item1.TryTake(out List <IMessage> messages)) { messages.ForEach(backlog.Enqueue); filled = true; } } } return(filled); } void run() { while (true) { while (backlog.Count > 0) { IMessage msg = backlog.Dequeue(); QueueHandlerBinder binder; lock (queueHandlers) { binder = queueHandlers[msg.getTopic()]; } HandlerRunner handlerRunner = new HandlerRunner(binder.Item2, msg); ThreadPool.QueueUserWorkItem(new WaitCallback(handlerRunner.run)); } fillBacklog(); } } thread = new Thread(new ThreadStart(run)); thread.Start(); }
public When_a_user_handler_is_executed() { var consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>(); var handlerRunner = new HandlerRunner(consumerErrorStrategy); var consumer = Substitute.For <IBasicConsumer>(); channel = Substitute.For <IModel, IRecoverable>(); consumer.Model.Returns(channel); var context = new ConsumerExecutionContext( async(body, properties, info, cancellation) => { await Task.Run(() => { deliveredBody = body; deliveredProperties = properties; deliveredInfo = info; }).ConfigureAwait(false); return(AckStrategies.Ack); }, messageInfo, messageProperties, messageBody ); var handlerTask = handlerRunner.InvokeUserMessageHandlerAsync(context, default) .ContinueWith(async x => { var ackStrategy = await x.ConfigureAwait(false); return(ackStrategy(channel, 42)); }, TaskContinuationOptions.ExecuteSynchronously) .Unwrap(); if (!handlerTask.Wait(5000)) { throw new TimeoutException(); } }
public ThreadPooledClient(string subscribeHost, int subscribePort) : base(subscribeHost, subscribePort) { Dictionary <String, Queue <IMessage> > backlog = new Dictionary <string, Queue <IMessage> >(); bool fillBacklog() { backlog.Clear(); bool filled = false; lock (queueHandlers) { foreach (KeyValuePair <string, QueueHandlerBinder> keyValue in queueHandlers) { if (keyValue.Value.Item1.TryTake(out List <IMessage> messages)) { Queue <IMessage> queue = new Queue <IMessage>(); messages.ForEach(queue.Enqueue); backlog[keyValue.Key] = queue; filled = true; } } } return(filled); } void run() { try { while (!this.isClose()) { foreach (KeyValuePair <String, Queue <IMessage> > keyValue in backlog) { Queue <IMessage> value = keyValue.Value; string topic = keyValue.Key; while (value.Count > 0) { IMessage msg = value.Dequeue(); QueueHandlerBinder binder = null; lock (queueHandlers) { if (queueHandlers.ContainsKey(topic)) { binder = queueHandlers[topic]; HandlerRunner handlerRunner = new HandlerRunner(binder.Item2, msg); ThreadPool.QueueUserWorkItem(new WaitCallback(handlerRunner.run)); } } } } fillBacklog(); } } catch (ThreadInterruptedException) { } Console.WriteLine("ThreadPooledClient thread stopped."); } thread_ = new Thread(new ThreadStart(run)); thread_.Start(); }