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