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();
}
