public void Should_fire_connected_event_when_connect_successfully()
{
// Arrange
var are = new AutoResetEvent(false);
var retryPolicty = Substitute.For <IRetryPolicy>();
var connection = new HaConnection(retryPolicty,
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
new ManagedConnectionFactory()
});
connection.Connected += () => are.Set();
connection.ConnectionFactories.ClearAll();
var f1 = CreateManagedConnectionFactory(5671);
var f2 = CreateManagedConnectionFactory(5672);
connection.ConnectionFactories.Add(f1);
connection.ConnectionFactories.Add(f2);
// Action
connection.Connect();
are.WaitOne();
// Assert
retryPolicty.Received(1).Reset();
f1.Received(1).CreateConnection();
}
public void Should_fail_over_to_next_node_if_there_is_ConnectionFailureException()
{
// Arrange
var retryPolicty = Substitute.For <IRetryPolicy>();
var connection = new HaConnection(retryPolicty,
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
new ManagedConnectionFactory()
});
connection.ConnectionFactories.ClearAll();
var f1 = CreateManagedConnectionFactory(5671, new Exception());
var f2 = CreateManagedConnectionFactory(5672, new Exception());
var f3 = CreateManagedConnectionFactory(5673, new BrokerUnreachableException(new Dictionary <AmqpTcpEndpoint, int>(), new Dictionary <AmqpTcpEndpoint, Exception>(), new Exception()));
connection.ConnectionFactories.Add(f1);
connection.ConnectionFactories.Add(f2);
connection.ConnectionFactories.Add(f3);
// Action
connection.Connect();
// Assert
f1.Received(1).CreateConnection();
f2.Received(1).CreateConnection();
f3.Received(1).CreateConnection();
retryPolicty.Received(1).WaitForNextRetry(Arg.Any <Action>());
}
public void Should_be_notified_about_a_new_established_connection()
{
// Arrange
var haConnectionEstablished = false;
var retryPolicty = Substitute.For <IRetryPolicy>();
var haConnection = new HaConnection(retryPolicty,
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
new ManagedConnectionFactory()
});
haConnection.ConnectionFactories.ClearAll();
var f1 = CreateManagedConnectionFactory(5671);
var f2 = CreateManagedConnectionFactory(5672);
var f3 = CreateManagedConnectionFactory(5673);
haConnection.ConnectionFactories.Add(f1);
haConnection.ConnectionFactories.Add(f2);
haConnection.ConnectionFactories.Add(f3);
var durableConnection = new DurableConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
CreateManagedConnectionFactory(5671));
haConnection.Connected += () => haConnectionEstablished = true;
// Action
durableConnection.Connect();
// Assert
Assert.IsTrue(haConnectionEstablished);
}
public void Should_create_only_one_connection_to_the_each_endpoint()
{
// Arrange
var retryPolicty = Substitute.For <IRetryPolicy>();
var connection1 = new HaConnection(retryPolicty,
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
new ManagedConnectionFactory()
});
connection1.ConnectionFactories.ClearAll();
var f1 = CreateManagedConnectionFactory(5671);
var f2 = CreateManagedConnectionFactory(5672);
var f3 = CreateManagedConnectionFactory(5673);
connection1.ConnectionFactories.Add(f1);
connection1.ConnectionFactories.Add(f2);
connection1.ConnectionFactories.Add(f3);
var connection2 = new HaConnection(retryPolicty,
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
new ManagedConnectionFactory()
});
connection2.ConnectionFactories.ClearAll();
var f4 = CreateManagedConnectionFactory(5674);
var f5 = CreateManagedConnectionFactory(5675);
var f6 = CreateManagedConnectionFactory(5676);
connection2.ConnectionFactories.Add(f4);
connection2.ConnectionFactories.Add(f5);
connection2.ConnectionFactories.Add(f6);
// Action
var tasks = new List <Task>();
for (var i = 0; i < 100; i++)
{
tasks.Add(Task.Factory.StartNew(connection1.Connect));
tasks.Add(Task.Factory.StartNew(connection2.Connect));
}
Task.WaitAll(tasks.ToArray());
// Assert
f1.Received(1).CreateConnection();
f4.Received(1).CreateConnection();
Assert.AreEqual(2, ManagedConnectionFactory.SharedConnections.Count);
}
/// <summary>
/// Create a tunnel with provided connection string and IRabbitWatcher object
/// </summary>
/// <param name="connectionString"></param>
/// <param name="watcher"></param>
/// <returns></returns>
public virtual ITunnel Create(string connectionString, IRabbitWatcher watcher)
{
var clusterConnections = connectionString.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (clusterConnections.Length > 1)
{
var factories = clusterConnections.Select(x => new ManagedConnectionFactory(new ConnectionString(x)))
.ToList();
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var haConnection = new HaConnection(new DefaultRetryPolicy(), rabbitWatcher, factories);
return(Create(haConnection, rabbitWatcher));
}
var connectionValues = new ConnectionString(connectionString);
return(Create(new ManagedConnectionFactory(connectionValues), watcher));
}
public override ITunnel Create(string connectionString, IRabbitWatcher watcher)
{
var clusterConnections = connectionString.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (clusterConnections.Length > 1)
{
var factories = clusterConnections.Select(x => new ManagedConnectionFactory(new ConnectionString(x)))
.ToList();
var rabbitWatcher = watcher ?? _burrowResolver.Resolve <IRabbitWatcher>() ?? Global.DefaultWatcher;
var serializer = _burrowResolver.Resolve <ISerializer>() ?? Global.DefaultSerializer;
var haConnection = new HaConnection(new DefaultRetryPolicy(), rabbitWatcher, factories);
return(Create(haConnection, serializer, rabbitWatcher));
}
var cnn = new ConnectionString(connectionString);
return(Create(cnn.Host, cnn.Port, cnn.VirtualHost, cnn.UserName, cnn.Password, watcher));
}
public void Should_bind_to_ConnectionEstablished_event_and_change_connection_status_if_a_share_connection_established()
{
var connection = Substitute.For <IConnection>();
connection.IsOpen.Returns(true);
var factory1 = Substitute.For <ManagedConnectionFactory>();
factory1.HostName = "host1";
factory1.VirtualHost = "/virtualhost";
factory1.EstablishConnection().Returns(connection);
var factory2 = Substitute.For <ManagedConnectionFactory>();
factory2.HostName = "host2";
factory2.VirtualHost = "/virtualhost";
var factory3 = Substitute.For <ManagedConnectionFactory>();
factory2.HostName = "host3";
factory2.VirtualHost = "/virtualhost";
var haConnection = new HaConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory> {
factory3, factory2, factory1
});
Assert.AreEqual(factory3.HostName, haConnection.ConnectionFactories.Current.HostName);
Assert.AreEqual(factory3.VirtualHost, haConnection.ConnectionFactories.Current.VirtualHost);
// Action
factory1.CreateConnection();
// Assert
Assert.AreEqual(factory1.HostName, haConnection.ConnectionFactories.Current.HostName);
Assert.AreEqual(factory1.VirtualHost, haConnection.ConnectionFactories.Current.VirtualHost);
}
public void Should_subscribe_to_ConnectionEstablished_event()
{
var connectionFactory = new ManagedConnectionFactory
{
HostName = "localhost",
Port = 5672,
VirtualHost = "/",
UserName = "******",
Password = "******"
};
using (var connection = new HaConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory>
{
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 void Should_convert_connection_factories_to_managed_connection_factories()
{
// Arrange
var connection = new HaConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
new List <ManagedConnectionFactory>
{
new ManagedConnectionFactory
{
HostName = "localhost",
Port = 5672,
VirtualHost = "/",
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);
Assert.AreEqual(5672, connection.ConnectionFactory.Port);
Assert.AreEqual("/", connection.ConnectionFactory.VirtualHost);
}
public override ITunnel Create(string connectionString, IRabbitWatcher watcher)
{
if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory)
{
return(RabbitTunnel.Factory.Create(connectionString, watcher));
}
var clusterConnections = connectionString.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (clusterConnections.Length > 1)
{
var factories = clusterConnections.Select(x => new ManagedConnectionFactory(new ConnectionString(x)))
.ToList();
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var haConnection = new HaConnection(new DefaultRetryPolicy(), rabbitWatcher, factories);
return(Create(haConnection, rabbitWatcher));
}
var cnn = new ConnectionString(connectionString);
return(Create(cnn.Host, cnn.Port, cnn.VirtualHost, cnn.UserName, cnn.Password, watcher));
}
