public SendTask(TaskSchedulerSubscribableChannel channel, List <ITaskSchedulerChannelInterceptor> interceptors, IMessage message, IMessageHandler messageHandler)
{
_channel = channel;
Message = message;
MessageHandler = messageHandler;
_interceptors = interceptors;
_interceptorIndex = -1;
}
public async Task SendAndReceiveAsync()
{
var channel = new TaskSchedulerSubscribableChannel(TaskScheduler.Default);
channel.Subscribe(new SendAndReceiveTestHandler());
var actual = await Template.ConvertSendAndReceiveAsync <string>(channel, "request");
Assert.Equal("response", actual);
}
public async ValueTask TaskSchedulerSubscribableChannel_WriteAsync_10_000_000()
{
var channel = new TaskSchedulerSubscribableChannel();
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = Message.Create("test");
for (var i = 0; i < 10_000_000; i++)
{
await channel.Writer.WriteAsync(message);
}
}
public void TaskSchedulerSubscribableChannel_Send_10_000_000()
{
var channel = new TaskSchedulerSubscribableChannel();
var handler = new CounterHandler();
channel.Subscribe(handler);
var message = Message.Create("test");
for (var i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
}
public void TaskSchedulerSubscribableChannel_Send_10_000_000()
{
var channel = new TaskSchedulerSubscribableChannel();
var handler = new CounterHandler();
channel.Subscribe(handler);
GenericMessage message = new GenericMessage("test");
for (int i = 0; i < 10_000_000; i++)
{
channel.Send(message);
}
}
public DestinationResolvingMessagingTemplateTest()
{
var resolver = new TestMessageChannelDestinationResolver();
myChannel = new TaskSchedulerSubscribableChannel();
resolver.RegisterMessageChannel("myChannel", myChannel);
template = new TestDestinationResolvingMessagingTemplate();
template.DestinationResolver = resolver;
headers = new Dictionary <string, object>()
{
{ "key", "value" }
};
postProcessor = new TestMessagePostProcessor();
}
public void SendWithScheduler()
{
var mock = new Mock <IMessageHandler>();
_handler = mock.Object;
var interceptor = new BeforeHandleInterceptor();
var scheduler = new TestScheduler();
var testChannel = new TaskSchedulerSubscribableChannel(scheduler);
testChannel.AddInterceptor(interceptor);
testChannel.Subscribe(_handler);
testChannel.Send(_message);
Assert.True(scheduler.WasTaskScheduled);
mock.Verify(h => h.HandleMessage(_message));
Assert.Equal(1, interceptor.Counter);
Assert.True(interceptor.WasAfterHandledInvoked);
}
public TaskSchedulerSubscribableChannelWriterTest()
{
_channel = new TaskSchedulerSubscribableChannel();
_payload = new object();
_message = MessageBuilder <object> .WithPayload(_payload).Build();
}
public ChannelInterceptorTest()
{
channel = new TaskSchedulerSubscribableChannel();
messageHandler = new TestMessageHandler();
channel.Subscribe(messageHandler);
}
