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 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 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 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(); }