public void should_batch_messages()
{
_dispatchQueue.Start();
var message0 = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(message0);
message0.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
var invokedBatches = new List <List <IMessage> >();
var messages = Enumerable.Range(0, 10)
.Select(x => new ExecutableEvent {
Callback = i => invokedBatches.Add(i.Messages.ToList())
})
.ToList();
foreach (var message in messages)
{
EnqueueBatchedInvocation(message);
}
message0.Unblock();
Wait.Until(() => invokedBatches.Count >= 1, 500.Milliseconds());
var invokedBatch = invokedBatches.ExpectedSingle();
invokedBatch.ShouldBeEquivalentTo(messages);
}
public void should_not_accept_invocations_after_stop_while_completing_async_invocations(bool captureContext)
{
var tcs = new TaskCompletionSource <object>();
var message = new AsyncExecutableEvent {
Callback = async _ => await tcs.Task.ConfigureAwait(captureContext)
};
_dispatchQueue.Start();
EnqueueAsyncInvocation(message);
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
var stopTask = Task.Run(() => _dispatchQueue.Stop());
Thread.Sleep(100);
stopTask.IsCompleted.ShouldBeFalse();
var afterStopMessage = new ExecutableEvent();
EnqueueInvocation(afterStopMessage);
Thread.Sleep(100);
Task.Run(() => tcs.SetResult(null));
stopTask.Wait(500.Milliseconds()).ShouldBeTrue();
afterStopMessage.HandleStarted.IsSet.ShouldBeFalse();
}
public void should_purge_dispatch_queues()
{
LoadAndStartDispatcher();
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
Dispatch(firstMessage);
firstMessage.HandleStarted.Wait(2.Seconds()).ShouldBeTrue();
Dispatch(new ExecutableEvent());
Dispatch(new ExecutableEvent());
Dispatch(new ExecutableEvent());
var dispatchQueue = _dispatchQueueFactory.DispatchQueues.ExpectedSingle(x => x.Name == DispatchQueueNameScanner.DefaultQueueName);
dispatchQueue.QueueLength.ShouldEqual(3);
var purgeCount = _messageDispatcher.Purge();
purgeCount.ShouldEqual(3);
dispatchQueue.QueueLength.ShouldEqual(0);
firstMessage.Unblock();
}
public void should_purge_dispatch_queues()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
Dispatch(firstMessage);
firstMessage.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
Dispatch(new ExecutableEvent());
Dispatch(new ExecutableEvent());
Dispatch(new ExecutableEvent());
var dispatchQueue = _dispatchQueueFactory.DispatchQueues.ExpectedSingle();
dispatchQueue.QueueLength.ShouldEqual(3);
var purgeCount = _messageDispatcher.Purge();
purgeCount.ShouldEqual(3);
dispatchQueue.QueueLength.ShouldEqual(0);
firstMessage.Unblock();
}
public void should_run_invoker_when_queue_is_started()
{
var message = new ExecutableEvent();
_dispatchQueue.Start();
EnqueueInvocation(message);
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
}
public void should_not_run_invoker_when_queue_is_not_started()
{
var message = new ExecutableEvent();
EnqueueInvocation(message);
Thread.Sleep(200);
message.HandleStarted.IsSet.ShouldBeFalse();
}
public void Setup()
{
_invoker = new TestAsyncMessageHandlerInvoker <ExecutableEvent>();
_message = new ExecutableEvent();
_messageContext = MessageContext.CreateTest();
_pipes = new List <IPipe>();
_invocation = new PipeInvocation(_invoker, new List <IMessage> {
_message
}, _messageContext, _pipes);
}
private Task <DispatchResult> EnqueueBatchedInvocation(ExecutableEvent message)
{
var tcs = new TaskCompletionSource <DispatchResult>();
var dispatch = new MessageDispatch(MessageContext.CreateTest(), message, (d, r) => tcs.SetResult(r));
dispatch.SetHandlerCount(1);
var invoker = new TestBatchedMessageHandlerInvoker <FakeEvent>();
_dispatchQueue.Enqueue(dispatch, invoker);
return(tcs.Task);
}
public void should_not_deliver_messages_until_started()
{
var executableEvent = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(executableEvent);
executableEvent.HandleStarted.Wait(100.Milliseconds()).ShouldBeFalse();
_dispatchQueue.Start();
executableEvent.HandleStarted.Wait(100.Milliseconds()).ShouldBeTrue();
executableEvent.Unblock();
}
public void should_restart()
{
_dispatchQueue.Start();
_dispatchQueue.Stop();
var message = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(message);
_dispatchQueue.Start();
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
}
public void should_restart([Values] bool startDelivering)
{
_dispatchQueue.Start();
_dispatchQueue.Stop();
var message = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(message);
_dispatchQueue.Start();
message.HandleStarted.Wait(5.Seconds()).ShouldBeTrue();
message.Unblock(); // If we don't release the message the test will stay blocked
}
public void should_continue_processing_messages_after_continuation_error()
{
_dispatchQueue.Start();
var message1 = new ExecutableEvent {
Callback = x => throw new Exception("Processing error")
};
var dispatch = new MessageDispatch(MessageContext.CreateTest(), message1, new TestMessageSerializer(), (d, r) => throw new Exception("Continuation error"));
dispatch.SetHandlerCount(1);
_dispatchQueue.Enqueue(dispatch, new TestMessageHandlerInvoker <ExecutableEvent>());
var message2 = new ExecutableEvent();
var task = EnqueueInvocation(message2);
task.Wait(5.Seconds()).ShouldBeTrue();
}
public void should_run_continuation_with_batch()
{
_dispatchQueue.Start();
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(firstMessage);
var dispatch1 = EnqueueBatchedInvocation(new ExecutableEvent());
var dispatch2 = EnqueueBatchedInvocation(new ExecutableEvent());
firstMessage.Unblock();
dispatch1.Wait(500.Milliseconds()).ShouldBeTrue();
dispatch2.Wait(500.Milliseconds()).ShouldBeTrue();
}
public void should_finish_current_invocation_before_stopping()
{
var message = new ExecutableEvent {
IsBlocking = true
};
_dispatchQueue.Start();
EnqueueInvocation(message);
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
var stopTask = Task.Run(() => _dispatchQueue.Stop());
Thread.Sleep(100);
stopTask.IsCompleted.ShouldBeFalse();
Task.Run(() => message.Unblock());
stopTask.Wait(500.Milliseconds()).ShouldBeTrue();
}
public void should_wait_for_dispatch_to_stop()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var message = new ExecutableEvent {
IsBlocking = true
};
Dispatch(message);
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
var stopTask = Task.Run(() => _messageDispatcher.Stop());
Thread.Sleep(200);
stopTask.IsCompleted.ShouldBeFalse();
message.Unblock();
stopTask.Wait(500.Milliseconds()).ShouldBeTrue();
}
public void should_wait_for_dispatch_to_stop()
{
LoadAndStartDispatcher();
var message = new ExecutableEvent {
IsBlocking = true
};
Dispatch(message);
message.HandleStarted.Wait(5.Seconds()).ShouldBeTrue();
var stopTask = Task.Run(() => _messageDispatcher.Stop()).WaitForActivation();
Thread.Sleep(200);
stopTask.IsCompleted.ShouldBeFalse();
message.Unblock();
stopTask.Wait(5.Seconds()).ShouldBeTrue();
}
public void should_stop_processing_messages_after_stop()
{
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(firstMessage);
var otherMessageTasks = new List <Task>();
otherMessageTasks.Add(EnqueueInvocation(new ExecutableEvent {
IsBlocking = true
}));
otherMessageTasks.Add(EnqueueInvocation(new ExecutableEvent {
IsBlocking = true
}));
_dispatchQueue.Start();
Thread.Sleep(50);
otherMessageTasks.Add(EnqueueInvocation(new ExecutableEvent {
IsBlocking = true
}));
otherMessageTasks.Add(EnqueueInvocation(new ExecutableEvent {
IsBlocking = true
}));
var stopTask = Task.Run(() => _dispatchQueue.Stop());
Wait.Until(() => _dispatchQueue.IsRunning == false, 500.Milliseconds());
firstMessage.Unblock();
stopTask.Wait(500.Milliseconds()).ShouldBeTrue();
foreach (var otherMessageTask in otherMessageTasks)
{
otherMessageTask.IsCompleted.ShouldBeFalse();
}
}
public async Task should_run_continuation_with_batch_error()
{
_dispatchQueue.Start();
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
var _ = EnqueueInvocation(firstMessage);
firstMessage.HandleStarted.Wait(5.Seconds()).ShouldBeTrue();
var dispatch1 = EnqueueBatchedInvocation(new ExecutableEvent {
Callback = x => Throw()
});
var dispatch2 = EnqueueBatchedInvocation(new ExecutableEvent());
firstMessage.Unblock();
(await dispatch1).Errors.ShouldNotBeEmpty();
(await dispatch2).Errors.ShouldNotBeEmpty();
}
public void should_run_continuation_with_batch_error()
{
_dispatchQueue.Start();
var firstMessage = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(firstMessage);
var dispatch1 = EnqueueBatchedInvocation(new ExecutableEvent {
Callback = x => Throw()
});
var dispatch2 = EnqueueBatchedInvocation(new ExecutableEvent());
firstMessage.Unblock();
dispatch1.Wait(500.Milliseconds()).ShouldBeTrue();
dispatch1.Result.Errors.ShouldNotBeEmpty();
dispatch2.Wait(500.Milliseconds()).ShouldBeTrue();
dispatch2.Result.Errors.ShouldNotBeEmpty();
}
public void should_purge()
{
_dispatchQueue.Start();
var message = new ExecutableEvent {
IsBlocking = true
};
EnqueueInvocation(message);
message.HandleStarted.Wait(500.Milliseconds()).ShouldBeTrue();
EnqueueInvocation(new ExecutableEvent());
EnqueueInvocation(new ExecutableEvent());
_dispatchQueue.QueueLength.ShouldEqual(2);
_dispatchQueue.Purge();
_dispatchQueue.QueueLength.ShouldEqual(0);
message.Unblock();
}
