public async Task Should_Return_Channel_From_Connection()
{
/* Setup */
var channel = new Mock <IModel>();
var connectionFactory = new Mock <IConnectionFactory>();
var connection = new Mock <IConnection>();
connectionFactory
.Setup(c => c.CreateConnection(
It.IsAny <List <string> >(), It.IsAny <string>()))
.Returns(connection.Object);
connection
.Setup(c => c.CreateModel())
.Returns(channel.Object);
connection
.Setup(c => c.IsOpen)
.Returns(true);
var channelFactory = new ChannelFactory(connectionFactory.Object, ZyRabbitConfiguration.Local, NullLogger <ChannelFactory> .Instance);
/* Test */
var retrievedChannel = await channelFactory.CreateChannelAsync();
/* Assert */
Assert.Equal(channel.Object, retrievedChannel);
}
public async Task Should_Wait_For_Connection_To_Recover_Before_Returning_Channel()
{
/* Setup */
var channel = new Mock <IModel>();
var connectionFactroy = new Mock <IConnectionFactory>();
var connection = new Mock <IConnection>();
var recoverable = connection.As <IRecoverable>();
connectionFactroy
.Setup(c => c.CreateConnection(
It.IsAny <List <string> >(), It.IsAny <string>()))
.Returns(connection.Object);
connection
.Setup(c => c.CreateModel())
.Returns(channel.Object);
connection
.Setup(c => c.IsOpen)
.Returns(false);
var channelFactory = new ChannelFactory(connectionFactroy.Object, ZyRabbitConfiguration.Local, NullLogger <ChannelFactory> .Instance);
/* Test */
/* Assert */
var channelTask = channelFactory.CreateChannelAsync();
channelTask.Wait(TimeSpan.FromMilliseconds(30));
Assert.False(channelTask.IsCompleted);
recoverable.Raise(r => r.Recovery += null, null, null);
await channelTask;
Assert.Equal(channel.Object, channelTask.Result);
}
public async Task Should_Throw_Exception_If_Connection_Is_Closed_By_Lib_But_Is_Not_Recoverable()
{
/* Setup */
var connectionFactory = new Mock <IConnectionFactory>();
var connection = new Mock <IConnection>();
connectionFactory
.Setup(c => c.CreateConnection(
It.IsAny <List <string> >(), It.IsAny <string>()))
.Returns(connection.Object);
connection
.Setup(c => c.IsOpen)
.Returns(false);
connection
.Setup(c => c.CloseReason)
.Returns(new ShutdownEventArgs(ShutdownInitiator.Library, 0, string.Empty));
var channelFactory = new ChannelFactory(connectionFactory.Object, ZyRabbitConfiguration.Local, NullLogger <ChannelFactory> .Instance);
/* Test */
/* Assert */
try
{
await channelFactory.CreateChannelAsync();
Assert.True(false, $"Connection is closed by Application, expected {nameof(ChannelAvailabilityException)}.");
}
catch (ChannelAvailabilityException e)
{
Assert.True(true, e.Message);
}
}
public async Task Should_Use_Create_Channel_Policy_When_Creating_Channels()
{
/* Setup */
var channel = new Mock <IModel>();
var connection = new Mock <IConnection>();
var connectionFactory = new Mock <IConnectionFactory>();
connectionFactory
.Setup(f => f.CreateConnection())
.Returns(connection.Object);
connectionFactory
.Setup(c => c.CreateConnection(
It.IsAny <List <string> >(), It.IsAny <string>()
))
.Returns(connection.Object);
connection
.Setup(c => c.IsOpen)
.Returns(true);
connection
.SetupSequence(c => c.CreateModel())
.Throws(new TimeoutException())
.Throws(new TimeoutException())
.Returns(channel.Object);
var policy = Policy
.Handle <TimeoutException>()
.WaitAndRetryAsync(new[]
{
TimeSpan.FromMilliseconds(1),
TimeSpan.FromMilliseconds(2),
TimeSpan.FromMilliseconds(4),
TimeSpan.FromMilliseconds(8),
TimeSpan.FromMilliseconds(16)
});
var factory = new ChannelFactory(
connectionFactory.Object,
ZyRabbitConfiguration.Local,
NullLogger <ChannelFactory> .Instance,
new ConnectionPolicies {
CreateChannel = policy
});
/* Test */
var retrievedChannel = await factory.CreateChannelAsync();
/* Assert */
Assert.Equal(channel.Object, retrievedChannel);
}