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));
}
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, 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_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 connectionFactory1 = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost5");
var durableConnection1 = new DurableConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
connectionFactory1);
var connectionFactory2 = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost6");
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 Client(Config cfg)
{
Condition.Requires(cfg.Endpoint, "cfg.Endpoint").IsNotNull();
Condition.Requires(cfg.Products, "cfg.Products").IsNotNull();
Condition.Requires(cfg.Scheduler, "cfg.Scheduler").IsNotNull();
if (cfg.Keys != null)
{
Condition.Requires(cfg.Keys.ApiKey, "cfg.Keys.ApiKey").IsNotNullOrWhiteSpace();
Condition.Requires(cfg.Keys.SecretKey, "cfg.Keys.SecretKey").IsNotNullOrWhiteSpace();
}
if (cfg.EnableTrading)
{
Condition.Requires(cfg.Keys, "cfg.Keys").IsNotNull();
}
_cfg = cfg.Clone();
_cfg.Keys = _cfg.Keys ?? new Keys()
{
ApiKey = "NONE", SecretKey = "NONE"
};
var connector = new CodingConnector <IMessageIn, IMessageOut>(
new ExchangeApi.WebSocket.Connector(_cfg.Endpoint.WebSocket), new WebSocket.Codec(_cfg.Keys));
_connection = new DurableConnection <IMessageIn, IMessageOut>(connector, _cfg.Scheduler);
_gateway = new WebSocket.Gateway(_connection);
_connection.OnConnection += OnConnection;
_connection.OnMessage += OnMessage;
_restClient = new REST.RestClient(_cfg.Endpoint.REST, _cfg.Keys);
_pinger = new PeriodicAction(_cfg.Scheduler, PingPeriod, PingPeriod, Ping);
_futurePositionPoller = new FuturePositionPoller(
_restClient, _cfg.Scheduler,
_cfg.EnableTrading ? _cfg.Products : new List <Product>());
_futurePositionPoller.OnFuturePositions += msg => OnFuturePositionsUpdate?.Invoke(msg);
_spotPositionPoller = new PeriodicAction(_cfg.Scheduler, SpotPositionPollPeriod, SpotPositionPollPeriod, PollSpotPositions);
}
public void Should_NOT_close_any_connection()
{
// Arrange
var retryPolicy = Substitute.For <IRetryPolicy>();
var watcher = Substitute.For <IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/", 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 void Can_create_connections_to_different_endpoints_which_have_the_same_virtualHost()
{
// Arrange
var endpoint1 = new AmqpTcpEndpoint("localhost", 5672);
var connectionFactory1 = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost7", endpoint1);
var durableConnection1 = new DurableConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
connectionFactory1);
var endpoint2 = new AmqpTcpEndpoint("localhost", 5673);
var connectionFactory2 = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost8", 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_unsubscribe_to_ConnectionEstablished_event()
{
var connectionFactory = new ConnectionFactory
{
HostName = "localhost",
UserName = "******",
Password = "******"
};
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
connection.Dispose();
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.IsFalse(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);
var abc = new ObjectObserver <IObserver <ISerializer> >();
Func <IConsumerErrorHandler> errorHandler = () =>
{
var handdler = new ConsumerErrorHandler(connectionFactory, serializer, rabbitWatcher);
abc.FireEvent(handdler);
return(handdler);
};
Func <IMessageHandlerFactory> handlerFactory = () =>
{
var factory = new DefaultMessageHandlerFactory(_burrowResolver.Resolve <IConsumerErrorHandler>() ?? errorHandler(),
serializer,
rabbitWatcher);
abc.FireEvent(factory);
return(factory);
};
Func <IConsumerManager> consumerManager = () =>
{
var manager = new ConsumerManager(rabbitWatcher,
_burrowResolver.Resolve <IMessageHandlerFactory>() ?? handlerFactory(),
serializer);
abc.FireEvent(manager);
return(manager);
};
var tunnel = new RabbitTunnel(_burrowResolver.Resolve <IConsumerManager>() ?? consumerManager(),
rabbitWatcher,
_burrowResolver.Resolve <IRouteFinder>() ?? new DefaultRouteFinder(),
durableConnection,
serializer,
_burrowResolver.Resolve <ICorrelationIdGenerator>() ?? Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
abc.ObjectCreated += tunnel.AddSerializerObserver;
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 <ManagedConnectionFactory>("/", out rmqConnection);
rmqConnection.IsOpen.Returns(false);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
// Action
durableConnection.CreateChannel();
}
public void Should_catch_BrokerUnreachableException()
{
// Arrange
var retryPolicy = Substitute.For <IRetryPolicy>();
var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost3");
connectionFactory.When(x => x.CreateConnection())
.Do(callInfo => { throw new BrokerUnreachableException(Substitute.For <Exception>()); });
var durableConnection = new DurableConnection(retryPolicy, Substitute.For <IRabbitWatcher>(), connectionFactory);
// Action
durableConnection.Connect();
// Assert
retryPolicy.Received(1).WaitForNextRetry(Arg.Any <Action>());
}
public override ITunnel Create(string hostName, int port, 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 ManagedConnectionFactory
{
HostName = hostName,
Port = port,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(_burrowResolver.Resolve <IRetryPolicy>() ?? new DefaultRetryPolicy(),
rabbitWatcher,
connectionFactory);
return(Create(durableConnection, serializer, rabbitWatcher));
}
static void RawConnection()
{
var connector = new ExchangeApi.WebSocket.Connector(ExchangeApi.Coinbase.Instance.Prod.WebSocket);
using (var connection = new DurableConnection <ArraySegment <byte>, ArraySegment <byte> >(connector, new Scheduler()))
{
connection.OnConnection += (IReader <ArraySegment <byte> > reader, IWriter <ArraySegment <byte> > writer) =>
{
writer.Send(Encode("{ \"type\": \"subscribe\", \"product_id\": \"BTC-USD\" }"));
};
connection.OnMessage += (TimestampedMsg <ArraySegment <byte> > msg) =>
{
_log.Info("OnMessage(IsLast={0}): {1} byte(s)", !connection.Scheduler.HasReady(), msg.Value.Count);
};
connection.Connect();
Thread.Sleep(5000);
}
Thread.Sleep(2000);
}
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 <ManagedConnectionFactory>("/", 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 Client(Config cfg)
{
Condition.Requires(cfg.Endpoint, "cfg.Endpoint").IsNotNull();
Condition.Requires(cfg.Products, "cfg.Products").IsNotNull();
Condition.Requires(cfg.Scheduler, "cfg.Scheduler").IsNotNull();
_cfg = cfg.Clone();
var connector = new CodingConnector <WebSocket.IMessageIn, WebSocket.IMessageOut>(
new ExchangeApi.WebSocket.Connector(_cfg.Endpoint.WebSocket), new WebSocket.Codec());
_connection = new DurableConnection <WebSocket.IMessageIn, WebSocket.IMessageOut>(connector, _cfg.Scheduler);
_connection.OnConnection += OnConnection;
_connection.OnMessage += OnMessage;
_restClient = new REST.RestClient(_cfg.Endpoint.REST, _cfg.Keys);
_orderManager = new OrderManager(_cfg.Scheduler);
foreach (string product in _cfg.Products)
{
_products.Add(product, new OrderBookBuilder());
}
}
public void Should_fire_connected_event_when_connect_successfully()
{
// Arrange
var are = new AutoResetEvent(false);
var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost1");
var durableConnection = new DurableConnection(Substitute.For <IRetryPolicy>(),
Substitute.For <IRabbitWatcher>(),
connectionFactory);
durableConnection.Connected += () => are.Set();
// Action
durableConnection.Connect();
Assert.IsTrue(are.WaitOne(1000));
// 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_called_if_App_is_closed_by_user()
{
// Arrange
var retryPolicy = Substitute.For <IRetryPolicy>();
var watcher = Substitute.For <IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/", 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>());
}
private ITunnel Create(DurableConnection durableConnection, ISerializer serializer, IRabbitWatcher rabbitWatcher)
{
var abc = new ObjectObserver <IObserver <ISerializer> >();
Func <IConsumerErrorHandler> errorHandler = () =>
{
var handdler = new ConsumerErrorHandler(durableConnection, serializer, rabbitWatcher);
abc.FireEvent(handdler);
return(handdler);
};
Func <IMessageHandlerFactory> handlerFactory = () =>
{
var factory = new DefaultMessageHandlerFactory(_burrowResolver.Resolve <IConsumerErrorHandler>() ?? errorHandler(),
serializer,
rabbitWatcher);
abc.FireEvent(factory);
return(factory);
};
Func <IConsumerManager> consumerManager = () =>
{
var manager = new ConsumerManager(rabbitWatcher,
_burrowResolver.Resolve <IMessageHandlerFactory>() ?? handlerFactory(),
serializer);
abc.FireEvent(manager);
return(manager);
};
var tunnel = new RabbitTunnel(_burrowResolver.Resolve <IConsumerManager>() ?? consumerManager(),
rabbitWatcher,
_burrowResolver.Resolve <IRouteFinder>() ?? new DefaultRouteFinder(),
durableConnection,
serializer,
_burrowResolver.Resolve <ICorrelationIdGenerator>() ?? Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
abc.ObjectCreated += tunnel.AddSerializerObserver;
return(tunnel);
}
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 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 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>("/", 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_create_only_one_connection_to_the_same_endpoint()
{
// Arrange
var connectionFactory = CreateMockConnectionFactory <ManagedConnectionFactory>("/vHost4");
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, ManagedConnectionFactory.SharedConnections.Count);
Assert.IsTrue(connectionFactory.Endpoint.Equals(ManagedConnectionFactory.SharedConnections.First().Value.Endpoint));
}
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_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_close_and_dispose_all_SharedConnections()
{
var retryPolicy = Substitute.For <IRetryPolicy>();
var watcher = Substitute.For <IRabbitWatcher>();
IConnection rmqConnection;
var connectionFactory = DurableConnectionTestHelper.CreateMockConnectionFactory <ManagedConnectionFactory>("/", out rmqConnection);
var channel = Substitute.For <IModel>();
rmqConnection.CreateModel().Returns(channel);
var durableConnection = new DurableConnection(retryPolicy, watcher, connectionFactory);
durableConnection.CreateChannel();
Assert.AreEqual(1, ManagedConnectionFactory.SharedConnections.Count);
// Action
RabbitTunnel.Factory.CloseAllConnections();
//Assert
rmqConnection.Received().Close(Arg.Any <ushort>(), Arg.Any <string>());
rmqConnection.Received().Dispose();
Assert.AreEqual(0, ManagedConnectionFactory.SharedConnections.Count);
}
// Immediately starts reading messages from the connection and passing them to onMessage.
// Stops reading when Dispose() is called.
public MessagePump(DurableConnection connection, Action<Mantle.Fix44.IServerMessage, long> onMessage)
{
_connection = connection;
_onMessage = onMessage;
_loop = ReceiveLoop();
}
/// <summary>
/// This method should only be called before close the main app. It will close all openning connections to RabbitMQ server
/// </summary>
public void CloseAllConnections()
{
DurableConnection.CloseAllConnections();
}
// Immediately starts reading messages from the connection and passing them to onMessage.
// Stops reading when Dispose() is called.
public MessagePump(DurableConnection connection, Action <Mantle.Fix44.IServerMessage, long> onMessage)
{
_connection = connection;
_onMessage = onMessage;
_loop = ReceiveLoop();
}
