public void Should_retry_when_configured_for_environmental_errors_only_and_error_is_environmental()
{
var logger = new FakeLogger();
var handler = new FakeEnvironmentExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue("errorQueue");
var bus = new Bus(new FakeBusConfig {
MaxRetries = 2, EnvironmentalErrorsOnly = true
}, logger, errorQueue, QueueWithOneMessage("readQueue"), new[] { new FakeValidMessageQueue("writeQueue1") });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(logger[0], Is.StringContaining("Transaction started"));
Assert.That(logger[1], Is.StringContaining("Started RECEIVE Operation"));
Assert.That(logger[2], Is.StringContaining("Payload: FakeDto"));
Assert.That(logger[3], Is.StringContaining("Invoking registered handler"));
Assert.That(logger[4], Is.StringContaining("TRANSACTION STATUS: Active - REASON: deadlocked"));
Assert.That(logger[5], Is.StringContaining("Retry attempt 1"));
Assert.That(logger[6], Is.StringContaining("Payload: FakeDto"));
Assert.That(logger[7], Is.StringContaining("Invoking registered handler"));
Assert.That(logger[8], Is.StringContaining("TRANSACTION STATUS: Active - REASON: deadlocked"));
Assert.That(logger[9], Is.StringContaining("Retry attempt 2"));
Assert.That(logger[10], Is.StringContaining("Payload: FakeDto"));
Assert.That(logger[11], Is.StringContaining("Invoking registered handler"));
Assert.That(logger[12], Is.StringContaining("TRANSACTION STATUS: Active - REASON: deadlocked"));
Assert.That(logger[13], Is.StringContaining("Invocation failed"));
Assert.That(logger[14], Is.StringContaining("Removing from read queue: readQueue"));
Assert.That(logger[15], Is.StringContaining("Moving to error queue: errorQueue"));
Assert.That(logger[16], Is.StringContaining("EXCEPTION - deadlocked"));
Assert.That(logger[18], Is.StringContaining("Completed RECEIVE Operation"));
Assert.That(logger[19], Is.StringContaining("Transaction rolled back"));
}
public void Should_log_retries_on_error()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue();
var bus = new Bus(new FakeBusConfig {
MaxRetries = 2
}, logger, errorQueue, QueueWithOneMessage(), new[] { new FakeValidMessageQueue() });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(logger[0], Is.StringEnding("Transaction started"));
Assert.That(logger[1], Is.StringEnding("Started RECEIVE Operation"));
Assert.That(logger[2], Is.StringEnding("Payload: FakeDto"));
Assert.That(logger[3], Is.StringEnding("Invoking registered handler"));
Assert.That(logger[4], Is.StringEnding("Retry attempt 1"));
Assert.That(logger[5], Is.StringEnding("Payload: FakeDto"));
Assert.That(logger[6], Is.StringEnding("Invoking registered handler"));
Assert.That(logger[7], Is.StringEnding("Retry attempt 2"));
Assert.That(logger[8], Is.StringEnding("Payload: FakeDto"));
Assert.That(logger[9], Is.StringEnding("Invoking registered handler"));
Assert.That(logger[10], Is.StringEnding("Invocation failed"));
Assert.That(logger[11], Is.StringEnding("Removing from read queue: FakeValidMessageQueue"));
Assert.That(logger[12], Is.StringEnding("Moving to error queue: FakeValidMessageQueue"));
Assert.That(logger[13], Is.StringEnding("EXCEPTION The method or operation is not implemented."));
Assert.That(logger[15], Is.StringEnding("Completed RECEIVE Operation"));
Assert.That(logger[16], Is.StringEnding("Transaction rolled back"));
}
public void Should_move_message_to_read_queue()
{
var readQueue = new FakeValidMessageQueue();
var bus = new Bus(new FakeBusConfig(), new NullLogger(), QueueWithOneMessage(), readQueue, new[] { new FakeValidMessageQueue() });
bus.ReturnErrorMessages();
Assert.That(readQueue.Count, Is.EqualTo(1));
}
internal IMessageQueue QueueWithOneMessage()
{
var queue = new FakeValidMessageQueue();
queue.Add(new Message {
Body = new FakeDto()
});
return(queue);
}
public void Should_throw_when_write_queues_are_undefined()
{
var emptyWriteQueueList = new FakeValidMessageQueue[] { };
var bus = new Bus(new BusConfig(), new NullLogger(), new FakeValidMessageQueue(), new FakeValidMessageQueue(), emptyWriteQueueList);
var exception = Assert.Throws <BusException>(() => bus.Send(new FakeDto()));
Assert.That(exception.Message, Is.EqualTo("Bus has not been configured for sending messages. Did you forget to call DefineWriteQueue on BusBuilder?"));
}
internal FakeValidMessageQueue QueueWithOneMessage(string queueName)
{
var queue = new FakeValidMessageQueue(queueName);
queue.Add(new Message {
Body = new FakeDto(), Label = "00000-00000-00000-00000\0000"
});
return(queue);
}
public void Should_throw_when_specific_message_is_not_found()
{
var errorQueue = QueueWithTwoMessages("errorQueue");
var readQueue = new FakeValidMessageQueue("readQueue");
var bus = new Bus(new FakeBusConfig(), new NullLogger(), errorQueue, readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
var exception = Assert.Throws <BusException>(() => bus.ReturnErrorMessage("0"));
Assert.That(exception.Message, Is.EqualTo("Message with id 0 was not found on the error queue"));
}
public void Should_move_specific_message_to_read_queue()
{
var errorQueue = QueueWithTwoMessages("errorQueue");
var readQueue = new FakeValidMessageQueue("readQueue");
var bus = new Bus(new FakeBusConfig(), new NullLogger(), errorQueue, readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
bus.ReturnErrorMessage("00000-00000-00000-00000\0000");
Assert.That(errorQueue.Count, Is.EqualTo(1));
Assert.That(readQueue.Count, Is.EqualTo(1));
}
public void Should_move_all_to_read_queue()
{
var errorQueue = QueueWithTwoMessages();
var readQueue = new FakeValidMessageQueue();
var bus = new Bus(new FakeBusConfig(), new NullLogger(), errorQueue, readQueue, new[] { new FakeValidMessageQueue() });
bus.ReturnAllErrorMessages();
Assert.That(errorQueue.Count, Is.EqualTo(0));
Assert.That(readQueue.Count, Is.EqualTo(2));
}
internal FakeValidMessageQueue QueueWithTwoMessages()
{
var queue = new FakeValidMessageQueue();
queue.Add(new Message {
Body = new FakeDto(), Label = "00000-00000-00000-00000\0000"
});
queue.Add(new Message {
Body = new FakeDto(), Label = "00000-00000-00000-00000\0001"
});
return(queue);
}
public void Should_move_message_to_error_queue_on_error()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue();
var bus = new Bus(new FakeBusConfig(), logger, errorQueue, QueueWithOneMessage(), new[] { new FakeValidMessageQueue() });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(errorQueue.Count, Is.EqualTo(1));
}
public void Should_log_all_steps_involved()
{
var logger = new FakeLogger();
var readQueue = new FakeValidMessageQueue();
var bus = new Bus(new FakeBusConfig(), logger, QueueWithOneMessage(), readQueue, new[] { new FakeValidMessageQueue() });
bus.ReturnErrorMessages();
Assert.That(logger[0], Is.StringEnding("Started RETURN_TO_SOURCE Operation"));
Assert.That(logger[1], Is.StringEnding("Removing from queue: FakeValidMessageQueue"));
Assert.That(logger[2], Is.StringEnding("Sending to queue: FakeValidMessageQueue"));
Assert.That(logger[3], Is.StringEnding("Completed RETURN_TO_SOURCE Operation"));
}
public void Should_log_all_steps_involved()
{
var logger = new FakeLogger();
var readQueue = new FakeValidMessageQueue("readQueue");
var bus = new Bus(new FakeBusConfig(), logger, QueueWithOneMessage("errorQueue"), readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
bus.ReturnAllErrorMessages();
Assert.That(logger[0], Is.StringContaining("Transaction started"));
Assert.That(logger[1], Is.StringContaining("Started RETURN_TO_SOURCE Operation"));
Assert.That(logger[2], Is.StringContaining("Removing from queue: errorQueue"));
Assert.That(logger[3], Is.StringContaining("Sending to queue: readQueue"));
Assert.That(logger[4], Is.StringContaining("Completed RETURN_TO_SOURCE Operation"));
Assert.That(logger[5], Is.StringContaining("Transaction committed"));
}
public void Should_move_failed_messages_to_error_queue_when_fail_fast_not_configured()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue("errorQueue");
var readQueue = QueueWithTwoMessages("readQueue");
var bus = new Bus(new FakeBusConfig {
FailFast = false
}, logger, errorQueue, readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(errorQueue.Count, Is.EqualTo(2));
Assert.That(readQueue.Count, Is.EqualTo(0));
}
public void Should_discard_failed_messages_to_when_discard_failures_configured()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue();
var readQueue = QueueWithTwoMessages();
var bus = new Bus(new FakeBusConfig {
DiscardFailures = true
}, logger, errorQueue, readQueue, new[] { new FakeValidMessageQueue() });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(errorQueue.Count, Is.EqualTo(0));
Assert.That(readQueue.Count, Is.EqualTo(0));
}
public void Should_leave_failed_message_on_read_queue_when_fail_fast_configured()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue("errorQueue");
var readQueue = QueueWithTwoMessages("readQueue");
var bus = new Bus(new FakeBusConfig {
FailFast = true
}, logger, errorQueue, readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(errorQueue.Count, Is.EqualTo(0));
Assert.That(readQueue.Count, Is.EqualTo(2));
Assert.That(logger[10], Is.StringContaining("FailFast option enabled - Queue processing halted"));
}
public void Should_discard_failed_messages_to_when_discard_failures_configured()
{
var logger = new FakeLogger();
var handler = new FakeExceptionThrowingUserHandler();
var errorQueue = new FakeValidMessageQueue("errorQueue");
var readQueue = QueueWithTwoMessages("readQueue");
var bus = new Bus(new FakeBusConfig {
DiscardFailures = true
}, logger, errorQueue, readQueue, new[] { new FakeValidMessageQueue("writeQueue1") });
bus.RegisterHandler(handler);
bus.Receive <FakeDto>();
Assert.That(errorQueue.Count, Is.EqualTo(0));
Assert.That(readQueue.Count, Is.EqualTo(0));
Assert.That(logger[11], Is.StringContaining("DiscardFailures option enabled - Payload discarded"));
Assert.That(logger[23], Is.StringContaining("DiscardFailures option enabled - Payload discarded"));
}
