public async Task HandleErrorAsync_SingleMessage_TrueReturned()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
null,
new TestOffset(),
new TestConsumerEndpoint("source-endpoint"),
"source-endpoint");
var result = await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
result.Should().BeTrue();
}
public void CanHandle_SingleMessage_TrueReturned()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var result = policy.CanHandle(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
result.Should().BeTrue();
}
public void Enrich_StaticValues_HeaderReplaced()
{
var envelope = EnvelopeFactory.Create(
new TestEventOne(),
new MessageHeaderCollection
{
{ "x-test", "old-value" }
},
TestProducerEndpoint.GetDefault());
var enricher = new GenericOutboundHeadersEnricher("x-test", "value");
enricher.Enrich(envelope);
envelope.Headers.Should().HaveCount(1);
envelope.Headers.Should().BeEquivalentTo(new[] { new MessageHeader("x-test", "value") });
}
public void Enrich_ValueProvider_HeaderAdded()
{
var envelope = EnvelopeFactory.Create(
new TestEventOne {
Content = "content"
},
null,
TestProducerEndpoint.GetDefault());
var enricher = new GenericOutboundHeadersEnricher <TestEventOne>(
"x-test",
envelopeToEnrich => envelopeToEnrich.Message?.Content);
enricher.Enrich(envelope);
envelope.Headers.Should().HaveCount(1);
envelope.Headers.Should().BeEquivalentTo(new[] { new MessageHeader("x-test", "content") });
}
public void HandleAsync_StartedActivity_TraceIdHeaderIsSet()
{
var activity = new Activity("test");
activity.SetParentId("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01");
activity.Start();
var envelope = new OutboundEnvelope(null, null, TestProducerEndpoint.GetDefault());
new ActivityProducerBehavior().HandleAsync(
new ProducerPipelineContext(envelope, Substitute.For <IProducer>(), Substitute.For <IServiceProvider>()),
_ => Task.CompletedTask);
envelope.Headers.Should().Contain(
header =>
header.Name == DefaultMessageHeaders.TraceId &&
header.Value != null &&
header.Value.StartsWith("00-0af7651916cd43dd8448eb211c80319c", StringComparison.Ordinal));
}
public async Task HandleErrorAsync_Whatever_ConsumerCommittedButTransactionAborted()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
null,
new TestOffset(),
new TestConsumerEndpoint("source-endpoint"),
"source-endpoint");
var transactionManager = Substitute.For <IConsumerTransactionManager>();
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider, transactionManager),
new InvalidOperationException("test"));
await transactionManager.Received(1).RollbackAsync(Arg.Any <InvalidOperationException>(), true);
}
public void Enrich_SpecificMessageType_HeaderAddedToMessagesOfMatchingType()
{
var envelopeEventOne = EnvelopeFactory.Create(
new TestEventOne(),
null,
TestProducerEndpoint.GetDefault());
var envelopeEventTwo = EnvelopeFactory.Create(
new TestEventTwo(),
null,
TestProducerEndpoint.GetDefault());
var enricher = new GenericOutboundHeadersEnricher <TestEventOne>("x-test", "value");
enricher.Enrich(envelopeEventOne);
enricher.Enrich(envelopeEventTwo);
envelopeEventOne.Headers.Should().HaveCount(1);
envelopeEventTwo.Headers.Should().BeEmpty();
}
public async Task HandleErrorAsync_NotDeserializedInboundMessage_MessagePreserved()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
var producedMessage = producer.ProducedMessages.Last();
producedMessage.Message.Should().BeEquivalentTo(producedMessage.Message);
}
public async Task HandleErrorAsync_InboundMessage_MessageMoved()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
producer.ProducedMessages.Should().HaveCount(1);
}
public void CanHandle_RawSequence_FalseReturned()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var context = ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider);
context.SetSequence(new ChunkSequence("123", 5, context), false);
var result = policy.CanHandle(
context,
new InvalidOperationException("test"));
result.Should().BeFalse();
}
public async Task HandleErrorAsync_InboundMessage_MessagePreserved()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var message = new TestEventOne {
Content = "hey oh!"
};
var headers = new MessageHeaderCollection
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var rawContent = await TestConsumerEndpoint.GetDefault().Serializer
.SerializeAsync(message, headers, MessageSerializationContext.Empty);
var envelope = new InboundEnvelope(
message,
rawContent,
headers,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
var producedMessage = producer.ProducedMessages.Last();
var(deserializedMessage, _) =
await producedMessage.Endpoint.Serializer.DeserializeAsync(
new MemoryStream(producedMessage.Message !),
producedMessage.Headers,
MessageSerializationContext.Empty);
deserializedMessage.Should().BeEquivalentTo(envelope.Message);
}
public void CreateOutboundEnvelope_NullMessage_UntypedEnvelopeReturned()
{
var endpoint = TestProducerEndpoint.GetDefault();
var headers = new[] { new MessageHeader("one", "1"), new MessageHeader("two", "2") };
var factory = new OutboundEnvelopeFactory(
new OutboundRoutingConfiguration
{
PublishOutboundMessagesToInternalBus = true
});
var envelope = factory.CreateOutboundEnvelope(
null,
headers,
TestProducerEndpoint.GetDefault());
envelope.Should().BeOfType <OutboundEnvelope>();
envelope.Message.Should().BeNull();
envelope.Headers.Should().ContainSingle(header => header.Name == "one" && header.Value == "1");
envelope.Headers.Should().ContainSingle(header => header.Name == "two" && header.Value == "2");
envelope.Endpoint.Should().Be(endpoint);
}
public void LogProduced_NoEnvelope_Logged()
{
var endpoint = new TestProducerEndpoint("[dynamic]");
var actualEndpointName = "test1";
var headers = new MessageHeaderCollection
{
{ DefaultMessageHeaders.MessageType, "Message.Type" },
{ DefaultMessageHeaders.MessageId, "1234" }
};
var brokerMessageIdentifier = new TestOffset("a", "42");
var expectedMessage =
"Message produced. | " +
"endpointName: test1, " +
"messageType: Message.Type, " +
"messageId: 1234, " +
"unused1: (null), " +
"unused2: (null)";
_outboundLogger.LogProduced(endpoint, actualEndpointName, headers, brokerMessageIdentifier);
_loggerSubstitute.Received(LogLevel.Information, null, expectedMessage, 1031);
}
public async Task HandleAsync_None_WarningIsNotLogged(IIntegrationMessage message)
{
var endpoint = TestProducerEndpoint.GetDefault();
endpoint.MessageValidationMode = MessageValidationMode.None;
var envelope = new OutboundEnvelope(message, null, endpoint);
IOutboundEnvelope?result = null;
await new ValidatorProducerBehavior(_outboundLogger).HandleAsync(
new ProducerPipelineContext(
envelope,
Substitute.For <IProducer>(),
Substitute.For <IServiceProvider>()),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
result.Should().NotBeNull();
result !.Message.Should().NotBeNull();
_loggerSubstitute.DidNotReceive(LogLevel.Warning, null).Should().BeTrue();
}
public async Task Transform_SingleMessage_HeadersProperlyModified()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault())
.Transform((outboundEnvelope, ex) => { outboundEnvelope.Headers.Add("error", ex.GetType().Name); })
.Build(_serviceProvider);
var envelope = new InboundEnvelope(
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
envelope.Headers.Add("key", "value");
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
var newHeaders = producer.ProducedMessages[0].Headers;
newHeaders.Should().HaveCount(4); // key, error, traceparent, message-id
}
public async Task HandleErrorAsync_InboundMessage_HeadersPreserved()
{
var policy = new MoveMessageErrorPolicy(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var headers = new MessageHeaderCollection
{
{ "key1", "value1" },
{ "key2", "value2" }
};
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
headers,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
producer.ProducedMessages.Last().Headers.Should().Contain(envelope.Headers);
}
public async Task HandleError_SingleMessage_SourceEndpointHeaderIsSet()
{
var policy = ErrorPolicy.Move(TestProducerEndpoint.GetDefault()).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(Encoding.UTF8.GetBytes("hey oh!")),
null,
new TestOffset(),
new TestConsumerEndpoint("source-endpoint"),
"source-endpoint");
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
var producer = (TestProducer)_broker.GetProducer(TestProducerEndpoint.GetDefault());
producer.ProducedMessages.Last()
.Headers
.Should().ContainEquivalentOf(
new MessageHeader(
DefaultMessageHeaders.SourceEndpoint,
"source-endpoint"));
}
public async Task HandleAsync_InheritedBinaryFileMessage_RawContentProduced()
{
var message = new InheritedBinaryFileMessage
{
Content = new MemoryStream(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 })
};
var envelope = new OutboundEnvelope(message, null, TestProducerEndpoint.GetDefault());
IOutboundEnvelope?result = null;
await new BinaryFileHandlerProducerBehavior().HandleAsync(
new ProducerPipelineContext(
envelope,
Substitute.For <IProducer>(),
Substitute.For <IServiceProvider>()),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
result.Should().NotBeNull();
result !.RawMessage.Should().BeEquivalentTo(message.Content);
}
public async Task HandleAsync_EndpointWithBinaryFileMessageSerializer_EnvelopeUntouched()
{
var message = new TestEventOne
{
Content = "hey!"
};
var envelope = new OutboundEnvelope(message, null, TestProducerEndpoint.GetDefault());
IOutboundEnvelope?result = null;
await new BinaryFileHandlerProducerBehavior().HandleAsync(
new ProducerPipelineContext(
envelope,
Substitute.For <IProducer>(),
Substitute.For <IServiceProvider>()),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
result.Should().NotBeNull();
result !.Should().BeSameAs(envelope);
}
