public void Should_subscribe_to_ConnectionEstablished_event()
{
var connectionFactory = new ConnectionFactory
{
HostName = "localhost",
UserName = "******",
Password = "******"
};
using(var connection = new DurableConnection(Substitute.For<IRetryPolicy>(), Substitute.For<IRabbitWatcher>(), connectionFactory))
{
var fired = false;
connection.Connected += () => { fired = true; };
ManagedConnectionFactory.ConnectionEstablished += (a, b) => { }; //NOTE: To make it not null
var model = Substitute.For<IModel>();
model.IsOpen.Returns(true);
var c = Substitute.For<IConnection>();
c.CreateModel().Returns(model);
c.IsOpen.Returns(true);
c.Endpoint.Returns(connectionFactory.Endpoint);
ManagedConnectionFactory.SharedConnections[connectionFactory.Endpoint + connectionFactory.VirtualHost] = c;
ManagedConnectionFactory.ConnectionEstablished.Invoke(new AmqpTcpEndpoint("localhost"), "/");
Assert.IsTrue(fired);
}
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? _burrowResolver.Resolve<IRabbitWatcher>() ?? Global.DefaultWatcher;
var serializer = _burrowResolver.Resolve<ISerializer>() ?? Global.DefaultSerializer;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(_burrowResolver.Resolve<IRetryPolicy>() ?? new DefaultRetryPolicy(),
rabbitWatcher,
connectionFactory);
Func<IConsumerErrorHandler> errorHandler = () => new ConsumerErrorHandler(connectionFactory,
serializer,
rabbitWatcher);
Func<IMessageHandlerFactory> handlerFactory = () => new DefaultMessageHandlerFactory(_burrowResolver.Resolve<IConsumerErrorHandler>() ?? errorHandler(), rabbitWatcher);
Func<IConsumerManager> consumerManager = () => new ConsumerManager(rabbitWatcher,
_burrowResolver.Resolve<IMessageHandlerFactory>() ?? handlerFactory(),
serializer);
return new RabbitTunnel(_burrowResolver.Resolve<IConsumerManager>() ?? consumerManager(),
rabbitWatcher,
_burrowResolver.Resolve<IRouteFinder>() ?? new DefaultRouteFinder(),
durableConnection,
serializer,
_burrowResolver.Resolve<ICorrelationIdGenerator>() ?? Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory)
{
return RabbitTunnel.Factory.Create(hostName, virtualHost, username, password, watcher);
}
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
return new RabbitTunnelWithPriorityQueuesSupport(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
public void Should_NOT_close_any_connection()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/vHost19", out rmqConnection);
var channel = Substitute.For<IModel>();
rmqConnection.CreateModel().Returns(channel);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
var count = ManagedConnectionFactory.SharedConnections.Count;
durableConnection.Connect();
durableConnection.CreateChannel();
Assert.AreEqual(count + 1, ManagedConnectionFactory.SharedConnections.Count);
// Action
durableConnection.Dispose();
//Assert
rmqConnection.DidNotReceive().Close(Arg.Any<ushort>(), Arg.Any<string>());
rmqConnection.DidNotReceive().Dispose();
Assert.AreEqual(count + 1, ManagedConnectionFactory.SharedConnections.Count);
}
public virtual ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnel(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return tunnel;
}
public void Should_convert_connection_factories_to_managed_connection_factories()
{
var connection = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(), new ConnectionFactory {
HostName = "localhost",
UserName = "******",
Password = "******"
});
Assert.IsTrue(connection.ConnectionFactory is ManagedConnectionFactory);
Assert.AreEqual("localhost", connection.ConnectionFactory.HostName);
Assert.AreEqual("vantheshark", connection.ConnectionFactory.UserName);
Assert.AreEqual("123", connection.ConnectionFactory.Password);
}
public void Should_throw_exception_if_cannot_connect()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
rmqConnection.IsOpen.Returns(false);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
// Action
durableConnection.CreateChannel();
}
public void Should_catch_ConnectFailureException()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/");
connectionFactory.When(x => x.CreateConnection())
.Do(callInfo => { throw new ConnectFailureException("Network error", Substitute.For<Exception>()); });
var durableConnection = new DurableConnection(retryPolicy, Substitute.For<IRabbitWatcher>(), connectionFactory);
// Action
durableConnection.Connect();
// Assert
retryPolicy.Received(1).WaitForNextRetry(Arg.Any<Action>());
}
public void Should_catch_BrokerUnreachableException()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/");
connectionFactory.When(x => x.CreateConnection())
.Do(callInfo => { throw new BrokerUnreachableException(Substitute.For<IDictionary<AmqpTcpEndpoint, int>>(), Substitute.For<IDictionary<AmqpTcpEndpoint, Exception>>(), Substitute.For<Exception>()); });
var durableConnection = new DurableConnection(retryPolicy, Substitute.For<IRabbitWatcher>(), connectionFactory);
// Action
durableConnection.Connect();
// Assert
retryPolicy.Received(1).WaitForNextRetry(Arg.Any<Action>());
}
public void Should_try_to_connection_first_if_not_connected()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
var channel = Substitute.For<IModel>();
rmqConnection.CreateModel().Returns(channel);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
// Action
durableConnection.CreateChannel();
//Assert
connectionFactory.Received().CreateConnection();
}
private ITunnel Create(DurableConnection durableConnection, IRabbitWatcher rabbitWatcher)
{
var errorHandler = new ConsumerErrorHandler(() => durableConnection.ConnectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new PriorityMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnelWithPriorityQueuesSupport(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return tunnel;
}
public void Should_fire_connected_event_when_connect_successfully()
{
// Arrange
var are = new AutoResetEvent(false);
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/");
var durableConnection = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory);
durableConnection.Connected += () => are.Set();
// Action
durableConnection.Connect();
are.WaitOne();
// Assert
connectionFactory.Received(1).CreateConnection();
Assert.AreEqual(1, ManagedConnectionFactory.SharedConnections.Count);
Assert.IsTrue(connectionFactory.Endpoint.Equals(ManagedConnectionFactory.SharedConnections.First().Value.Endpoint));
}
public void Should_be_call_if_App_is_closed_by_user()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.Disconnected += () => { };
durableConnection.Connect();
// Action
rmqConnection.ConnectionShutdown += Raise.Event<ConnectionShutdownEventHandler>(rmqConnection, new ShutdownEventArgs(ShutdownInitiator.Application, 0, "Connection disposed by application"));
//Assert
retryPolicy.DidNotReceive().WaitForNextRetry(Arg.Any<Action>());
}
public void Should_be_call_if_channel_is_shutdown()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
var channel = Substitute.For<IModel>();
rmqConnection.CreateModel().Returns(channel);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.Connect();
durableConnection.CreateChannel();
// Action
channel.ModelShutdown += Raise.Event<ModelShutdownEventHandler>(channel, new ShutdownEventArgs(ShutdownInitiator.Application, 0, "Channel shutdown"));
//Assert
watcher.Received().WarnFormat("Channel shutdown: {0}", "Channel shutdown");
}
public void Should_clear_existing_connection_from_shared_connection_list_then_retry_if_connection_is_dropped_by_peer()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.Disconnected += () => { };
durableConnection.Connect();
Assert.AreEqual(1, DurableConnection.SharedConnections.Count);
// Action
rmqConnection.ConnectionShutdown += Raise.Event<ConnectionShutdownEventHandler>(rmqConnection, new ShutdownEventArgs(ShutdownInitiator.Application, 0, "Connection dropped for unknow reason ;)"));
//Assert
Assert.AreEqual(0, DurableConnection.SharedConnections.Count);
retryPolicy.Received().WaitForNextRetry(Arg.Any<Action>());
}
public void Should_try_reconnect_by_retryPolicy_if_Connection_Shutdown_event_was_fired()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/vHost21", out rmqConnection);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.Disconnected += () => { };
durableConnection.Connect();
Assert.AreEqual(1, ManagedConnectionFactory.SharedConnections.Count);
// Action
rmqConnection.ConnectionShutdown += Raise.Event<ConnectionShutdownEventHandler>(rmqConnection, new ShutdownEventArgs(ShutdownInitiator.Application, 0, "Connection dropped for unknow reason ;)"));
//Assert
Assert.AreEqual(0, ManagedConnectionFactory.SharedConnections.Count);
retryPolicy.Received().WaitForNextRetry(Arg.Any<Action>());
}
public void Should_catch_all_exceptions()
{
// Arrange
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory("/", out rmqConnection);
var channel = Substitute.For<IModel>();
rmqConnection.CreateModel().Returns(channel);
rmqConnection.When(x => x.Dispose())
.Do(callInfo => { throw new Exception("Can't dispose :D");});
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.CreateChannel();
Assert.AreEqual(1, DurableConnection.SharedConnections.Count);
// Action
durableConnection.Dispose();
//Assert
watcher.Received().Error(Arg.Is<Exception>(x => x.Message == "Can't dispose :D"));
}
public void Should_close_and_dispose_all_SharedConnections()
{
var retryPolicy = Substitute.For<IRetryPolicy>();
var watcher = Substitute.For<IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = DurableConnectionTestHelper.CreateMockConnectionFactory("/", out rmqConnection);
var channel = Substitute.For<IModel>();
rmqConnection.CreateModel().Returns(channel);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.CreateChannel();
Assert.AreEqual(1, DurableConnection.SharedConnections.Count);
// Action
RabbitTunnel.Factory.CloseAllConnections();
//Assert
rmqConnection.Received().Close(Arg.Any<ushort>(), Arg.Any<string>());
rmqConnection.Received().Dispose();
Assert.AreEqual(0, DurableConnection.SharedConnections.Count);
}
public void Should_create_only_one_connection_to_the_same_endpoint()
{
// Arrange
var connectionFactory = CreateMockConnectionFactory("/");
var durableConnection = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory);
// Action
var tasks = new List<Task>();
for(var i=0; i< 100; i++)
{
tasks.Add(Task.Factory.StartNew(durableConnection.Connect));
}
Task.WaitAll(tasks.ToArray());
// Assert
connectionFactory.Received(1).CreateConnection();
Assert.AreEqual(1, DurableConnection.SharedConnections.Count);
Assert.IsTrue(connectionFactory.Endpoint.Equals(DurableConnection.SharedConnections.First().Value.Endpoint));
}
public override ITunnel Create(string hostName, int port, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory)
{
return RabbitTunnel.Factory.Create(hostName, port, virtualHost, username, password, watcher);
}
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new ManagedConnectionFactory
{
HostName = hostName,
Port = port,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
return Create(durableConnection, rabbitWatcher);
}
public virtual ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), watcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, Global.DefaultWatcher);
var consumerManager = new ConsumerManager(watcher, errorHandler, Global.DefaultSerializer, Global.DefaultConsumerBatchSize);
return new RabbitTunnel(consumerManager,
watcher,
Global.DefaultRouteFinder,
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
public void Can_create_connections_to_different_endpoints_which_have_the_same_virtualHost()
{
// Arrange
var endpoint1 = new AmqpTcpEndpoint("localhost", 5672);
var connectionFactory1 = CreateMockConnectionFactory<ManagedConnectionFactory>("/", endpoint1);
var durableConnection1 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory1);
var endpoint2 = new AmqpTcpEndpoint("localhost", 5673);
var connectionFactory2 = CreateMockConnectionFactory<ManagedConnectionFactory>("/", endpoint2);
var durableConnection2 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory2);
// Action
var tasks = new List<Task>();
for (var i = 0; i < 100; i++)
{
tasks.Add(Task.Factory.StartNew(durableConnection1.Connect));
tasks.Add(Task.Factory.StartNew(durableConnection2.Connect));
}
Task.WaitAll(tasks.ToArray());
// Assert
connectionFactory1.Received(1).CreateConnection();
connectionFactory2.Received(1).CreateConnection();
Assert.AreEqual(2, ManagedConnectionFactory.SharedConnections.Count);
}
public void Should_create_only_one_connection_to_the_each_endpoint()
{
// Arrange
var connectionFactory1 = CreateMockConnectionFactory<ManagedConnectionFactory>("/");
var durableConnection1 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory1);
var connectionFactory2 = CreateMockConnectionFactory<ManagedConnectionFactory>("/2ndVirtualHost");
var durableConnection2 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory2);
// Action
var tasks = new List<Task>();
for (var i = 0; i < 100; i++)
{
tasks.Add(Task.Factory.StartNew(durableConnection1.Connect));
tasks.Add(Task.Factory.StartNew(durableConnection2.Connect));
}
Task.WaitAll(tasks.ToArray());
// Assert
connectionFactory1.Received(1).CreateConnection();
connectionFactory2.Received(1).CreateConnection();
Assert.AreEqual(2, ManagedConnectionFactory.SharedConnections.Count);
}
public void Should_be_notified_about_a_new_established_connection()
{
// Arrange
var connection2Connected = false;
var connectionFactory = CreateMockConnectionFactory<ManagedConnectionFactory>("/vHost9");
var durableConnection1 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory);
var durableConnection2 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory);
durableConnection2.Connected += () => connection2Connected = true;
// Action
durableConnection1.Connect();
// Assert
connectionFactory.Received(1).CreateConnection();
Assert.IsTrue(connection2Connected);
}
public void Should_only_be_notified_about_a_new_established_connection_that_has_the_same_endpoint_and_virtual_host()
{
// Arrange
var connection1Connected = false;
var connection2Connected = false;
var connectionFactory1 = CreateMockConnectionFactory<ManagedConnectionFactory>("/vHost10");
var durableConnection1 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory1);
durableConnection1.Connected += () => connection1Connected = true;
var connectionFactory2 = CreateMockConnectionFactory<ManagedConnectionFactory>("/vHost11");
var durableConnection2 = new DurableConnection(Substitute.For<IRetryPolicy>(),
Substitute.For<IRabbitWatcher>(),
connectionFactory2);
durableConnection2.Connected += () => connection2Connected = true;
// Action
durableConnection1.Connect();
// Assert
connectionFactory1.Received(1).CreateConnection();
Assert.IsTrue(connection1Connected);
Assert.IsFalse(connection2Connected);
}
private ITunnel Create(ConnectionFactory connectionFactory, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
return Create(durableConnection, rabbitWatcher);
}
