public void UsingPublishSubscribeChannels()
{
PublishSubscribeChannel channel = new PublishSubscribeChannel();
channel.Subscribe(new SimpleMessageHandler("Handler-1"));
channel.Subscribe(new SimpleMessageHandler("Handler-2"));
IMessage diningMessage =
MessageBuilder.WithPayload("Hello World").Build();
channel.Send(diningMessage);
channel.Send(diningMessage);
channel.Send(diningMessage);
}
public void HandlerThrowsExceptionPublishSubscribeWithExecutor()
{
services.AddSingleton <IDestinationResolver <IMessageChannel>, DefaultMessageChannelDestinationResolver>();
services.AddSingleton <IMessageBuilderFactory, DefaultMessageBuilderFactory>();
services.AddSingleton <IMessageChannel>((p) => new DirectChannel(p.GetService <IApplicationContext>(), "errorChannel"));
var provider = services.BuildServiceProvider();
var defaultErrorChannel = provider.GetService <IMessageChannel>() as DirectChannel;
var channel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>(), TaskScheduler.Default);
var resultHandler = new ResultHandler(latch);
var throwingHandler = new ThrowMessageExceptionHandler();
channel.Subscribe(throwingHandler);
defaultErrorChannel.Subscribe(resultHandler);
var message = IntegrationMessageBuilder.WithPayload("test").Build();
channel.Send(message);
Assert.True(latch.Wait(10000));
var errorMessage = resultHandler.LastMessage;
Assert.IsType <MessagingException>(errorMessage.Payload);
var exceptionPayload = (MessagingException)errorMessage.Payload;
Assert.IsType <NotSupportedException>(exceptionPayload.InnerException);
Assert.Same(message, exceptionPayload.FailedMessage);
Assert.NotEqual(Thread.CurrentThread.ManagedThreadId, resultHandler.LastThread.ManagedThreadId);
}
public void PublishSubscribeChannel_Send_10_000_000_TwoHandlers()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new PublishSubscribeChannel(provider);
var handler1 = new CounterHandler();
var handler2 = new CounterHandler();
channel.Subscribe(handler1);
channel.Subscribe(handler2);
var message = new GenericMessage("test");
for (var i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
if (handler1.Count != 10_000_000)
{
throw new InvalidOperationException("Handler count1 invalid");
}
if (handler2.Count != 10_000_000)
{
throw new InvalidOperationException("Handler count2 invalid");
}
}
private static void SimpleMessageHandlerEventing()
{
PublishSubscribeChannel channel = new PublishSubscribeChannel();
channel.Subscribe(new SimpleMessageHandler("one"));
channel.Subscribe(new SimpleMessageHandler("two"));
IMessage message = MessageBuilder.WithPayload("foo").Build();
channel.Send(message);
}
private static void SimpleMessageHandlerEventing()
{
PublishSubscribeChannel channel = new PublishSubscribeChannel();
channel.Subscribe(new SimpleMessageHandler("one"));
channel.Subscribe(new SimpleMessageHandler("two"));
IMessage message = MessageBuilder.WithPayload("foo").Build();
channel.Send(message);
}
public void HandlerThrowsExceptionPublishSubscribeWithoutScheduler()
{
var provider = services.BuildServiceProvider();
var channel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>());
var handler = new ThrowingHandler();
channel.Subscribe(handler);
var message = IntegrationMessageBuilder.WithPayload("test").Build();
Assert.Throws <MessageDeliveryException>(() => channel.Send(message));
}
public void TestSendOneHandler_10_000_000()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var handler = new CounterHandler();
var channel = new PublishSubscribeChannel(provider);
channel.Subscribe(handler);
var message = new GenericMessage("test");
Assert.True(channel.Send(message));
for (var i = 0; i < 10000000; i++)
{
channel.Send(message);
}
Assert.Equal(10000001, handler.Count);
}
public void Should_return_false_if_there_are_no_subscribers()
{
Fiber fiber = new SynchronousFiber();
Channel<UserUpdate> channel = new PublishSubscribeChannel<UserUpdate>(fiber, new Channel<UserUpdate>[] {});
var update = new UserUpdate();
channel.Send(update);
// exception here? or just ignore
}
public void PublishSubscribeChannel_Send_10_000_000_SingleHandler()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>());
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = Message.Create("test");
channel.Send(message);
for (var i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
if (handler.Count != 10_000_000 + 1)
{
throw new InvalidOperationException("Handler count invalid");
}
}
public void HandlerThrowsExceptionPublishSubscribeWithoutScheduler()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var channel = new PublishSubscribeChannel(provider);
var handler = new ThrowingHandler();
channel.Subscribe(handler);
var message = MessageBuilder.WithPayload("test").Build();
Assert.Throws <MessageDeliveryException>(() => channel.Send(message));
}
public void TestSend()
{
var services = new ServiceCollection();
services.AddSingleton <IIntegrationServices, IntegrationServices>();
var provider = services.BuildServiceProvider();
var handler = new CounterHandler();
var channel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>());
channel.Subscribe(handler);
var message = Message.Create("test");
Assert.True(channel.Send(message));
Assert.Equal(1, handler.Count);
}
public void Should_filter_out_unwanted_messages()
{
var update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};
Fiber fiber = new SynchronousFiber();
var future = new Future<UserUpdate>();
var filter = new FilterChannel<UserUpdate>(fiber, future, x => x.LastActivity > DateTime.Now);
Channel<UserUpdate> channel = new PublishSubscribeChannel<UserUpdate>(fiber, new[] {filter});
channel.Send(update);
Assert.IsFalse(future.WaitUntilCompleted(1.Seconds()));
}
public void Should_schedule_events()
{
var update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};
Fiber fiber = new SynchronousFiber();
var future = new Future<UserUpdate>();
Channel<UserUpdate> channel = new PublishSubscribeChannel<UserUpdate>(fiber, new Channel<UserUpdate>[] {future});
var scheduler = new TimerFiberScheduler(fiber);
scheduler.Schedule(1000, fiber, () => channel.Send(update));
Thread.Sleep(500);
Assert.IsFalse(future.WaitUntilCompleted(0.Seconds()));
Assert.IsTrue(future.WaitUntilCompleted(1.Seconds()));
}
public void UsingPublishSubscribeChannels()
{
PublishSubscribeChannel channel = new PublishSubscribeChannel();
channel.Subscribe(new SimpleMessageHandler("Handler-1"));
channel.Subscribe(new SimpleMessageHandler("Handler-2"));
IMessage diningMessage =
MessageBuilder.WithPayload("Hello World").Build();
channel.Send(diningMessage);
channel.Send(diningMessage);
channel.Send(diningMessage);
}
