public async Task OnMessageReceived_MultipleMessages_CorrectlyRoutedToEndpoint(IIntegrationMessage message, string[] expectedEndpointNames)
{
_routingConfiguration.Add <IIntegrationMessage>(new TestEndpoint("allMessages"), null);
_routingConfiguration.Add <IIntegrationEvent>(new TestEndpoint("allEvents"), null);
_routingConfiguration.Add <TestEventOne>(new TestEndpoint("eventOne"), null);
_routingConfiguration.Add <TestEventTwo>(new TestEndpoint("eventTwo"), null);
await _connectorRouter.OnMessageReceived(message);
await _outboundQueue.Commit();
var queued = await _outboundQueue.Dequeue(100);
foreach (var expectedEndpointName in expectedEndpointNames)
{
queued.Count(x => x.Message.Endpoint.Name == expectedEndpointName).Should().Be(1);
}
var notExpectedEndpointNames = _routingConfiguration
.Routes.Select(r => r.DestinationEndpoint.Name)
.Where(r => !expectedEndpointNames.Contains(r));
foreach (var notExpectedEndpointName in notExpectedEndpointNames)
{
queued.Count(x => x.Message.Endpoint.Name == notExpectedEndpointName).Should().Be(0);
}
}
public async Task ProcessQueue_SomeMessages_Produced()
{
await _queue.Enqueue(new OutboundMessage <TestEventOne>
{
Message = new TestEventOne {
Content = "Test"
},
Endpoint = new TestEndpoint("topic1")
});
await _queue.Enqueue(new OutboundMessage <TestEventOne>
{
Message = new TestEventOne {
Content = "Test"
},
Endpoint = new TestEndpoint("topic2")
});
await _queue.Commit();
await _worker.ProcessQueue(CancellationToken.None);
_broker.ProducedMessages.Count.Should().Be(2);
_broker.ProducedMessages[0].Endpoint.Name.Should().Be("topic1");
_broker.ProducedMessages[1].Endpoint.Name.Should().Be("topic2");
}
public void EnqueueCommitTest()
{
Parallel.For(0, 3, _ =>
{
_queue.Enqueue(_sampleOutboundMessage);
});
_queue.Commit();
_queue.Length.Should().Be(3);
}
public async Task EnqueueCommitTest()
{
Parallel.For(0, 3, _ =>
{
_queue.Enqueue(_sampleOutboundMessage);
});
await _queue.Commit();
(await _queue.GetLength()).Should().Be(3);
}
public async Task OnMessageReceived_SingleMessage_Queued()
{
var outboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne {
Content = "Test"
},
new[]
{
new MessageHeader("header1", "value1"),
new MessageHeader("header2", "value2")
},
TestEndpoint.GetDefault());
outboundMessage.RawContent = new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers);
await _connector.RelayMessage(outboundMessage);
await _queue.Commit();
(await _queue.GetLength()).Should().Be(1);
var queued = (await _queue.Dequeue(1)).First();
queued.Endpoint.Should().Be(outboundMessage.Endpoint);
queued.Headers.Count().Should().Be(3);
queued.Content.Should().BeEquivalentTo(new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers));
}
public async Task OnMessageReceived_SingleMessage_Queued()
{
var outboundMessage = new OutboundMessage <TestEventOne>()
{
Message = new TestEventOne {
Content = "Test"
},
Headers =
{
{ "header1", "value1" },
{ "header2", "value2" }
},
Endpoint = TestEndpoint.Default
};
await _connector.RelayMessage(outboundMessage);
await _queue.Commit();
_queue.Length.Should().Be(1);
var queued = (await _queue.Dequeue(1)).First();
queued.Message.Endpoint.Should().Be(outboundMessage.Endpoint);
queued.Message.Headers.Count.Should().Be(2);
((IIntegrationMessage)queued.Message.Message).Id.Should().Be(outboundMessage.Message.Id);
}
public async Task Handle_OutboundMessage_CorrectlyRelayed()
{
var outboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne(),
new MessageHeader[0],
new OutboundRoutingConfiguration.OutboundRoute(
typeof(TestEventOne),
TestEndpoint.GetDefault(),
typeof(OutboundConnector)));
await _behavior.Handle(new[] { outboundMessage, outboundMessage, outboundMessage }, Task.FromResult);
await _outboundQueue.Commit();
var queued = await _outboundQueue.Dequeue(10);
queued.Count().Should().Be(0);
_broker.ProducedMessages.Count.Should().Be(3);
}