public void TestImmediateReceive()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var messageNull = false;
var channel = new QueueChannel(provider);
var latch1 = new CountdownEvent(1);
var latch2 = new CountdownEvent(1);
void RecvAction1()
{
var message = channel.Receive(0);
messageNull = message == null;
latch1.Signal();
}
Task.Run(RecvAction1);
Assert.True(latch1.Wait(10000));
channel.Send(new GenericMessage("testing"));
void RecvAction2()
{
var message = channel.Receive(0);
if (message != null)
{
latch2.Signal();
}
}
Task.Run(RecvAction2);
Assert.True(latch2.Wait(10000));
}
public void DynamicReplyChannel()
{
QueueChannel replyChannel1 = new QueueChannel();
QueueChannel replyChannel2 = new QueueChannel();
replyChannel2.ObjectName = "replyChannel2";
Object handler = new TestObject2();
ServiceActivatingHandler endpoint = new ServiceActivatingHandler(handler, "Handle");
TestChannelResolver channelResolver = new TestChannelResolver();
channelResolver.AddChannel(replyChannel2);
endpoint.ChannelResolver = channelResolver;
IMessage testMessage1 = MessageBuilder.WithPayload("bar").SetReplyChannel(replyChannel1).Build();
endpoint.HandleMessage(testMessage1);
IMessage reply1 = replyChannel1.Receive(TimeSpan.FromMilliseconds(50));
Assert.IsNotNull(reply1);
Assert.That(reply1.Payload, Is.EqualTo("foobar"));
IMessage reply2 = replyChannel2.Receive(TimeSpan.Zero);
Assert.IsNull(reply2);
IMessage testMessage2 =
MessageBuilder.FromMessage(testMessage1).SetReplyChannelName("replyChannel2").Build();
endpoint.HandleMessage(testMessage2);
reply1 = replyChannel1.Receive(TimeSpan.Zero);
Assert.IsNull(reply1);
reply2 = replyChannel2.Receive(TimeSpan.Zero);
Assert.IsNotNull(reply2);
Assert.That(reply2.Payload, Is.EqualTo("foobar"));
}
public void testMultipleChannelsWithSelector()
{
QueueChannel channel1 = new QueueChannel();
QueueChannel channel2 = new QueueChannel();
channel1.Send(new StringMessage("test1"));
channel1.Send(new StringMessage("test2"));
channel1.Send(new StringMessage("test3"));
channel2.Send(new StringMessage("test1"));
channel2.Send(new StringMessage("test2"));
channel2.Send(new StringMessage("test3"));
ChannelPurger purger = new ChannelPurger(delegate(IMessage msg) { return(msg.Payload.Equals("test2")); },
channel1, channel2);
IList <IMessage> purgedMessages = purger.Purge();
Assert.That(purgedMessages.Count, Is.EqualTo(4));
IMessage message1 = channel1.Receive(TimeSpan.Zero);
Assert.IsNotNull(message1);
Assert.That(message1.Payload, Is.EqualTo("test2"));
Assert.IsNull(channel1.Receive(TimeSpan.Zero));
IMessage message2 = channel2.Receive(TimeSpan.Zero);
Assert.IsNotNull(message2);
Assert.That(message2.Payload, Is.EqualTo("test2"));
Assert.IsNull(channel2.Receive(TimeSpan.Zero));
}
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 SetWithRequestReplyHandler()
{
handler.ReturnValue = new HashSet <string>(new string[] { "foo", "bar" });
var channel = new QueueChannel(provider);
var message = MessageBuilder.WithPayload("test").SetReplyChannel(channel).Build();
handler.HandleMessage(message);
var reply1 = channel.Receive(0);
var reply2 = channel.Receive(0);
Assert.NotNull(reply1);
Assert.Null(reply2);
Assert.IsType <HashSet <string> >(reply1.Payload);
Assert.Equal(2, ((HashSet <string>)reply1.Payload).Count);
}
public void testPurgeNoneWithSelector()
{
QueueChannel channel = new QueueChannel();
channel.Send(new StringMessage("test1"));
channel.Send(new StringMessage("test2"));
channel.Send(new StringMessage("test3"));
ChannelPurger purger = new ChannelPurger(delegate { return(true); }, channel);
IList <IMessage> purgedMessages = purger.Purge();
Assert.That(purgedMessages.Count, Is.EqualTo(0));
Assert.IsNotNull(channel.Receive(TimeSpan.Zero));
Assert.IsNotNull(channel.Receive(TimeSpan.Zero));
Assert.IsNotNull(channel.Receive(TimeSpan.Zero));
}
public void ArrayWithRequestReplyHandler()
{
handler.ReturnValue = new string[] { "foo", "bar" };
var channel = new QueueChannel(provider.GetService <IApplicationContext>());
var message = IntegrationMessageBuilder.WithPayload("test").SetReplyChannel(channel).Build();
handler.HandleMessage(message);
var reply1 = channel.Receive(0);
var reply2 = channel.Receive(0);
Assert.NotNull(reply1);
Assert.Null(reply2);
Assert.IsType <string[]>(reply1.Payload);
Assert.Equal(2, ((string[])reply1.Payload).Length);
}
public void TestCorrelationIdWithSplitter()
{
IMessage message = new StringMessage("test1,test2");
QueueChannel testChannel = new QueueChannel();
MethodInvokingSplitter splitter = new MethodInvokingSplitter(new TestBean(),
typeof(TestBean).GetMethod("Split"));
splitter.OutputChannel = testChannel;
splitter.HandleMessage(message);
IMessage reply1 = testChannel.Receive(TimeSpan.FromMilliseconds(100));
IMessage reply2 = testChannel.Receive(TimeSpan.FromMilliseconds(100));
Assert.That(reply1.Headers.CorrelationId, Is.EqualTo(message.Headers.Id));
Assert.That(reply2.Headers.CorrelationId, Is.EqualTo(message.Headers.Id));
}
public void SimpleTargetWireTap()
{
QueueChannel mainChannel = new QueueChannel();
QueueChannel secondaryChannel = new QueueChannel();
mainChannel.AddInterceptor(new WireTap(secondaryChannel));
Assert.IsNull(secondaryChannel.Receive(TimeSpan.Zero));
mainChannel.Send(new StringMessage("testing"));
IMessage original = mainChannel.Receive(TimeSpan.Zero);
Assert.IsNotNull(original);
IMessage intercepted = secondaryChannel.Receive(TimeSpan.Zero);
Assert.IsNotNull(intercepted);
Assert.That(original, Is.EqualTo(intercepted));
}
public void ConversionServiceUsedByDefault()
{
var converter = new BoolToIntConverter();
var convService = new GenericConversionService();
convService.AddConverter(converter);
var services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
services.AddSingleton <IConfiguration>(config);
services.AddSingleton <IApplicationContext, GenericApplicationContext>();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
services.AddSingleton <IConversionService>(convService);
services.AddSingleton <IMessageBuilderFactory, DefaultMessageBuilderFactory>();
services.AddSingleton <DefaultDatatypeChannelMessageConverter>();
var provider = services.BuildServiceProvider();
var channel = new QueueChannel(provider.GetService <IApplicationContext>(), "testChannel");
channel.DataTypes = new List <Type>()
{
typeof(int), typeof(DateTime)
};
Assert.True(channel.Send(Message.Create(true)));
Assert.Equal(1, channel.Receive().Payload);
}
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);
}
public void TestPostReceiveInterceptor()
{
AtomicInteger invokedCount = new AtomicInteger();
AtomicInteger messageCount = new AtomicInteger();
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(new TestPostReceiveInterceptorInterceptor(invokedCount, messageCount, channel));
channel.Receive(TimeSpan.Zero);
Assert.That(invokedCount.Value, Is.EqualTo(1));
Assert.That(messageCount.Value, Is.EqualTo(0));
channel.Send(new StringMessage("test"));
IMessage result = channel.Receive(TimeSpan.Zero);
Assert.IsNotNull(result);
Assert.That(invokedCount.Value, Is.EqualTo(2));
Assert.That(messageCount.Value, Is.EqualTo(1));
}
public void testPurgeSubsetWithSelector()
{
QueueChannel channel = new QueueChannel();
channel.Send(new StringMessage("test1"));
channel.Send(new StringMessage("test2"));
channel.Send(new StringMessage("test3"));
ChannelPurger purger = new ChannelPurger(delegate(IMessage msg) { return(msg.Payload.Equals("test2")); },
channel);
IList <IMessage> purgedMessages = purger.Purge();
Assert.That(purgedMessages.Count, Is.EqualTo(2));
IMessage message = channel.Receive(TimeSpan.Zero);
Assert.IsNotNull(message);
Assert.That(message.Payload, Is.EqualTo("test2"));
Assert.IsNull(channel.Receive(TimeSpan.Zero));
}
public void SendAndReceiveWithExplicitChannelTakesPrecedenceOverDefault()
{
QueueChannel defaultChannel = new QueueChannel();
MessageChannelTemplate template = new MessageChannelTemplate(defaultChannel);
IMessage message = new StringMessage("test");
IMessage reply = template.SendAndReceive(message, requestChannel);
Assert.That(reply.Payload, Is.EqualTo("TEST"));
Assert.IsNull(defaultChannel.Receive(TimeSpan.Zero));
}
public void CreateAndUseQueueChannel()
{
QueueChannel channel = new QueueChannel(1);
Thread thread = new Thread(new ThreadStart(delegate() { channel.Send(10); }));
thread.Start();
object result = channel.Receive();
}
public void CorrelationIdNotSetIfMessageIsReturnedUnaltered()
{
QueueChannel replyChannel = new QueueChannel(1);
ServiceActivatingHandler endpoint = new ServiceActivatingHandler(new TestObject3(), "Handle");
IMessage message = MessageBuilder.WithPayload("test").SetReplyChannel(replyChannel).Build();
endpoint.HandleMessage(message);
IMessage reply = replyChannel.Receive(TimeSpan.FromMilliseconds(500));
Assert.IsNull(reply.Headers.CorrelationId);
}
public void SendWithDefaultChannelProvidedByConstructor()
{
QueueChannel channel = new QueueChannel();
MessageChannelTemplate template = new MessageChannelTemplate(channel);
template.Send(new StringMessage("test"));
IMessage reply = channel.Receive();
Assert.IsNotNull(reply);
Assert.That(reply.Payload, Is.EqualTo("test"));
}
public void NoReplyMessage()
{
QueueChannel channel = new QueueChannel(1);
ServiceActivatingHandler endpoint = new ServiceActivatingHandler(new TestNullReplyObject(), "Handle");
endpoint.OutputChannel = channel;
IMessage message = MessageBuilder.WithPayload("foo").Build();
endpoint.HandleMessage(message);
Assert.IsNull(channel.Receive(TimeSpan.Zero));
}
public void Send()
{
MessageChannelTemplate template = new MessageChannelTemplate();
QueueChannel channel = new QueueChannel();
template.Send(new StringMessage("test"), channel);
IMessage reply = channel.Receive();
Assert.IsNotNull(reply);
Assert.That(reply.Payload, Is.EqualTo("test"));
}
public void ReturnAddressHeader()
{
QueueChannel channel = new QueueChannel(1);
ServiceActivatingHandler endpoint = CreateEndpoint();
IMessage message = MessageBuilder.WithPayload("foo").SetReplyChannel(channel).Build();
endpoint.HandleMessage(message);
IMessage reply = channel.Receive(TimeSpan.Zero);
Assert.IsNotNull(reply);
Assert.That(reply.Payload, Is.EqualTo("FOO"));
}
public void MissingOutputChannelAllowedForReplyChannelMessages()
{
var replyChannel = new QueueChannel(provider.GetService <IApplicationContext>());
var request = Integration.Support.IntegrationMessageBuilder.WithPayload("tst").SetReplyChannel(replyChannel).Build();
handler.HandleMessage(request);
var reply = replyChannel.Receive();
Assert.NotNull(reply);
Assert.Equal(request.Payload, reply.Payload);
Assert.Equal(request.Headers, reply.Headers);
}
public void TestPreSendInterceptorReturnsMessage()
{
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(new PreSendReturnsMessageInterceptor());
channel.Send(new StringMessage("test"));
IMessage result = channel.Receive(TimeSpan.Zero);
Assert.IsNotNull(result);
Assert.That("test", Is.EqualTo(result.Payload));
Assert.That(result.Headers.Get(typeof(PreSendReturnsMessageInterceptor).Name), Is.EqualTo(1));
}
public void CorrelationIdSetByHandlerTakesPrecedence()
{
QueueChannel replyChannel = new QueueChannel(1);
ServiceActivatingHandler endpoint = new ServiceActivatingHandler(new TestObject4(), "Handle");
IMessage message = MessageBuilder.WithPayload("test").SetReplyChannel(replyChannel).Build();
endpoint.HandleMessage(message);
IMessage reply = replyChannel.Receive(TimeSpan.FromMilliseconds(500));
Object correlationId = reply.Headers.CorrelationId;
Assert.IsFalse(message.Headers.Id.Equals(correlationId));
Assert.That(correlationId, Is.EqualTo("ABC-123"));
}
public void SendWithExplicitChannelTakesPrecedenceOverDefault()
{
QueueChannel explicitChannel = new QueueChannel();
QueueChannel defaultChannel = new QueueChannel();
MessageChannelTemplate template = new MessageChannelTemplate(defaultChannel);
template.Send(new StringMessage("test"), explicitChannel);
IMessage reply = explicitChannel.Receive();
Assert.IsNotNull(reply);
Assert.That(reply.Payload, Is.EqualTo("test"));
Assert.IsNull(defaultChannel.Receive(TimeSpan.Zero));
}
public void TestPreReceiveInterceptorReturnsFalse()
{
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(new PreReceiveReturnsFalseInterceptor());
IMessage message = new StringMessage("test");
channel.Send(message);
IMessage result = channel.Receive(TimeSpan.Zero);
Assert.That(PreReceiveReturnsFalseInterceptor.counter.Value, Is.EqualTo(1));
Assert.IsNull(result);
}
public void testPurgeAllWithoutSelector()
{
QueueChannel channel = new QueueChannel();
channel.Send(new StringMessage("test1"));
channel.Send(new StringMessage("test2"));
channel.Send(new StringMessage("test3"));
ChannelPurger purger = new ChannelPurger(channel);
IList <IMessage> purgedMessages = purger.Purge();
Assert.That(purgedMessages.Count, Is.EqualTo(3));
Assert.IsNull(channel.Receive(TimeSpan.Zero));
}
public void TestImmediateReceive()
{
AtomicBoolean messageReceived = new AtomicBoolean(false);
QueueChannel channel = new QueueChannel();
CountDownLatch latch1 = new CountDownLatch(1);
CountDownLatch latch2 = new CountDownLatch(1);
IExecutor singleThreadExecutor = Executors.NewSingleThreadExecutor();
singleThreadExecutor.Execute(
delegate
{
IMessage message = channel.Receive(TimeSpan.Zero);
if (message != null)
{
messageReceived.Value = true;
}
latch1.CountDown();
});
latch1.Await();
singleThreadExecutor.Execute(
delegate { channel.Send(new Message <string>("testing")); });
Assert.IsFalse(messageReceived.Value);
singleThreadExecutor.Execute(
delegate
{
IMessage message = channel.Receive(TimeSpan.Zero);
if (message != null)
{
messageReceived.Value = true;
}
latch2.CountDown();
});
latch2.Await();
Assert.IsNotNull(messageReceived.Value);
}
public void SimpleBridge()
{
var outputChannel = new QueueChannel(provider.GetService <IApplicationContext>());
handler.OutputChannel = outputChannel;
var request = Message.Create("test");
handler.HandleMessage(request);
var reply = outputChannel.Receive(0);
Assert.NotNull(reply);
Assert.Equal(request.Payload, reply.Payload);
Assert.Equal(request.Headers, reply.Headers);
}
public void WireTapWithRejectingSelector()
{
QueueChannel mainChannel = new QueueChannel();
QueueChannel secondaryChannel = new QueueChannel();
mainChannel.AddInterceptor(new WireTap(secondaryChannel, new TestSelector(false)));
mainChannel.Send(new StringMessage("testing"));
IMessage original = mainChannel.Receive(TimeSpan.Zero);
Assert.IsNotNull(original);
IMessage intercepted = secondaryChannel.Receive(TimeSpan.Zero);
Assert.IsNull(intercepted);
}
public void TestPreSendInterceptorReturnsNull()
{
QueueChannel channel = new QueueChannel();
PreSendReturnsNullInterceptor interceptor = new PreSendReturnsNullInterceptor();
channel.AddInterceptor(interceptor);
IMessage message = new StringMessage("test");
channel.Send(message);
Assert.That(interceptor.Count, Is.EqualTo(1));
IMessage result = channel.Receive(TimeSpan.Zero);
Assert.IsNull(result);
}