public void Valid_Arguments()
{
// Act
var serviceBusTransportManager = new ServiceBusTransportManager(Mock.Of <ITransport>(), Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
// Assert
Assert.That(serviceBusTransportManager, Is.Not.Null);
}
public async Task Initialise_Calls_Initialise_On_The_Transport()
{
//Arrange
var manager = new ServiceBusTransportManager(_mockTransport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
//Act
await manager.Initialise(CancellationToken.None);
//Assert
_mockTransport.Verify(x => x.Initialise(CancellationToken.None), Times.Once);
}
public void Info_Event_Logged_If_Circuit_Breaker_Resets()
{
// Arrange
var unused = new ServiceBusTransportManager(_mockTransport.Object, _mockCircuitBreaker.Object, _mockEventLogger.Object);
// Act
_mockCircuitBreaker.Raise(m => m.CircuitBreakerReset += null, new EventArgs());
// Assert
Assert.That(_loggedMessage, Contains.Substring("Circuit Breaker on queue 'Test Queue Name' reset"));
}
public async Task Start_Calls_Start_On_The_Transport()
{
//Arrange
var manager = new ServiceBusTransportManager(_mockTransport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
//Act
await manager.Start(CancellationToken.None);
//Assert
//This is expect as twice because it was called once from the constructor
_mockTransport.Verify(x => x.Start(CancellationToken.None), Times.Exactly(2));
}
public void Warning_Event_Logged_If_Circuit_Breaker_Opens()
{
// Arrange
var unused = new ServiceBusTransportManager(_mockTransport.Object, _mockCircuitBreaker.Object, _mockEventLogger.Object);
var testException = new ApplicationException("Test Exception Message");
var testDuration = new TimeSpan(10);
// Act
_mockCircuitBreaker.Raise(m => m.CircuitBreakerOpened += null, this, new CircuitBreakerOpenedEventArgs(testException, testDuration));
// Assert
Assert.That(_loggedMessage, Contains.Substring($"Circuit Breaker opened on queue '{TestQueueName}' for duration of {testDuration} due to {testException.Message}"));
}
public async Task A_Single_Listener_Can_Be_Registered_On_The_Transport_Manager()
{
//Arrange
_mockTransport.Setup(x => x.Configuration).Returns(new TransportConfiguration());
var mockListerner = new Mock <IMessageListener>();
var manager = new ServiceBusTransportManager(_mockTransport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
//Act
await manager.RegisterListener(mockListerner.Object);
//Assert
Assert.That(_mockTransport.Object.Configuration.Listeners, Has.Exactly(1).EqualTo(mockListerner.Object));
}
public void Enqueue_Message_Throws_Exception_When_Transport_Fails_To_Send_The_Message()
{
_mockCircuitBreaker.
Setup(m => m.ExecuteAsync(It.IsAny <Func <CancellationToken, Task> >(), It.IsAny <Func <Exception, Task> >(), It.IsAny <CancellationToken>())).
Returns(Task.CompletedTask).
Callback((Func <CancellationToken, Task> executeAction, Func <Exception, Task> failureAction, CancellationToken c) => failureAction(Mock.Of <Exception>()));
var manager = new ServiceBusTransportManager(_mockTransport.Object, _mockCircuitBreaker.Object, Mock.Of <IEventLogger>());
async Task TestDelegateAsync() => await manager.EnqueueMessage(It.IsAny <byte[]>(), CancellationToken.None);
Assert.ThrowsAsync <MessageSendFailure>(TestDelegateAsync);
}
public async Task Failing_To_Attach_To_Transport_Manager_Will_Return_False()
{
//Arrange
var transport = new Mock <ITransport>();
var transportManager = new ServiceBusTransportManager(transport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
var result = await listener.AttachTo(transportManager);
//Assert
Assert.That(result, Is.False);
}
public async Task Listener_Can_Be_Attached_To_An_Active_Transport_Manager()
{
//Arrange
var transport = new Mock <ITransport>();
transport.Setup(x => x.Configuration).Returns(new TransportConfiguration());
var transportManager = new ServiceBusTransportManager(transport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
var result = await listener.AttachTo(transportManager);
//Assert
Assert.That(result, Is.True);
Assert.That(transport.Object.Configuration.Listeners, Has.Exactly(1).EqualTo(listener));
}
public async Task Enqueue_Message_Passes_Message_To_Transport_Successfully()
{
//Arrange
const string expectedMessage = "Test Message";
var receivedMessage = string.Empty;
_mockTransport.
Setup(m => m.Send(It.IsAny <byte[]>(), It.IsAny <CancellationToken>())).
Returns(Task.CompletedTask).
Callback((byte[] message, CancellationToken token) => receivedMessage = Encoding.ASCII.GetString(message));
_mockCircuitBreaker.
Setup(m => m.ExecuteAsync(It.IsAny <Func <CancellationToken, Task> >(), It.IsAny <Func <Exception, Task> >(), It.IsAny <CancellationToken>())).
Returns(Task.CompletedTask).
Callback((Func <CancellationToken, Task> executeAction, Func <Exception, Task> failureAction, CancellationToken c) => executeAction(c));
var manager = new ServiceBusTransportManager(_mockTransport.Object, _mockCircuitBreaker.Object, Mock.Of <IEventLogger>());
//Act
await manager.EnqueueMessage(Encoding.ASCII.GetBytes(expectedMessage), CancellationToken.None);
//Assert
Assert.That(receivedMessage, Is.EqualTo(expectedMessage));
}
