public void ShouldCallExchangeDeclarePubSubTypeIsSubscribeAndExchangeBindingShouldDeclare() { const string queueName = "abc"; _endpoint = new QueueEndpoint() { Name = "testendpoint", PubSubType = PubSubType.Subscribe, Subscription = new SubscriptionConfiguration() { ExchangeBindings = new ExchangeBindingCollection() } }; _endpoint.Subscription.ExchangeBindings.Add( new ExchangeBinding() { Name = "e1", RoutingKey = "rk", Type = ExchangeType.Direct, DeclareExchange = true }); _channel.Stub(x => x.QueueDeclare()).Return(new QueueDeclareOk(queueName, 1, 1)); var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); var binding = _endpoint.Subscription.ExchangeBindings[0]; _channel.AssertWasCalled(x => x.ExchangeDeclare( binding.Name, "direct")); }
public void ShouldCallQueueDeclareAndQueueBindWhenPubSubTypeIsSubscribe() { const string queueName = "abc"; _endpoint = new QueueEndpoint() { Name = "testendpoint", PubSubType = PubSubType.Subscribe, Subscription = new SubscriptionConfiguration() { ExchangeBindings = new ExchangeBindingCollection() } }; _endpoint.Subscription.ExchangeBindings.Add( new ExchangeBinding() { Name = "e1", RoutingKey = "rk" }); _channel.Stub(x => x.QueueDeclare()).Return(new QueueDeclareOk(queueName, 1, 1)); var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); _channel.AssertWasCalled(x => x.QueueDeclare()); _channel.AssertWasCalled(x => x.QueueBind( queueName, _endpoint.Subscription.ExchangeBindings[0].Name, _endpoint.Subscription.ExchangeBindings[0].RoutingKey)); }
public virtual ConnectionFactory GetConnectionFactory(QueueEndpoint endpoint) { _logger.Log("Creating connection factory"); _logger.Log("Hostname: '" + (endpoint.Host ?? "") + "'"); var factory = new ConnectionFactory() { HostName = endpoint.Host }; _logger.Log("VirtualHostName: '" + (endpoint.VirtualHost ?? "") + "'"); if (!string.IsNullOrEmpty(endpoint.VirtualHost)) { _logger.Log("Setting virtual host"); factory.VirtualHost = endpoint.VirtualHost; } _logger.Log("Port: " + (endpoint.Port.HasValue ? endpoint.Port.Value.ToString() : "[not set]")); if(endpoint.Port.HasValue) { factory.Port = endpoint.Port.Value; } if (!string.IsNullOrEmpty(endpoint.User)) { _logger.Log("Setting user and password"); factory.UserName = endpoint.User; factory.Password = endpoint.Password; } return factory; }
private void HandleExchange(QueueEndpoint endpoint, IModel channel) { if ( endpoint.Exchange != null && !string.IsNullOrEmpty(endpoint.Exchange.Name)) { LogExchangeDeclareData(endpoint); channel.ExchangeDeclare(endpoint.Exchange.Name, endpoint.Exchange.Type.ToString().ToLower(), endpoint.Exchange.Durable); } }
protected void SetupEndpoint(string virtualHost, string queueName, string exchangeName) { if (!string.IsNullOrWhiteSpace(exchangeName)) { Exchange = new ExchangeConfiguration() { Name = exchangeName, Type = RabbitMQUtil.ExchangeType.Fanout }; } QueueEndpoint = new QueueEndpoint() { VirtualHost = virtualHost, RoutingKey = queueName, Exchange = Exchange }; }
protected ConnectionFactory CreateFactoryMock(QueueEndpoint endPoint, IBasicProperties properties, byte[] data) { SetupModel(endPoint, properties, data); var connection = MockRepository.GenerateStub<IConnection>(); connection .Stub(x => x.CreateModel()) .Return(Model); var factory = MockRepository.GenerateStub<ConnectionFactory>(); factory.Stub(x => x.CreateConnection()) .Return(connection); return factory; }
private static void HandleSubscription(QueueEndpoint endpoint, IModel channel) { if (endpoint.Subscription == null) { throw new InvalidOperationException( "No subscription configuration was supplied. When an endpoints PubSubType is 'Subscribe', subscription configuration is mandatory."); } var queueName = string.IsNullOrWhiteSpace(endpoint.Subscription.QueueName) ? channel.QueueDeclare() : channel.QueueDeclare(endpoint.Subscription.QueueName, endpoint.Subscription.Durable, false, false, null); for (var x = 0; x < endpoint.Subscription.ExchangeBindings.Count; x++) { var exchangeBinding = endpoint.Subscription.ExchangeBindings[x]; if (exchangeBinding.DeclareExchange) { channel.ExchangeDeclare(exchangeBinding.Name, exchangeBinding.Type.ToString().ToLower()); } channel.QueueBind(queueName, exchangeBinding.Name, exchangeBinding.RoutingKey); } }
private void LogExchangeDeclareData(QueueEndpoint endpoint) { _logger.Log("Declaring exchange: " + endpoint.Exchange.Name); _logger.Log("Exchange type: " + endpoint.Exchange.Type.ToString()); _logger.Log("Exchange durable: " + endpoint.Exchange.Durable.ToString()); }
public virtual void ConfigureQueue(QueueEndpoint endpoint, IModel channel) { HandleExchange(endpoint, channel); if (endpoint.PubSubType != PubSubType.Subscribe) return; HandleSubscription(endpoint, channel); }
public virtual void ConfigureErrorHandling(QueueEndpoint endpoint, IModel channel) { HandleErrorConfig(endpoint.Subscription, channel); }
public void ShouldCallQueueDeclareWithParametersWhenPubSubTypeIsSubscribeAndRoutingKeyIsSet() { const string queueName = "abc"; var expectedResult = new QueueDeclareOk(queueName, 1, 1); _endpoint = new QueueEndpoint() { Name = "testendpoint", Exchange = new ExchangeConfiguration() { Name = "ex1" }, PubSubType = PubSubType.Subscribe, RoutingKey = queueName, Subscription = new SubscriptionConfiguration() { QueueName = "abckduf", NoAck = false } }; _endpoint.Subscription.ExchangeBindings.Add(new ExchangeBinding() { Name = "e1" }); _channel .Stub(x => x.QueueDeclare()) .Return(new QueueDeclareOk(queueName, 1, 1)); _channel .Stub(x => x.QueueDeclare(_endpoint.Subscription.QueueName, _endpoint.Subscription.NoAck, false, false, null)) .Return(expectedResult); var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); _channel.AssertWasCalled(x => x.QueueDeclare(_endpoint.Subscription.QueueName, _endpoint.Subscription.Durable, false, false, null)); _channel.AssertWasCalled(x => x.QueueBind(expectedResult, _endpoint.Subscription.ExchangeBindings[0].Name, "")); }
protected void SetupEndpoint(string name, string virtualHost, string routingKey) { QueueEndpoint = new QueueEndpoint() { Name = name, RoutingKey = routingKey, VirtualHost = virtualHost, PubSubType = PubSubType.Subscribe }; }
public void ShouldThrowExceptionIfPubSubTypeIsSubscribeAndNoSubscriptionConfigExists() { const string queueName = "abc"; var expectedResult = new QueueDeclareOk(queueName, 1, 1); _endpoint = new QueueEndpoint() { Name = "testendpoint", Exchange = new ExchangeConfiguration() { Name = "ex1" }, PubSubType = PubSubType.Subscribe, RoutingKey = queueName, Subscription = null }; var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); }
public void ShouldNotCallQueueDeclareAndQueueBindWhenPubSubTypeIsPublish() { const string queueName = "abc"; _endpoint = new QueueEndpoint() { Name = "testendpoint", Exchange = new ExchangeConfiguration() { Name = "ex1" }, Subscription = new SubscriptionConfiguration() { QueueName = "asdf" }, PubSubType = PubSubType.Publish }; _channel.Stub(x => x.QueueDeclare()).Return(new QueueDeclareOk(queueName, 1, 1)); var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); _channel.AssertWasNotCalled(x => x.QueueDeclare()); _channel.AssertWasNotCalled(x => x.QueueBind(_endpoint.Subscription.QueueName, _endpoint.Exchange.Name, "")); }
public void ShouldNotCallExchangeDeclareIfExchangesNameIsEmpty() { _endpoint = new QueueEndpoint() { Name = "testendpoint", Exchange = new ExchangeConfiguration() { Name = string.Empty, Type = ExchangeType.Fanout}, PubSubType = PubSubType.Publish, RoutingKey = "asdf", Subscription = null }; var configurator = new ChannelConfigurator(); configurator.ConfigureQueue(_endpoint, _channel); _channel.AssertWasNotCalled(x => x.ExchangeDeclare(_endpoint.Exchange.Name, _endpoint.Exchange.Type.ToString().ToLower())); }
protected void SetupModel(QueueEndpoint endPoint, IBasicProperties properties, byte[] data) { Model = MockRepository.GenerateStub<IModel>(); Model.Stub(x => x.QueueDeclare(endPoint.RoutingKey, false, false, false, null)) .Return(new QueueDeclareOk(endPoint.RoutingKey, 1, 1)); Model.Stub(x => x.CreateBasicProperties()) .Return(properties); Model.Stub(x => x.BasicPublish(Exchange != null ? Exchange.Name : null, endPoint.RoutingKey, properties, data)); }
protected void SetupModel(QueueEndpoint endPoint, IBasicProperties properties, byte[] data) { Model = MockRepository.GenerateStub<IModel>(); Model.Stub(x => x.QueueDeclare(endPoint.RoutingKey, false, false, false, null)) .Return(new QueueDeclareOk(endPoint.RoutingKey, 1, 1)); Model.Stub(x => x.BasicConsume(endPoint.RoutingKey, true, Consumer)) .Return(null); }
protected void SetupModelBasicGet(QueueEndpoint endPoint, BasicGetResult result) { Model.Stub(x => x.BasicGet(endPoint.RoutingKey, false)).Return(result); }
private void LogEndpointData(ConnectionFactory factory, QueueEndpoint endpoint) { _logger.Log("Host: " + factory.HostName); _logger.Log("Virtual host: " + factory.VirtualHost); _logger.Log("ExchangeName: '" + GetExchangeName(endpoint) + "'"); _logger.Log("RoutingKey: '" + endpoint.RoutingKey + "'"); }
protected void ValidateEndpoint(QueueEndpoint endpoint) { if (endpoint.PubSubType == PubSubType.Publish) throw new InvalidOperationException("ReceiveListener cannot be started on an endpoint with PubSubType.Publish."); }
private static string GetExchangeName(QueueEndpoint endpoint) { return endpoint.Exchange != null ? endpoint.Exchange.Name : string.Empty; }