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 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 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 testMultipleChannelsWithNoSelector()
{
QueueChannel channel1 = new QueueChannel();
QueueChannel channel2 = new QueueChannel();
channel1.Send(new StringMessage("test1"));
channel1.Send(new StringMessage("test2"));
channel2.Send(new StringMessage("test1"));
channel2.Send(new StringMessage("test2"));
ChannelPurger purger = new ChannelPurger(channel1, channel2);
IList <IMessage> purgedMessages = purger.Purge();
Assert.That(purgedMessages.Count, Is.EqualTo(4));
Assert.IsNull(channel1.Receive(TimeSpan.Zero));
Assert.IsNull(channel2.Receive(TimeSpan.Zero));
}
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 TestImmediateSend()
{
QueueChannel channel = new QueueChannel(3);
bool result1 = channel.Send(new Message <string>("test-1"));
Assert.IsTrue(result1);
bool result2 = channel.Send(new Message <string>("test-2"), new TimeSpan(100));
Assert.IsTrue(result2);
bool result3 = channel.Send(new Message <string>("test-3"), TimeSpan.Zero);
Assert.IsTrue(result3);
bool result4 = channel.Send(new Message <string>("test-4"), TimeSpan.Zero);
Assert.IsFalse(result4);
}
public void TestClear()
{
QueueChannel channel = new QueueChannel(2);
StringMessage message1 = new StringMessage("test1");
StringMessage message2 = new StringMessage("test2");
StringMessage message3 = new StringMessage("test3");
Assert.IsTrue(channel.Send(message1));
Assert.IsTrue(channel.Send(message2));
Assert.IsFalse(channel.Send(message3, TimeSpan.Zero));
IList <IMessage> clearedMessages = channel.Clear();
Assert.IsNotNull(clearedMessages);
Assert.That(clearedMessages.Count, Is.EqualTo(2));
Assert.IsTrue(channel.Send(message3));
}
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 Subscription()
{
TestUtils.TestApplicationContext context = TestUtils.CreateTestApplicationContext();
SynchronousQueue <string> queue = new SynchronousQueue <string>();
TestBean testBean = new TestBean(queue);
QueueChannel channel = new QueueChannel();
context.RegisterChannel("channel", channel);
Message <string> message = new Message <string>("testing");
channel.Send(message);
string polledString;
Assert.IsFalse(queue.Poll(out polledString));
MethodInvokingMessageHandler handler = new MethodInvokingMessageHandler(testBean, "foo");
PollingConsumer endpoint = new PollingConsumer(channel, handler);
endpoint.Trigger = new IntervalTrigger(TimeSpan.FromMilliseconds(10));
context.RegisterEndpoint("testEndpoint", endpoint);
context.Refresh();
string result;
Assert.IsTrue(queue.Poll(TimeSpan.FromMilliseconds(1000), out result));
Assert.IsNotNull(result);
Assert.That(result, Is.EqualTo("testing"));
context.Stop();
}
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 TestPostSendInterceptorWithUnsentMessage()
{
AtomicInteger invokedCounter = new AtomicInteger(0);
AtomicInteger sentCounter = new AtomicInteger(0);
QueueChannel singleItemChannel = new QueueChannel(1);
singleItemChannel.AddInterceptor(new TestPostSendInterceptorWithUnsentMessageInterceptor(invokedCounter,
sentCounter,
singleItemChannel));
Assert.That(invokedCounter.Value, Is.EqualTo(0));
Assert.That(sentCounter.Value, Is.EqualTo(0));
singleItemChannel.Send(new StringMessage("test1"));
Assert.That(invokedCounter.Value, Is.EqualTo(1));
Assert.That(sentCounter.Value, Is.EqualTo(1));
singleItemChannel.Send(new StringMessage("test2"), TimeSpan.Zero);
Assert.That(invokedCounter.Value, Is.EqualTo(2));
Assert.That(sentCounter.Value, Is.EqualTo(1));
}
public void testSingleSelectorRejects()
{
AtomicInteger counter = new AtomicInteger();
IMessageSelector selector = new TestMessageSelector(false, counter);
MessageSelectingInterceptor interceptor = new MessageSelectingInterceptor(selector);
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(interceptor);
channel.Send(new StringMessage("test1"));
}
public void testSingleSelectorAccepts()
{
AtomicInteger counter = new AtomicInteger();
IMessageSelector selector = new TestMessageSelector(true, counter);
MessageSelectingInterceptor interceptor = new MessageSelectingInterceptor(selector);
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(interceptor);
Assert.That(channel.Send(new StringMessage("test1")), Is.True);
}
public void TestPostSendInterceptorWithSentMessage()
{
QueueChannel channel = new QueueChannel();
AtomicBoolean invoked = new AtomicBoolean(false);
channel.AddInterceptor(new TestPostSendInterceptorWithSentMessageInterceptor(invoked, channel));
channel.Send(new StringMessage("test"));
Assert.IsTrue(invoked.Value);
}
public void ReceiveWithDefaultChannelProvidedByConstructor()
{
QueueChannel channel = new QueueChannel();
channel.Send(new StringMessage("test"));
MessageChannelTemplate template = new MessageChannelTemplate(channel);
IMessage reply = template.Receive();
Assert.That(reply.Payload, Is.EqualTo("test"));
}
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 TestPurge()
{
QueueChannel channel = new QueueChannel(2);
TimeSpan minute = new TimeSpan(0, 0, 1, 0);
DateTime now = DateTime.Now;
DateTime past = now.Subtract(minute);
DateTime future = now.Add(minute);
IMessage expiredMessage = MessageBuilder.WithPayload("test1").SetExpirationDate(past).Build();
IMessage unexpiredMessage = MessageBuilder.WithPayload("test2").SetExpirationDate(future).Build();
Assert.IsTrue(channel.Send(expiredMessage, TimeSpan.Zero));
Assert.IsTrue(channel.Send(unexpiredMessage, TimeSpan.Zero));
Assert.IsFalse(channel.Send(new StringMessage("atCapacity"), TimeSpan.Zero));
IList <IMessage> purgedMessages = channel.Purge(new UnexpiredMessageSelector());
Assert.IsNotNull(purgedMessages);
Assert.That(purgedMessages.Count, Is.EqualTo(1));
Assert.IsTrue(channel.Send(new StringMessage("roomAvailable"), TimeSpan.Zero));
}
public void TestPostSendInterceptorWithUnsentMessage()
{
var singleItemChannel = new QueueChannel(provider, 1);
var interceptor = new TestPostSendInterceptorWithUnsentMessageInterceptor();
singleItemChannel.AddInterceptor(interceptor);
Assert.Equal(0, interceptor.InvokedCounter);
Assert.Equal(0, interceptor.SentCounter);
singleItemChannel.Send(new GenericMessage("test1"));
Assert.Equal(1, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
singleItemChannel.Send(new GenericMessage("test2"), 0);
Assert.Equal(2, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
Assert.NotNull(singleItemChannel.RemoveInterceptor(0));
singleItemChannel.Send(new GenericMessage("test2"), 0);
Assert.Equal(2, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
}
public void TestPostSendInterceptorWithUnsentMessage()
{
var singleItemChannel = new QueueChannel(provider.GetService <IApplicationContext>(), 1);
var interceptor = new TestPostSendInterceptorWithUnsentMessageInterceptor();
singleItemChannel.AddInterceptor(interceptor);
Assert.Equal(0, interceptor.InvokedCounter);
Assert.Equal(0, interceptor.SentCounter);
singleItemChannel.Send(Message.Create("test1"));
Assert.Equal(1, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
singleItemChannel.Send(Message.Create("test2"), 0);
Assert.Equal(2, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
Assert.NotNull(singleItemChannel.RemoveInterceptor(0));
singleItemChannel.Send(Message.Create("test2"), 0);
Assert.Equal(2, interceptor.InvokedCounter);
Assert.Equal(1, interceptor.SentCounter);
}
public void TestBlockingSendWithTimeout()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new QueueChannel(provider, 1);
var result1 = channel.Send(new GenericMessage("test-1"));
Assert.True(result1);
var latch = new CountdownEvent(1);
Task.Run(() =>
{
channel.Send(new GenericMessage("test-2"), 5);
latch.Signal();
});
Assert.True(latch.Wait(10000));
}
public void TestImmediateSend()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new QueueChannel(provider, 3);
var result1 = channel.Send(new GenericMessage("test-1"));
Assert.True(result1);
var result2 = channel.Send(new GenericMessage("test-2"), 100);
Assert.True(result2);
var result3 = channel.Send(new GenericMessage("test-3"), 0);
Assert.True(result3);
var result4 = channel.Send(new GenericMessage("test-4"), 0);
Assert.False(result4);
}
public void TestBlockingSendWithNoTimeout()
{
QueueChannel channel = new QueueChannel(1);
bool result1 = channel.Send(new Message <string>("test-1"));
Assert.IsTrue(result1);
AtomicBoolean SendInterrupted = new AtomicBoolean(false);
CountDownLatch latch = new CountDownLatch(1);
Thread t = new Thread(new ThreadStart(delegate
{
channel.Send(new Message <string>("test-2"));
SendInterrupted.Value = true;
latch.CountDown();
}));
t.Start();
//Assert.IsFalse(SendInterrupted.Value);
t.Interrupt();
latch.Await();
Assert.IsTrue(SendInterrupted.Value);
}
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 testMultipleSelectorsAccept()
{
AtomicInteger counter = new AtomicInteger();
IMessageSelector selector1 = new TestMessageSelector(true, counter);
IMessageSelector selector2 = new TestMessageSelector(true, counter);
MessageSelectingInterceptor interceptor = new MessageSelectingInterceptor(selector1, selector2);
QueueChannel channel = new QueueChannel();
channel.AddInterceptor(interceptor);
Assert.That(channel.Send(new StringMessage("test1")), Is.True);
Assert.That(counter.Value, Is.EqualTo(2));
}
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 ReceiveWithExplicitChannelTakesPrecedenceOverDefault()
{
QueueChannel explicitChannel = new QueueChannel();
QueueChannel defaultChannel = new QueueChannel();
explicitChannel.Send(new StringMessage("test"));
MessageChannelTemplate template = new MessageChannelTemplate(defaultChannel);
template.ReceiveTimeout = TimeSpan.Zero;
IMessage reply = template.Receive(explicitChannel);
Assert.That(reply.Payload, Is.EqualTo("test"));
Assert.IsNull(defaultChannel.Receive(TimeSpan.Zero));
}
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);
}
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 CreateAndUseQueueChannelWithTenElements()
{
QueueChannel channel = new QueueChannel(10);
for (int k = 1; k <= 10; k++)
{
channel.Send(k);
}
for (int k = 1; k <= 10; k++)
{
Assert.AreEqual(k, channel.Receive());
}
}
public void TestClear()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new QueueChannel(provider, 2);
var message1 = new GenericMessage("test1");
var message2 = new GenericMessage("test2");
var message3 = new GenericMessage("test3");
Assert.True(channel.Send(message1));
Assert.True(channel.Send(message2));
Assert.False(channel.Send(message3, 0));
Assert.Equal(2, channel.QueueSize);
Assert.Equal(2 - 2, channel.RemainingCapacity);
var clearedMessages = channel.Clear();
Assert.NotNull(clearedMessages);
Assert.Equal(2, clearedMessages.Count);
Assert.Equal(0, channel.QueueSize);
Assert.Equal(2, channel.RemainingCapacity);
Assert.True(channel.Send(message3));
}