public void CanHandle_WithDifferentFailedAttemptsCount_ReturnReflectsMaxFailedAttempts(
int failedAttempts,
bool expectedResult)
{
var policy = new RetryErrorPolicy().MaxFailedAttempts(3).Build(_serviceProvider);
var rawMessage = new MemoryStream();
var headers = new[]
{
new MessageHeader(
DefaultMessageHeaders.FailedAttempts,
failedAttempts.ToString(CultureInfo.InvariantCulture))
};
var envelope = new InboundEnvelope(
rawMessage,
headers,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var canHandle = policy.CanHandle(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
canHandle.Should().Be(expectedResult);
}
public async Task HandleAsync_ThrowException_ExceptionIsThrown()
{
var message = new TestValidationMessage
{
Id = "1", String10 = "123456789abc", IntRange = 5, NumbersOnly = "123"
};
var expectedMessage =
$"The message is not valid:{Environment.NewLine}- The field String10 must be a string with a maximum length of 10.";
var endpoint = TestConsumerEndpoint.GetDefault();
endpoint.MessageValidationMode = MessageValidationMode.ThrowException;
var envelope = new InboundEnvelope(
message,
null,
null,
new TestOffset(),
endpoint,
"source-endpoint");
IRawInboundEnvelope?result = null;
Func <Task> act = () => new ValidatorConsumerBehavior(_inboundLogger).HandleAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
await act.Should().ThrowAsync <MessageValidationException>().WithMessage(expectedMessage);
result.Should().BeNull();
}
public async Task ExistsAsync_ExistingMessageIdWithDifferentTopicName_FalseReturned()
{
await _inboundLog.AddAsync(
new InboundEnvelope(
null,
new MessageHeaderCollection
{
{ "x-message-id", "123" }
},
new TestOffset("topic1", "1"),
new TestConsumerEndpoint("topic1"),
"topic1"));
await _inboundLog.CommitAsync();
var envelope = new InboundEnvelope(
null,
new MessageHeaderCollection
{
{ "x-message-id", "123" }
},
new TestOffset("topic2", "1"),
new TestConsumerEndpoint("topic2"),
"topic2");
var result = await _inboundLog.ExistsAsync(envelope);
result.Should().BeFalse();
}
public async Task HandleAsync_LogWarning_WarningIsLogged(
IIntegrationMessage message,
string expectedValidationMessage)
{
var endpoint = TestConsumerEndpoint.GetDefault();
endpoint.MessageValidationMode = MessageValidationMode.LogWarning;
var envelope = new InboundEnvelope(
message,
null,
null,
new TestOffset(),
endpoint,
"source-endpoint");
IRawInboundEnvelope?result = null;
await new ValidatorConsumerBehavior(_inboundLogger).HandleAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
result.Should().NotBeNull();
_loggerSubstitute.Received(LogLevel.Warning, null, expectedValidationMessage, 1080);
}
public async Task HandleAsync_ValidMessage_NoLogAndNoException(MessageValidationMode validationMode)
{
var message = new TestValidationMessage
{
Id = "1", String10 = "123", IntRange = 5, NumbersOnly = "123"
};
var endpoint = TestConsumerEndpoint.GetDefault();
endpoint.MessageValidationMode = validationMode;
var envelope = new InboundEnvelope(
message,
null,
null,
new TestOffset(),
endpoint,
"source-endpoint");
IRawInboundEnvelope?result = null;
Func <Task> act = () => new ValidatorConsumerBehavior(_inboundLogger).HandleAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
context =>
{
result = context.Envelope;
return(Task.CompletedTask);
});
await act.Should().NotThrowAsync <ValidationException>();
result.Should().NotBeNull();
_loggerSubstitute.DidNotReceive(LogLevel.Warning, null).Should().BeTrue();
}
public async Task HandleErrorAsync_Whatever_ConsumerRolledBackAndTransactionAborted()
{
var policy = new RetryErrorPolicy().MaxFailedAttempts(3).Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var transactionManager = Substitute.For <IConsumerTransactionManager>();
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(
envelope,
_serviceProvider,
transactionManager),
new InvalidOperationException("test"));
await transactionManager.Received(1).RollbackAsync(
Arg.Any <InvalidOperationException>(),
false,
true,
false);
}
public void MustProcess_InboundEnvelopeWithNonMqttEndpoint_FalseIsReturned()
{
var inboundEnvelope = new InboundEnvelope(
new MemoryStream(),
new List <MessageHeader>(),
new TestOffset(),
new SomeConsumerEndpoint("test"),
string.Empty);
var result = new MqttClientIdFilterAttribute().MustProcess(inboundEnvelope);
result.Should().BeFalse();
}
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 async Task HandleErrorAsync_Whatever_FalseReturned()
{
var policy = new StopConsumerErrorPolicy().Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var result = await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
result.Should().BeFalse();
}
public void CanHandle_Whatever_TrueReturned()
{
var policy = new StopConsumerErrorPolicy().Build(_serviceProvider);
var envelope = new InboundEnvelope(
"hey oh!",
new MemoryStream(),
null,
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var canHandle = policy.CanHandle(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, _serviceProvider),
new InvalidOperationException("test"));
canHandle.Should().BeTrue();
}
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 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 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_WithMaxFailedAttempts_ExpectedResultReturned(int failedAttempts, bool expectedResult)
{
var envelope = new InboundEnvelope(
new MemoryStream(),
new[] { new MessageHeader(DefaultMessageHeaders.FailedAttempts, failedAttempts) },
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
var policy = new TestErrorPolicy()
.MaxFailedAttempts(3)
.Build(Substitute.For <IServiceProvider>());
var canHandle = policy.CanHandle(
ConsumerPipelineContextHelper.CreateSubstitute(envelope),
new InvalidOperationException());
canHandle.Should().Be(expectedResult);
}
public async Task ExistsAsync_ExistingEnvelope_TrueReturned()
{
var envelope = new InboundEnvelope(
null,
new MessageHeaderCollection
{
{ "x-message-id", "123" }
},
new TestOffset("topic1", "1"),
new TestConsumerEndpoint("topic1"),
"topic1");
await _inboundLog.AddAsync(envelope);
await _inboundLog.CommitAsync();
var result = await _inboundLog.ExistsAsync(envelope);
result.Should().BeTrue();
}
public async Task HandleErrorAsync_Whatever_TransactionNotCommittedNorAborted()
{
/* The consumer will be stopped and the transaction aborted by the consumer/behavior */
var policy = new StopConsumerErrorPolicy().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.ReceivedWithAnyArgs(0).RollbackAsync(Arg.Any <InvalidOperationException>());
}
public void MustProcess_InboundEnvelopesWithDifferentClientId_ExpectedResultIsReturned(
string envelopeClientId,
bool expectedResult)
{
var inboundEnvelope = new InboundEnvelope(
new MemoryStream(),
new List <MessageHeader>(),
new TestOffset(),
new MqttConsumerEndpoint("my-topic")
{
Configuration =
{
ClientId = envelopeClientId
}
},
"my-topic");
var result = new MqttClientIdFilterAttribute("client1", "client2").MustProcess(inboundEnvelope);
result.Should().Be(expectedResult);
}
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 ExistsAsync_NotExistingMessageId_FalseReturned()
{
var envelope = new InboundEnvelope(
null,
new MessageHeaderCollection
{
{ "x-message-id", "123" }
},
new TestOffset("topic1", "1"),
new TestConsumerEndpoint("topic1"),
"topic1");
await _inboundLog.AddAsync(envelope);
await _inboundLog.CommitAsync();
envelope.Headers.AddOrReplace("x-message-id", "456");
var result = await _inboundLog.ExistsAsync(envelope);
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 async Task HandleErrorAsync_WithPublishReturningNull_NoMessagePublished()
{
var publisher = Substitute.For<IPublisher>();
var serviceProvider = new ServiceCollection().AddScoped(_ => publisher)
.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true });
var policy = new TestErrorPolicy()
.Publish(_ => null)
.Build(serviceProvider);
var envelope = new InboundEnvelope(
new MemoryStream(),
new[] { new MessageHeader(DefaultMessageHeaders.FailedAttempts, "3") },
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, serviceProvider),
new ArgumentNullException());
await publisher.DidNotReceive().PublishAsync(Arg.Any<object>());
}
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 HandleErrorAsync_WithPublishForwardingException_MessagePublished()
{
var publisher = Substitute.For<IPublisher>();
var serviceProvider = new ServiceCollection().AddScoped(_ => publisher)
.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true });
var policy = new TestErrorPolicy()
.Publish((_, exception) => new TestEventTwo { Content = exception.Message })
.Build(serviceProvider);
var envelope = new InboundEnvelope(
new MemoryStream(),
new[] { new MessageHeader(DefaultMessageHeaders.FailedAttempts, "3") },
new TestOffset(),
TestConsumerEndpoint.GetDefault(),
TestConsumerEndpoint.GetDefault().Name);
await policy.HandleErrorAsync(
ConsumerPipelineContextHelper.CreateSubstitute(envelope, serviceProvider),
new TimeoutException("Exception message."));
await publisher.Received().PublishAsync(
Arg.Is<TestEventTwo>(message => message.Content == "Exception message."));
}
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 InboundEmailResult handleInboundEmail(InboundEmail inboundEmail, InboundEnvelope inboundEnvelope)
{
throw new global::System.NotImplementedException("InboundEmailHandler.HandleInboundEmail");
}
