public void Close_Where_No_Pending_Publications_Which_Results_In_A_Context_Transition_To_Closed()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For <IConnectionManager>();
var _connection = Substitute.For <IConnection>();
var _channel = Substitute.For <IModel>();
var _context = Substitute.For <IBusContext>();
_connectionManager.Connection.Returns(_connection);
_connection.CreateModel().Returns(_channel);
var _SUT = new Connected(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
State _capturedState = null;
_context.When(context => context.State = Arg.Any <State>()).Do(callInfo => _capturedState = callInfo[0] as State);
_SUT.Close();
Assert.IsInstanceOf <Closed>(_capturedState);
}
public void Publish_Connection_Closed_By_Application_Never_Recovers()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => Accessories.Configuration.QueueName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Verify connection exists. Press enter to close connection ...");
Console.ReadKey();
// Close the connection explicitly
_SUT.Close();
// Attempt to publish after closing the connection from the application, this should never happen in reality ...
var _message = new Accessories.MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
var _result = _SUT.PublishAsync(_message);
Console.WriteLine("Should keep retrying to publish every second indefinitely");
Console.WriteLine("This is due to the fact that the application initiated the close");
Console.WriteLine("Normally, close is only called when application is closing down");
Console.Read();
}
public void InstantiateAndStartConsumer()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
this.InstantiateAndStartConsumer(_busConfigurationBuilder.Build());
}
public void Run_Where_We_Continuously_Publish_Until_Program_Killed()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to start publishing messages {0}", DateTime.Now);
Console.ReadLine();
var _sequence = 1;
while (true)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
try
{
var _result = _SUT.PublishAsync(_message);
_result.Wait();
Console.WriteLine("Result status is {0}", _result.Status);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
Thread.Sleep(500);
_sequence++;
}
}
public void Consume_Continues_When_Node_We_Are_Not_Connected_To_Is_Blocked()
{
var _publisherBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "publisher"));
_publisherBusConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.1");
var _publisherBus = new Bus(_publisherBusConfigurationBuilder.Build());
_publisherBus.Connect();
// Let node that we are connected to = NodeA
// Let other node = NodeB
// Before blocking rabbitmq service on NodeB, verify cluster is in working order
// We publish 50,000 messages and verify that these are on the queue
// We continuously consume the 50,000 messages
// During consumption, block NodeB for a period of time, then unblock
// rabbitmqctl set_vm_memory_high_watermark 0.0000001
// rabbitmqctl set_vm_memory_high_watermark 0.4
// Verify 0 messages exist on queue
// Verify consumed message count is at least 50,000
for (int count = 0; count < 50000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_publisherBus.PublishAsync(_message);
}
Console.WriteLine("Verify exactly 50000 messages in the queue");
// Note that we see that a number of messages seem to get delivered more than once. This however is expected behaviour as we are using acknowledgements
// See link: https://groups.google.com/forum/#!topic/rabbitmq-users/PODU8wIYmQs
Console.ReadKey();
var _consumedMessageCount = 0;
var _consumerBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "consumer"));
_consumerBusConfigurationBuilder.NumberOfConsumers = 5;
_consumerBusConfigurationBuilder
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName1,
typeof(Accessories.MyEvent).Name,
message => {
Interlocked.Increment(ref _consumedMessageCount);
return(ConsumerHandlerResult.Completed);
});
var _consumerBus = new Bus(_consumerBusConfigurationBuilder.Build());
_consumerBus.Connect();
for (int _counter = 0; _counter < 60; _counter++)
{
Thread.Sleep(1000);
Console.WriteLine(string.Format("{0} seconds completed", _counter));
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine(string.Format("Consumed message count expected(at least): (50000), actual: ({0})", _consumedMessageCount));
Console.ReadKey();
}
public void Publish_A_Message_And_Consume_For_The_Same_Message_With_Nack_And_Dead_Letter_Queue()
{
var _capturedMessageId = string.Empty;
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { _capturedMessageId = message.Id.ToString(); return(ConsumerHandlerResult.Errored); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
Thread.Sleep(2000);
Console.WriteLine(string.Format("Captured message id expected: ({0}), actual: ({1})", _messageId, _capturedMessageId));
Console.WriteLine(string.Format("Ensure message with id: ({0}) no longer exists in the queue", _messageId));
Console.WriteLine(string.Format("Ensure message with id: ({0}) exists in the dead letter queue - rejected", _messageId));
Console.Read();
}
public void Run_Where_We_Create_A_Transient_Queue_And_Then_Close_Connection()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(
Configuration.ExchangeName1,
typeof(MyEvent).Name)
.RegisterConsumer <MyEvent>(
typeof(MyEvent).Name,
message => { return(ConsumerHandlerResult.Completed); },
Configuration.ExchangeName1);
this.InstantiateAndStartConsumer(_busConfigurationBuilder.Build());
Console.WriteLine("You should see a new transient queue in the dashboard)");
Console.ReadLine();
this.c_cancellationTokenSource.Cancel();
Console.WriteLine("Hit enter to close connection (Channel should already be closed - check the dashboard)");
Console.ReadLine();
this.c_connection.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Publish_A_Message_To_Two_Exchanges_No_Consumption_For_The_Same_Messsage()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name)
.RegisterPublication <MyEvent>(Configuration.ExchangeName2, typeof(MyEvent).Name);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish message");
Console.ReadLine();
var _message = new MyEvent(Guid.NewGuid(), null, "R1", 1, "09:00", "DDD....");
var _result = _SUT.PublishAsync(_message);
_result.Wait();
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Publish_A_Message_And_Consume_For_The_Same_Messsage_On_A_Transient_Queue()
{
var _capturedMessageId = string.Empty;
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name)
.RegisterConsumer <MyEvent>(
typeof(MyEvent).Name,
message => { _capturedMessageId = message.Id.ToString(); return(ConsumerHandlerResult.Completed); },
Configuration.ExchangeName1);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish message");
Console.ReadLine();
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", 1, "09:00", "....");
_SUT.PublishAsync(_message);
Console.WriteLine("Hit enter to display captured message Id");
Console.ReadLine();
Console.WriteLine("Captured message Id [{0}]", _capturedMessageId);
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Attempt_A_Publication_Timeout()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to try publishing message");
Console.ReadLine();
var _sequence = 1;
while (true)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:12", "...");
try
{
var _result = _SUT.PublishAsync(_message);
var _completedWithinTimeout = _result.Wait(TimeSpan.FromTicks(1));
Console.WriteLine("Completed within time out = {0}", _completedWithinTimeout);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
Thread.Sleep(500);
_sequence++;
}
}
public void Publish_1000_Messages_And_Consume_For_The_Same_Messages_With_Half_Acked_Half_Nacked()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { return(bool.Parse(message.RunIdentifier) ? ConsumerHandlerResult.Completed : ConsumerHandlerResult.Errored); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
for (int count = 0; count < 1000; count++)
{
var _messageId = Guid.NewGuid();
var _runIdentifier = (count % 2 == 0);
var _message = new Accessories.MyEvent(_messageId, null, _runIdentifier.ToString(), 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure 500 messages exists in the dead letter queue - rejected");
Console.Read();
}
public void State_Changed_Where_Connection_Is_Disconnected_Results_In_A_Context_Transition_To_Diconnected()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For <IConnectionManager>();
var _connection = Substitute.For <IConnection>();
var _channel = Substitute.For <IModel>();
var _context = Substitute.For <IBusContext>();
_connectionManager.Connection.Returns(_connection);
_connection.CreateModel().Returns(_channel);
var _SUT = new Connected(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
State _capturedState = null;
_context.When(context => context.State = Arg.Any <State>()).Do(callInfo => _capturedState = callInfo[0] as State);
_connectionManager.Disconnected += Raise.Event <EventHandler <ConnectionDisconnectedEventArgs> >(_connection, new ConnectionDisconnectedEventArgs(1, "."));
Assert.IsInstanceOf <Disconnected>(_capturedState);
}
public void Run_Where_We_Transition_Between_States_By_Instructing_The_Broker()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Stop the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat stop");
Console.WriteLine("Block the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat set_vm_memory_high_watermark 0.0000001");
var _index = 1;
do
{
var _myEvent = new MyEvent(Guid.NewGuid(), "", "R1", _index, "09:00", "DDD....");
var _task = _SUT.PublishAsync(_myEvent);
_task.Wait();
_index++;
Console.WriteLine("Hit enter to publish a message, x to exit");
} while (Console.ReadLine() != "x");
Console.WriteLine("After stopping the broker hit enter to exit");
Console.ReadLine();
_SUT.Close();
}
public void PublishAsync_Where_Connection_Is_Disconnected_Results_In_A_Non_Published_Result()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For <IConnectionManager>();
var _connection = Substitute.For <IConnection>();
var _channel = Substitute.For <IModel>();
var _context = Substitute.For <IBusContext>();
_connectionManager.Connection.Returns(_connection);
_connection.CreateModel().Returns(_channel);
var _SUT = new Connected(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
_connectionManager.Disconnected += Raise.Event <EventHandler <ConnectionDisconnectedEventArgs> >(_connection, new ConnectionDisconnectedEventArgs(1, "."));
var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1);
var _publicationResult = _SUT.PublishAsync(_theEvent);
_publicationResult.Wait();
Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.NotPublished, _publicationResult.Result.Status);
}
public void Publish_1000_Messages_To_A_Queue_Using_Custom_Exchange()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => Accessories.Configuration.QueueName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
var _tasks = new ConcurrentBag <Task <PMCG.Messaging.PublicationResult> >();
for (int count = 0; count < 1000; count++)
{
var _message = new Accessories.MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
_tasks.Add(_SUT.PublishAsync(_message));
}
Task.WhenAll(_tasks).ContinueWith(a =>
{
var _taskStatusCount = _tasks.Count(result => result.Status == TaskStatus.RanToCompletion);
var _messagePublishedCount = _tasks.Count(result => result.Result.Status == Messaging.PublicationResultStatus.Published);
Console.WriteLine(string.Format("RanToCompletionTaskCount expected: (1000), actual: ({0})", _taskStatusCount));
Console.WriteLine(string.Format("MessagePublishedCount expected: (1000), actual: ({0})", _messagePublishedCount));
Console.WriteLine("Verify that 1000 messages on queue on management ui");
});
Console.Read();
}
public void Publish_Where_Publication_Configurations_Exist_Which_Results_In_Blocked_Result()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For <IConnectionManager>();
var _context = Substitute.For <IBusContext>();
var _SUT = new Blocked(
_busConfirguration,
_connectionManager,
_context);
var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1);
var _publicationResult = _SUT.PublishAsync(_theEvent);
_publicationResult.Wait();
Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.Blocked, _publicationResult.Result.Status);
}
public void Run_Where_We_Publish_A_Null_Message_Results_In_An_Exception()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name)
.RegisterPublication <MyEvent>(Configuration.ExchangeName2, typeof(MyEvent).Name);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish null message, which should result in an exception");
Console.ReadLine();
try
{
_SUT.PublishAsync <MyEvent>(null);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Publish_10000_Messages_And_Consume_For_The_Same_Messages_With_Ack_Connection_Closed_By_Server_Recovers_Automatically()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { return(ConsumerHandlerResult.Completed); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Close connection via rabbitmq management ui while loop is executing");
for (int count = 0; count < 10000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure there are some messages in the dead letter queue(reason expired)");
Console.ReadKey();
}
public void Run_Where_We_Publish_A_Message_To_A_Queue_Using_The_Direct_Exchange()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>("", typeof(MyEvent).Name, MessageDeliveryMode.Persistent, message => Configuration.QueueName1);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish message");
Console.ReadLine();
var _message = new MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
var _result = _SUT.PublishAsync(_message);
_result.Wait(TimeSpan.FromSeconds(1));
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Publish_1000_Messages_And_Consume_For_The_Same_Messsage_On_A_Transient_Queue()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name)
.RegisterConsumer <Accessories.MyEvent>(
typeof(Accessories.MyEvent).Name,
message => { return(ConsumerHandlerResult.Completed); },
Accessories.Configuration.ExchangeName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Wait for transient queue to appear on management ui");
Console.ReadKey();
var _message = new Accessories.MyEvent(Guid.NewGuid(), "Correlation Id", "R1", 1, "09:00", "....");
for (int count = 0; count < 1000; count++)
{
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure transient queue appears and disappears");
Console.ReadKey();
}
public void Run_Where_We_Create_A_Transient_Queue_And_Then_Close_Connection()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(
Configuration.ExchangeName1,
typeof(MyEvent).Name)
.RegisterConsumer<MyEvent>(
typeof(MyEvent).Name,
message => { return ConsumerHandlerResult.Completed; },
Configuration.ExchangeName1);
this.InstantiateAndStartConsumer(_busConfigurationBuilder.Build());
Console.WriteLine("You should see a new transient queue in the dashboard)");
Console.ReadLine();
this.c_cancellationTokenSource.Cancel();
Console.WriteLine("Hit enter to close connection (Channel should already be closed - check the dashboard)");
Console.ReadLine();
this.c_connection.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Connect_Where_Connection_Is_Established_Results_In_Transition_To_Connected_State()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For <IConnectionManager>();
var _context = Substitute.For <IBusContext>();
var _SUT = new Closed(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
List <State> _capturedStates = new List <State>();
_context.When(context => context.State = Arg.Any <State>()).Do(callInfo => _capturedStates.Add(callInfo[0] as State));
_SUT.Connect();
Assert.IsInstanceOf <Connecting>(_capturedStates[0]);
Assert.IsInstanceOf <Connected>(_capturedStates[1]);
}
public void Consume_Where_We_Mock_All_Without_A_Real_Connection_Knows_Too_Much_About_RabbitMQ_Internals()
{
var _waitHandle = new AutoResetEvent(false);
var _capturedMessageId = Guid.Empty;
var _configurationBuilder = new BusConfigurationBuilder();
_configurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_configurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
typeof(MyEvent).Name,
message =>
{
_capturedMessageId = message.Id;
_waitHandle.Set();
return ConsumerHandlerResult.Completed;
});
var _configuration = _configurationBuilder.Build();
var _connection = Substitute.For<IConnection>();
var _channel = Substitute.For<IModel>();
_connection.CreateModel().Returns(_channel);
var _myEvent = new MyEvent(Guid.NewGuid(), "CorrlationId_1", "Detail", 1);
var _messageProperties = Substitute.For<IBasicProperties>();
_messageProperties.ContentType = "application/json";
_messageProperties.DeliveryMode = (byte)MessageDeliveryMode.Persistent;
_messageProperties.Type = typeof(MyEvent).Name;
_messageProperties.MessageId = _myEvent.Id.ToString();
_messageProperties.CorrelationId = _myEvent.CorrelationId;
_channel.CreateBasicProperties().Returns(_messageProperties);
QueueingBasicConsumer _capturedConsumer = null;
_channel
.When(channel => channel.BasicConsume(TestingConfiguration.QueueName, false, Arg.Any<IBasicConsumer>()))
.Do(callInfo => { _capturedConsumer = callInfo[2] as QueueingBasicConsumer; _waitHandle.Set(); });
var _SUT = new Consumer(_connection, _configuration, CancellationToken.None);
_SUT.Start(); // Can't capture result due to compiler treating warnings as errors
_waitHandle.WaitOne(); // Wait till consumer task has called the BasicConsume method which captures the consumer
_waitHandle.Reset(); // Reset so we can block on the consumer message func
var _messageJson = JsonConvert.SerializeObject(_myEvent);
var _messageBody = Encoding.UTF8.GetBytes(_messageJson);
_capturedConsumer.Queue.Enqueue(
new BasicDeliverEventArgs
{
ConsumerTag = "consumerTag",
DeliveryTag = 1UL,
Redelivered = false,
Exchange = "TheExchange",
RoutingKey = "ARoutingKey",
BasicProperties = _messageProperties,
Body = _messageBody
});
_waitHandle.WaitOne(); // Wait for message to be consumed
Assert.AreEqual(_myEvent.Id, _capturedMessageId);
}
public void InstantiateAndStartConsumer()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
this.InstantiateAndStartConsumer(_busConfigurationBuilder.Build());
}
public void SetUp()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(TestingConfiguration.ConnectionSettingsString);
_busConfigurationBuilder.RegisterPublication <MyEvent>("", typeof(MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.1");
this.c_busConfiguration = _busConfigurationBuilder.Build();
this.c_connectionManager = Substitute.For <IConnectionManager>();
this.c_connectionManager.IsOpen.ReturnsForAnyArgs(true);
}
public void Consume_Continues_When_Node_We_Are_Connected_To_Is_Rebooted()
{
var _publisherBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "publisher"));
_publisherBusConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.1");
var _publisherBus = new Bus(_publisherBusConfigurationBuilder.Build());
_publisherBus.Connect();
// Let node that we are connected to = NodeA
// Let other node = NodeB
// Before rebooting NodeA, verify cluster is in working order
// We publish 50,000 messages and verify that these are on the queue
// We continuously consume the 50,000 messages
// During consumption, reboot NodeA
// Verify 0 messages exist on queue
// Verify consumed message count is nearly 50,000
for (int count = 0; count < 50000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_publisherBus.PublishAsync(_message);
}
Console.WriteLine("Verify at least 50000 messages in the queue");
Console.ReadKey();
var _consumedMessageCount = 0;
var _consumerBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "consumer"));
_consumerBusConfigurationBuilder.NumberOfConsumers = 5;
_consumerBusConfigurationBuilder
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName1,
typeof(Accessories.MyEvent).Name,
message => {
Interlocked.Increment(ref _consumedMessageCount);
return(ConsumerHandlerResult.Completed);
});
var _consumerBus = new Bus(_consumerBusConfigurationBuilder.Build());
_consumerBus.Connect();
for (int _counter = 0; _counter < 60; _counter++)
{
Thread.Sleep(1000);
Console.WriteLine(string.Format("{0} seconds completed", _counter));
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine(string.Format("Consumed message count expected(nearly): (50000), actual: ({0})", _consumedMessageCount));
Console.ReadKey();
}
public void Status_Initialised()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
Assert.AreEqual(BusStatus.Initialised, _SUT.Status);
}
public void PublishAsync_Null_Message_Results_In_An_Exception()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
_SUT.Connect();
_SUT.PublishAsync<MyEvent>(null);
}
public void Status_Initialised()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
Assert.AreEqual(BusStatus.Initialised, _SUT.Status);
}
public void Connect_Restart_Broker_Connection_Reestablished_Automatically()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine(@"Stop the broker by running the following command '.\rabbitmqctl.bat stop'");
Console.WriteLine(@"Start the broker by running the following command '.\rabbitmq-server.bat -detached'");
Console.WriteLine("Verify connection in management ui is re-established automatically via automatic recovery");
Console.Read();
}
public void Run_Where_We_Connect_And_Instruct_To_Close_The_Connection_Using_The_DashBoard()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Close the connection from the dashboard");
Console.WriteLine("After closing the connecton hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Instantiate_And_Instruct_To_Stop_The_Broker()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
Console.WriteLine("Stop the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat stop");
Console.WriteLine("After stopping the broker hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Publish_A_Message_Subject_To_A_Timeout_And_Consume_The_Same_Messsage()
{
var _capturedMessageId = string.Empty;
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication <MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name)
.RegisterPublication <MyEvent>("A.Different.Exchange", typeof(MyEvent).Name)
.RegisterConsumer <MyEvent>(
Configuration.QueueName1,
typeof(MyEvent).Name,
message => { _capturedMessageId = message.Id.ToString(); return(ConsumerHandlerResult.Completed); });
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish message");
Console.ReadLine();
var _message = new MyEvent(Guid.NewGuid(), null, null, 1, null, "DDD....");
try
{
var _task = _SUT.PublishAsync(_message);
if (!_task.Wait(TimeSpan.FromMilliseconds(100)))
{
Console.WriteLine("Timed out !");
}
}
catch (AggregateException aggregateException)
{
Console.WriteLine(aggregateException);
foreach (var _internalException in aggregateException.InnerExceptions)
{
Console.WriteLine(_internalException);
}
}
catch (Exception genericException)
{
Console.WriteLine(genericException);
}
Console.WriteLine("Captured message Id [{0}]", _capturedMessageId);
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Connect_Close_The_Connection_Using_The_Management_UI_Connection_Reestablished_Automatically()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Close the connection from the management ui");
Console.WriteLine("Verify connection in management ui is re-established automatically via automatic recovery");
Console.WriteLine("Verify the correct connection close reason is output to the console - 'Closed via management plugin'");
Console.Read();
}
public void PublishAsync_Null_Message_Results_In_An_Exception()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
_SUT.Connect();
_SUT.PublishAsync <MyEvent>(null);
}
private PMCG.Messaging.Client.ConsumerMessageProcessor BuildSUT(
Func <MyEvent, ConsumerHandlerResult> action = null)
{
var _busConfigurationBuilder = new BusConfigurationBuilder("hosts=localhost;port=5672;virtualhost=/;clientprovidedname=myConnectionClientProvidedName;username=guest;ispasswordencrypted=false;password=Pass");
_busConfigurationBuilder.RegisterConsumer(
TestingConfiguration.QueueName,
typeof(MyEvent).Name,
action);
var _busConfiguration = _busConfigurationBuilder.Build();
return(new PMCG.Messaging.Client.ConsumerMessageProcessor(_busConfiguration));
}
public void Run_Where_We_Instantiate_And_Instruct_To_Stop_The_Broker()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
Console.WriteLine("Stop the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat stop");
Console.WriteLine("After stopping the broker hit enter to exit");
Console.ReadLine();
}
public void Status_Connected_And_Then_Closed()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
_SUT.Connect();
Assert.AreEqual(BusStatus.Connected, _SUT.Status);
_SUT.Close();
Assert.AreEqual(BusStatus.Closed, _SUT.Status);
}
public void Run_Where_We_Connect_And_Then_Close()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Instantiate_And_Try_To_Connect_To_Non_Existent_Broker()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri.Replace("5672", "2567/")); // Wrong port number
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Allow time for connection attempt to fail, check bus state which should be disconnected");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Connect_Results_In_An_Invalid_Operation_Exception()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Blocked(
_busConfirguration,
_connectionManager,
_context);
_SUT.Connect();
}
public void Ctor_Success()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Closed(
_busConfirguration,
_connectionManager,
_context);
Assert.IsNotNull(_SUT);
}
public void SetUp()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add("....");
_busConfigurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
typeof(MyEvent).Name,
message =>
{
this.c_messageProcessrResult = ConsumerHandlerResult.Completed;
return ConsumerHandlerResult.Completed;
});
_busConfigurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
typeof(MyEvent).FullName,
message =>
{
this.c_messageProcessrResult = ConsumerHandlerResult.Completed;
return ConsumerHandlerResult.Completed;
});
_busConfigurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
"Throw_Error_Type_Header",
message =>
{
throw new ApplicationException("Bang !");
});
_busConfigurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
"Returns_Errored_Result",
message =>
{
this.c_messageProcessrResult = ConsumerHandlerResult.Errored;
return ConsumerHandlerResult.Errored;
});
var _busConfiguration = _busConfigurationBuilder.Build();
var _connection = Substitute.For<IConnection>();
this.c_channel = Substitute.For<IModel>();
_connection.CreateModel().Returns(this.c_channel);
this.c_SUT = new ConsumerMessageProcessor(_busConfiguration);
this.c_messageProcessrResult = ConsumerHandlerResult.None;
}
public void InstantiateConsumerTasks()
{
var _connectionUri = Configuration.LocalConnectionUri;
this.c_connection = new ConnectionFactory { Uri = _connectionUri }.CreateConnection();
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(_connectionUri);
this.c_cancellationTokenSource = new CancellationTokenSource();
this.c_consumerTasks = new Task[this.c_numberOfConsumers];
for(var _index = 0; _index < this.c_numberOfConsumers; _index++)
{
var _consumer = new PMCG.Messaging.Client.Consumer(this.c_connection, _busConfigurationBuilder.Build(), this.c_cancellationTokenSource.Token);
this.c_consumerTasks[_index] = _consumer.Start();
}
}
public void Ctor_Success()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
new Blocked(
_busConfirguration,
_connectionManager,
_context);
}
public void SetUp()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder.ConsumerDequeueTimeout = TimeSpan.FromMilliseconds(20);
_busConfigurationBuilder.RegisterConsumer<MyEvent>(
TestingConfiguration.QueueName,
typeof(MyEvent).Name,
message =>
{
return ConsumerHandlerResult.Completed;
});
this.c_busConfiguration = _busConfigurationBuilder.Build();
this.c_connection = Substitute.For<IConnection>();
this.c_channel = Substitute.For<IModel>();
this.c_cancellationTokenSource = new CancellationTokenSource();
this.c_connection.CreateModel().Returns(this.c_channel);
}
public void PublishAsync_Where_No_Publication_Configurations_Which_Results_In_A_NoConfigurationFound_Result()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Connected(
_busConfirguration,
_connectionManager,
_context);
var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1);
var _publicationResult = _SUT.PublishAsync(_theEvent);
_publicationResult.Wait();
Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.NoConfigurationFound, _publicationResult.Result.Status);
}
public void Connect_Where_Connection_Is_Not_Established_Results_In_Transition_To_Connecting_State()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Closed(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
State _capturedState = null;
_context.When(context => context.State = Arg.Any<State>()).Do(callInfo => _capturedState = callInfo[0] as State);
_SUT.Connect();
Assert.IsInstanceOf<Connecting>(_capturedState);
}
public void PublishAsync_Where_A_Single_Publication_Configuration_Which_Results_In_A_Successfull_Publication()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _connection = Substitute.For<IConnection>();
var _channel = Substitute.For<IModel>();
var _context = Substitute.For<IBusContext>();
var _waitHandle = new AutoResetEvent(false);
_connectionManager.Connection.Returns(_connection);
_connection.CreateModel().Returns(_channel);
_channel.NextPublishSeqNo.Returns(1UL);
_channel
.When(channel => channel.BasicPublish(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IBasicProperties>(), Arg.Any<byte[]>()))
.Do(callInfo => _waitHandle.Set());
var _SUT = new Connected(
_busConfirguration,
_connectionManager,
_context);
var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1);
var _publicationResult = _SUT.PublishAsync(_theEvent);
_waitHandle.WaitOne(); // Allow publication to complete
_channel.BasicAcks += Raise.Event<BasicAckEventHandler>(_channel, new BasicAckEventArgs { Multiple = true, DeliveryTag = 10 });
_publicationResult.Wait();
Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.Published, _publicationResult.Result.Status);
}
public void Publish_Where_Publication_Configurations_Exist_Which_Results_In_Blocked_Result()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(
TestingConfiguration.ExchangeName,
typeof(MyEvent).Name);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Blocked(
_busConfirguration,
_connectionManager,
_context);
var _theEvent = new MyEvent(Guid.NewGuid(), null, "Some detail", 1);
var _publicationResult = _SUT.PublishAsync(_theEvent);
_publicationResult.Wait();
Assert.AreEqual(PMCG.Messaging.PublicationResultStatus.Blocked, _publicationResult.Result.Status);
}
public void Run_Where_We_Publish_Multiple_Messages_And_Consume_For_The_Same_Messsages()
{
var _numberOfMessagesToPublish = 3;
var _receivedMessages = new ConcurrentStack<MyEvent>();
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1")
.RegisterConsumer<MyEvent>(
Configuration.QueueName1,
typeof(MyEvent).Name + "v1",
message => { _receivedMessages.Push(message); return ConsumerHandlerResult.Completed; });
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish messages {0}", DateTime.Now);
Console.ReadLine();
Console.WriteLine("About to publish messages {0}", DateTime.Now);
for (var _sequence = 1; _sequence <= _numberOfMessagesToPublish; _sequence++)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
_SUT.PublishAsync(_message);
Thread.Sleep(100);
}
Console.WriteLine("Completed publishing messages {0}", DateTime.Now);
Console.WriteLine("Hit enter to verify recieved messages {0}", DateTime.Now);
var _stopwatch = Stopwatch.StartNew();
while (_receivedMessages.Count < _numberOfMessagesToPublish)
{
Console.WriteLine("{0} Received message count {1}", DateTime.Now, _receivedMessages.Count);
Thread.Sleep(100);
}
_stopwatch.Stop();
Console.WriteLine("{0} Received message count {1}", _stopwatch.ElapsedMilliseconds, _receivedMessages.Count);
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Consume_From_A_Transient_Queue_On_A_Cluster()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri.Replace("rabbit1", "rabbit2"));
_busConfigurationBuilder.RegisterConsumer<MyEvent>("RunMessage",
message =>
{
Console.WriteLine("Received message");
Thread.Sleep(3000);
return ConsumerHandlerResult.Completed;
},
Configuration.ExchangeName2);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to stop consuming");
Console.ReadLine();
_SUT.Close();
}
public void Run_Where_We_Continuously_Publish_Until_Program_Killed()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to start publishing messages {0}", DateTime.Now);
Console.ReadLine();
var _sequence = 1;
while(true)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
try
{
var _result = _SUT.PublishAsync(_message);
_result.Wait();
Console.WriteLine("Result status is {0}", _result.Status);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
Thread.Sleep(500);
_sequence++;
}
}
public void Run_Where_A_Consumer_Also_Publishes_A_Message_Consumer_Handler_Uses_A_Closure_To_Allow_Publishing_Using_The_Same_Bus_Reference()
{
PMCG.Messaging.Client.Bus _bus = null;
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
_busConfigurationBuilder.RegisterPublication<MyOtherEvent>(Configuration.ExchangeName2, typeof(MyOtherEvent).Name + "v1");
_busConfigurationBuilder.RegisterConsumer<MyEvent>(Configuration.QueueName1, typeof(MyEvent).Name + "v1",
message =>
{
Console.WriteLine("Consuming message");
_bus.PublishAsync(new MyOtherEvent(Guid.NewGuid(), message.CorrelationId, "Pub with closure", message.Sequence));
Thread.Sleep(4000);
return ConsumerHandlerResult.Completed;
});
_bus = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_bus.Connect();
Console.WriteLine("Hit enter to try publishing message");
Console.ReadLine();
var _sequence = 1;
do
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
try
{
var _result = _bus.PublishAsync(_message);
var _completedWithinTimeout = _result.Wait(TimeSpan.FromTicks(1));
Console.WriteLine("Completed within time out = {0}", _completedWithinTimeout);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
_sequence++;
} while (Console.ReadLine() != "x");
_bus.Close();
Console.WriteLine("Hit enter to finish");
Console.ReadLine();
}
public void Run_Where_We_Continuously_Publish_Handling_All_Results()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to start publishing messages {0}", DateTime.Now);
Console.ReadLine();
var _sequence = 1;
while (true)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
try
{
var _publicationTimeout = TimeSpan.FromTicks(0);
var _result = _SUT.PublishAsync(_message);
_result.Wait(_publicationTimeout);
// PENDING - What do clients do ?
Console.WriteLine("PENDING");
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
//Thread.Sleep(5);
_sequence++;
}
}
public void Run_Where_We_Attempt_A_Publication_Timeout()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to try publishing message");
Console.ReadLine();
var _sequence = 1;
while (true)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:12", "...");
try
{
var _result = _SUT.PublishAsync(_message);
var _completedWithinTimeout = _result.Wait(TimeSpan.FromTicks(1));
Console.WriteLine("Completed within time out = {0}", _completedWithinTimeout);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
Thread.Sleep(500);
_sequence++;
}
}
public void State_Changed_Where_Connection_Is_Unblocked_Results_In_Transition_To_Connected_State()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _connectionManager = Substitute.For<IConnectionManager>();
var _connection = Substitute.For<IConnection>();
var _context = Substitute.For<IBusContext>();
var _SUT = new Blocked(
_busConfirguration,
_connectionManager,
_context);
_context.State.Returns(callInfo => _SUT);
State _capturedState = null;
_context.When(context => context.State = Arg.Any<State>()).Do(callInfo => _capturedState = callInfo[0] as State);
_connectionManager.Unblocked += Raise.Event<EventHandler<EventArgs>>(_connection, new EventArgs());
Assert.IsInstanceOf<Connected>(_capturedState);
}
public void Run_Where_We_Publish_1000_Messages_Waiting_On_Result()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name + "v1");
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to start publishing messages {0}", DateTime.Now);
Console.ReadLine();
var _tasks = new Task[4];
for (var _taskIndex = 0; _taskIndex < _tasks.Length; _taskIndex++)
{
_tasks[_taskIndex] = new Task(() =>
{
for (var _sequence = 1; _sequence <= 1000; _sequence++)
{
Console.WriteLine("About to publish {0}", _sequence);
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", _sequence, "09:01", "...");
try
{
var _result = _SUT.PublishAsync(_message);
_result.Wait();
Console.WriteLine("Result status is {0}", _result.Status);
}
catch (Exception theException)
{
Console.WriteLine("Exception encountered {0}", theException);
}
}
});
}
var _stopwatch = Stopwatch.StartNew();
foreach(var _task in _tasks) { _task.Start(); }
Task.WaitAll(_tasks);
_stopwatch.Stop();
Console.WriteLine("Done {0} elapsed = {1} ms", DateTime.Now, _stopwatch.ElapsedMilliseconds);
Console.ReadLine();
_SUT.Close();
}
public void Run_Where_We_Publish_A_Message_And_Consume_For_The_Same_Messsage_On_A_Transient_Queue()
{
var _capturedMessageId = string.Empty;
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder
.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name)
.RegisterConsumer<MyEvent>(
typeof(MyEvent).Name,
message => { _capturedMessageId = message.Id.ToString(); return ConsumerHandlerResult.Completed; },
Configuration.ExchangeName1);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Hit enter to publish message");
Console.ReadLine();
var _message = new MyEvent(Guid.NewGuid(), "Correlation Id", "R1", 1, "09:00", "....");
_SUT.PublishAsync(_message);
Console.WriteLine("Hit enter to display captured message Id");
Console.ReadLine();
Console.WriteLine("Captured message Id [{0}]", _capturedMessageId);
Console.WriteLine("Hit enter to close");
Console.ReadLine();
_SUT.Close();
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public void Run_Where_We_Transition_Between_States_By_Instructing_The_Broker()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(Configuration.LocalConnectionUri);
_busConfigurationBuilder.RegisterPublication<MyEvent>(Configuration.ExchangeName1, typeof(MyEvent).Name);
var _SUT = new PMCG.Messaging.Client.Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Stop the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat stop");
Console.WriteLine("Block the broker by running the following command as an admin");
Console.WriteLine("\t rabbitmqctl.bat set_vm_memory_high_watermark 0.0000001");
var _index = 1;
do
{
var _myEvent = new MyEvent(Guid.NewGuid(), "", "R1", _index, "09:00", "DDD....");
var _task = _SUT.PublishAsync(_myEvent);
_task.Wait();
_index++;
Console.WriteLine("Hit enter to publish a message, x to exit");
} while (Console.ReadLine() != "x");
Console.WriteLine("After stopping the broker hit enter to exit");
Console.ReadLine();
_SUT.Close();
}
