public void TestBatchdAdapter()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
var container = new DirectMessageListenerContainer();
var adapter = new RabbitInboundChannelAdapter(context, container);
var outchan = new QueueChannel(context);
adapter.OutputChannel = outchan;
var listener = container.MessageListener as IChannelAwareMessageListener;
var bs = new SimpleBatchingStrategy(2, 10_000, 10_000L);
var accessor = new MessageHeaderAccessor();
accessor.ContentType = "text/plain";
var message = Message.Create(Encoding.UTF8.GetBytes("test1"), accessor.MessageHeaders);
bs.AddToBatch("foo", "bar", message);
message = Message.Create(Encoding.UTF8.GetBytes("test2"), accessor.MessageHeaders);
var batched = bs.AddToBatch("foo", "bar", message);
Assert.NotNull(batched);
listener.OnMessage(batched.Value.Message, null);
var received = outchan.Receive();
Assert.NotNull(received);
var asList = received.Payload as List <object>;
Assert.NotNull(asList);
Assert.Equal(2, asList.Count);
Assert.Contains("test1", asList);
Assert.Contains("test2", asList);
}
private void TestFullConfiguration(IApplicationContext context)
{
var simpleFactory = context.GetService <IRabbitListenerContainerFactory>("simpleFactory") as RabbitListenerContainerTestFactory;
Assert.Single(simpleFactory.ListenerContainers);
var testContainer = simpleFactory.GetListenerContainers()[0];
var endpoint = testContainer.Endpoint as AbstractRabbitListenerEndpoint;
Assert.Equal("listener1", endpoint.Id);
AssertQueues(endpoint, "queue1", "queue2");
Assert.Empty(endpoint.Queues);
Assert.True(endpoint.Exclusive);
Assert.Equal(34, endpoint.Priority);
var admin = context.GetRabbitAdmin();
Assert.Same(endpoint.Admin, admin);
var container = new DirectMessageListenerContainer(context);
endpoint.SetupListenerContainer(container);
var listener = container.MessageListener as MessagingMessageListenerAdapter;
var accessor = new RabbitHeaderAccessor
{
ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN
};
var message = Message.Create(Encoding.UTF8.GetBytes("Hello"), accessor.MessageHeaders);
var mockChannel = new Mock <R.IModel>();
listener.OnMessage(message, mockChannel.Object);
}
public async Task SimpleMessageListener()
{
var queues = new List <IQueue>()
{
QueueBuilder.Durable("testQueue").Build(),
QueueBuilder.Durable("secondQueue").Build()
};
var provider = await Config.CreateAndStartServices(null, queues, typeof(SimpleMessageListenerTestBean));
var context = provider.GetService <IApplicationContext>();
var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory;
Assert.Single(factory.GetListenerContainers());
var container = factory.GetListenerContainers()[0] as MessageListenerTestContainer;
var endpoint = container.Endpoint;
Assert.IsType <MethodRabbitListenerEndpoint>(endpoint);
var methodEndpoint = endpoint as MethodRabbitListenerEndpoint;
Assert.NotNull(methodEndpoint.Instance);
Assert.NotNull(methodEndpoint.Method);
var listenerContainer = new DirectMessageListenerContainer(context);
methodEndpoint.SetupListenerContainer(listenerContainer);
Assert.NotNull(listenerContainer.MessageListener);
Assert.True(container.IsStarted);
provider.Dispose();
Assert.True(container.IsStopped);
}
public void TestAdapterConversionError()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <RC.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object);
var container = new DirectMessageListenerContainer();
container.ConnectionFactory = connectionFactory.Object;
var adapter = new RabbitInboundChannelAdapter(context, container);
var outputChannel = new QueueChannel(context);
adapter.OutputChannel = outputChannel;
var errorChannel = new QueueChannel(context);
adapter.ErrorChannel = errorChannel;
adapter.MessageConverter = new ThrowingMessageConverter();
var accessor = new RabbitHeaderAccessor();
accessor.DeliveryTag = 123ul;
var headers = accessor.MessageHeaders;
var message = Message.Create(string.Empty, headers);
var listener = container.MessageListener as IChannelAwareMessageListener;
listener.OnMessage(message, null);
Assert.Null(outputChannel.Receive(0));
var received = errorChannel.Receive(0);
Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE));
Assert.IsType <ListenerExecutionFailedException>(received.Payload);
container.AcknowledgeMode = Messaging.RabbitMQ.Core.AcknowledgeMode.MANUAL;
var channel2 = new Mock <RC.IModel>();
listener.OnMessage(message, channel2.Object);
Assert.Null(outputChannel.Receive(0));
received = errorChannel.Receive(0);
Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE));
Assert.IsType <ManualAckListenerExecutionFailedException>(received.Payload);
var ex = (ManualAckListenerExecutionFailedException)received.Payload;
Assert.Same(channel2.Object, ex.Channel);
Assert.Equal(123ul, ex.DeliveryTag);
}
public void TestDebatchByContainerPerformance()
{
var provider = new ServiceCollection().BuildServiceProvider();
var config = new ConfigurationBuilder().Build();
var received = new List <IMessage>();
var count = 100000;
var latch = new CountdownEvent(count);
var context = new GenericApplicationContext(provider, config);
context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
var container = new DirectMessageListenerContainer(context, connectionFactory);
container.SetQueueNames(ROUTE);
var lastInBatch = new List <bool>();
var batchSize = new AtomicInteger();
container.MessageListener = new TestDebatchListener(received, null, null, latch);
container.PrefetchCount = 1000;
container.BatchingStrategy = new SimpleBatchingStrategy(1000, int.MaxValue, 30000);
container.Initialize();
container.Start();
try
{
var batchingStrategy = new SimpleBatchingStrategy(1000, int.MaxValue, 30000);
var template = new BatchingRabbitTemplate(batchingStrategy)
{
ConnectionFactory = connectionFactory
};
var accessor = RabbitHeaderAccessor.GetMutableAccessor(new MessageHeaders());
accessor.DeliveryMode = MessageDeliveryMode.NON_PERSISTENT;
var message = Message.Create(new byte[256], accessor.MessageHeaders);
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < count; i++)
{
template.Send(string.Empty, ROUTE, message);
}
Assert.True(latch.Wait(TimeSpan.FromSeconds(60)));
watch.Stop();
testOutputHelper.WriteLine(watch.ElapsedMilliseconds.ToString());
Assert.Equal(count, received.Count);
}
finally
{
container.Stop();
}
}
public void TestInt2809JavaTypePropertiesToRabbit()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <RC.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object);
var container = new DirectMessageListenerContainer();
container.ConnectionFactory = connectionFactory.Object;
container.AcknowledgeMode = Messaging.RabbitMQ.Core.AcknowledgeMode.MANUAL;
var adapter = new RabbitInboundChannelAdapter(context, container);
adapter.MessageConverter = new JsonMessageConverter();
var qchannel = new QueueChannel(context);
adapter.OutputChannel = qchannel;
adapter.BindSourceMessage = true;
object payload = new Foo("bar1");
var objectToJsonTransformer = new ObjectToJsonTransformer(context, typeof(byte[]));
var jsonMessage = objectToJsonTransformer.Transform(Message.Create(payload));
var accessor = RabbitHeaderAccessor.GetMutableAccessor(jsonMessage);
accessor.DeliveryTag = 123ul;
var listener = container.MessageListener as IChannelAwareMessageListener;
var rabbitChannel = new Mock <RC.IModel>();
listener.OnMessage(jsonMessage, rabbitChannel.Object);
var result = qchannel.Receive(1000);
Assert.Equal(payload, result.Payload);
Assert.Same(rabbitChannel.Object, result.Headers.Get <RC.IModel>(RabbitMessageHeaders.CHANNEL));
Assert.Equal(123ul, result.Headers.DeliveryTag());
var sourceData = result.Headers.Get <IMessage>(IntegrationMessageHeaderAccessor.SOURCE_DATA);
Assert.Same(jsonMessage, sourceData);
}
public void TestDebatchByContainer()
{
var provider = new ServiceCollection().BuildServiceProvider();
var config = new ConfigurationBuilder().Build();
var received = new List <IMessage>();
var latch = new CountdownEvent(2);
var context = new GenericApplicationContext(provider, config);
context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
var container = new DirectMessageListenerContainer(context, connectionFactory);
container.SetQueueNames(ROUTE);
var lastInBatch = new List <bool>();
var batchSize = new AtomicInteger();
container.MessageListener = new TestDebatchListener(received, lastInBatch, batchSize, latch);
container.Initialize();
container.Start();
try
{
var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000);
var template = new BatchingRabbitTemplate(batchingStrategy)
{
ConnectionFactory = connectionFactory
};
var message = Message.Create(Encoding.UTF8.GetBytes("foo"));
template.Send(string.Empty, ROUTE, message);
message = Message.Create(Encoding.UTF8.GetBytes("bar"));
template.Send(string.Empty, ROUTE, message);
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
Assert.Equal(2, received.Count);
Assert.Equal("foo", Encoding.UTF8.GetString((byte[])received[0].Payload));
Assert.Equal(3, received[0].Headers.ContentLength());
Assert.False(lastInBatch[0]);
Assert.Equal("bar", Encoding.UTF8.GetString((byte[])received[1].Payload));
Assert.Equal(3, received[1].Headers.ContentLength());
Assert.True(lastInBatch[1]);
Assert.Equal(2, batchSize.Value);
}
finally
{
container.Stop();
}
}
public async Task SimpleMessageListenerWithMixedAnnotations()
{
var configBuilder = new ConfigurationBuilder();
configBuilder.AddInMemoryCollection(new Dictionary <string, string>()
{
{ "rabbit:myQueue", "secondQueue" }
});
var config = configBuilder.Build();
var queues = new List <IQueue>()
{
QueueBuilder.Durable("testQueue").Build(),
QueueBuilder.Durable("secondQueue").Build()
};
var provider = await Config.CreateAndStartServices(config, queues, typeof(SimpleMessageListenerWithMixedAnnotationsTestBean));
var context = provider.GetService <IApplicationContext>();
var factory = context.GetService <IRabbitListenerContainerFactory>() as RabbitListenerContainerTestFactory;
Assert.Single(factory.GetListenerContainers());
var container = factory.GetListenerContainers()[0];
var endpoint = container.Endpoint;
Assert.IsType <MethodRabbitListenerEndpoint>(endpoint);
var methodEndpoint = endpoint as MethodRabbitListenerEndpoint;
Assert.NotNull(methodEndpoint.Instance);
Assert.NotNull(methodEndpoint.Method);
Assert.Equal(2, methodEndpoint.QueueNames.Count);
Assert.Contains("testQueue", methodEndpoint.QueueNames);
Assert.Contains("secondQueue", methodEndpoint.QueueNames);
var listenerContainer = new DirectMessageListenerContainer(context);
methodEndpoint.SetupListenerContainer(listenerContainer);
Assert.NotNull(listenerContainer.MessageListener);
Assert.True(container.IsStarted);
provider.Dispose();
Assert.True(container.IsStopped);
}
public void TestDebatchByContainerBadMessageRejected()
{
var provider = new ServiceCollection().BuildServiceProvider();
var config = new ConfigurationBuilder().Build();
var context = new GenericApplicationContext(provider, config);
context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
var container = new DirectMessageListenerContainer(context, connectionFactory);
container.SetQueueNames(ROUTE);
var listener = new EmptyListener();
container.MessageListener = listener;
var errorHandler = new TestConditionalRejectingErrorHandler();
container.ErrorHandler = errorHandler;
container.Initialize();
container.Start();
try
{
var template = new RabbitTemplate
{
ConnectionFactory = connectionFactory
};
var headers = new MessageHeaders(new Dictionary <string, object>()
{
{ RabbitMessageHeaders.SPRING_BATCH_FORMAT, RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4 }
});
var message = Message.Create(Encoding.UTF8.GetBytes("\u0000\u0000\u0000\u0004foo"), headers);
template.Send(string.Empty, ROUTE, message);
Thread.Sleep(1000);
Assert.Equal(0, listener.Count);
Assert.True(errorHandler.HandleErrorCalled);
}
finally
{
container.Stop();
}
}
public void TestInt2809JavaTypePropertiesFromAmqp()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <RC.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object);
var container = new DirectMessageListenerContainer();
container.ConnectionFactory = connectionFactory.Object;
var adapter = new RabbitInboundChannelAdapter(context, container);
var qchannel = new QueueChannel(context);
adapter.OutputChannel = qchannel;
object payload = new Foo("bar1");
var headers = new MessageHeaders();
var amqpMessage = new JsonMessageConverter().ToMessage(payload, headers);
var listener = container.MessageListener as IChannelAwareMessageListener;
listener.OnMessage(amqpMessage, null);
var receive = qchannel.Receive(1000);
var result = new JsonToObjectTransformer(context).Transform(receive) as IMessage;
Assert.NotNull(result);
Assert.Equal(payload, result.Payload);
var sourceData = result.Headers.Get <IMessage>(IntegrationMessageHeaderAccessor.SOURCE_DATA);
Assert.Null(sourceData);
}
public void TestRetryWithinOnMessageAdapter()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
var container = new DirectMessageListenerContainer();
var adapter = new RabbitInboundChannelAdapter(context, container);
adapter.OutputChannel = new DirectChannel(context);
adapter.RetryTemplate = new PollyRetryTemplate(3, 1, 1, 1);
var errors = new QueueChannel(context);
var recoveryCallback = new ErrorMessageSendingRecoverer(context, errors);
recoveryCallback.ErrorMessageStrategy = new RabbitMessageHeaderErrorMessageStrategy();
adapter.RecoveryCallback = recoveryCallback;
var listener = container.MessageListener as IChannelAwareMessageListener;
var message = MessageBuilder.WithPayload <byte[]>(Encoding.UTF8.GetBytes("foo")).CopyHeaders(new MessageHeaders()).Build();
listener.OnMessage(message, null);
var errorMessage = errors.Receive(0);
Assert.NotNull(errorMessage);
var payload = errorMessage.Payload as MessagingException;
Assert.NotNull(payload);
Assert.Contains("Dispatcher has no", payload.Message);
var deliveryAttempts = payload.FailedMessage.Headers.Get <AtomicInteger>(IntegrationMessageHeaderAccessor.DELIVERY_ATTEMPT);
Assert.NotNull(deliveryAttempts);
Assert.Equal(3, deliveryAttempts.Value);
var amqpMessage = errorMessage.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE);
Assert.NotNull(amqpMessage);
Assert.Null(errors.Receive(0));
}
public async Task TestAbstractRoutingConnectionFactoryWithListenerContainer()
{
var connectionFactory1 = new Mock <IConnectionFactory>();
var connectionFactory2 = new Mock <IConnectionFactory>();
var defaultConnectionFactory = new Mock <IConnectionFactory>();
var connection1 = new Mock <IConnection>();
var connection2 = new Mock <IConnection>();
var defautConnection = new Mock <IConnection>();
var channel1 = new Mock <RC.IModel>();
var channel2 = new Mock <RC.IModel>();
var defaultChannel = new Mock <RC.IModel>();
connectionFactory1.SetupSequence((f) => f.CreateConnection())
.Returns(connection1.Object);
connectionFactory2.SetupSequence((f) => f.CreateConnection())
.Returns(connection1.Object)
.Returns(connection2.Object);
defaultConnectionFactory.SetupSequence((f) => f.CreateConnection())
.Returns(defautConnection.Object);
connection1.Setup((c) => c.IsOpen).Returns(true);
connection1.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel1.Object);
connection2.Setup((c) => c.IsOpen).Returns(true);
connection2.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel2.Object);
defautConnection.Setup((c) => c.IsOpen).Returns(true);
defautConnection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(defaultChannel.Object);
channel1.Setup(c => c.IsOpen).Returns(true);
channel2.Setup(c => c.IsOpen).Returns(true);
defaultChannel.Setup(c => c.IsOpen).Returns(true);
var factories = new Dictionary <object, IConnectionFactory>
{
{ "[baz]", connectionFactory1.Object },
{ "[foo,bar]", connectionFactory2.Object }
};
var connectionFactory = new SimpleRoutingConnectionFactory
{
LenientFallback = true,
DefaultTargetConnectionFactory = defaultConnectionFactory.Object
};
connectionFactory.SetTargetConnectionFactories(factories);
var container = new DirectMessageListenerContainer(null, connectionFactory);
container.SetQueueNames("foo", "bar");
container.Initialize();
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
connectionFactory1.Verify((f) => f.CreateConnection(), Times.Never);
connectionFactory2.Verify((f) => f.CreateConnection(), Times.Exactly(2));
defaultConnectionFactory.Verify((f) => f.CreateConnection(), Times.Once); // Checks connection
connectionFactory1.Invocations.Clear();
connectionFactory2.Invocations.Clear();
defaultConnectionFactory.Invocations.Clear();
container.SetQueueNames("baz");
connectionFactory1.Verify((f) => f.CreateConnection());
connectionFactory2.Verify((f) => f.CreateConnection(), Times.Never);
defaultConnectionFactory.Verify((f) => f.CreateConnection(), Times.Never);
connectionFactory1.Invocations.Clear();
connectionFactory2.Invocations.Clear();
defaultConnectionFactory.Invocations.Clear();
container.SetQueueNames("qux");
connectionFactory1.Verify((f) => f.CreateConnection(), Times.Never);
connectionFactory2.Verify((f) => f.CreateConnection(), Times.Never);
defaultConnectionFactory.Verify((f) => f.CreateConnection());
await container.Stop();
}
