public void When_Requeuing_A_Message_With_Unsupported_Delay()
{
_channel.Requeue(_requeueMessage, 1000);
//_should_call_the_messaging_gateway
A.CallTo(() => _consumer.Requeue(_requeueMessage, 1000)).MustHaveHappened();
}
public void When_Requeuing_A_Message_With_No_Delay()
{
_channel.Requeue(_requeueMessage);
//_should_call_the_messaging_gateway
A.CallTo(() => _gateway.Requeue(_requeueMessage)).MustHaveHappened();
}
public async Task When_Requeueing_a_message_via_the_consumer()
{
//arrange
var producer = _producerRegistry.LookupBy(_topicName) as IAmAMessageProducerAsync;
await producer.SendAsync(_message);
var message = _channel.Receive(5000);
message.Header.HandledCount++;
_channel.Requeue(message);
var requeuedMessage = _channel.Receive(5000);
requeuedMessage.Id.Should().Be(message.Id);
requeuedMessage.Redelivered.Should().BeFalse();
requeuedMessage.Header.Id.Should().Be(message.Id);
requeuedMessage.Header.Topic.Should().Contain(_topicName);
requeuedMessage.Header.CorrelationId.Should().Be(_correlationId);
requeuedMessage.Header.ContentType.Should().Be(_contentType);
requeuedMessage.Header.HandledCount.Should().Be(1);
//allow for clock drift in the following test, more important to have a contemporary timestamp than anything
requeuedMessage.Header.DelayedMilliseconds.Should().Be(0);
//{"Id":"cd581ced-c066-4322-aeaf-d40944de8edd","Value":"Test","WasCancelled":false,"TaskCompleted":false}
requeuedMessage.Body.Value.Should().Be(message.Body.Value);
}
public void When_requeueing_redrives_to_the_queue()
{
_sender.Send(_message);
var receivedMessage = _channel.Receive(2000);
_channel.Requeue(receivedMessage);
receivedMessage = _channel.Receive(1000);
_channel.Requeue(receivedMessage);
//should force us into the dlq
receivedMessage = _channel.Receive(1000);
_channel.Requeue(receivedMessage);
//inspect the dlq
GetDLQCount(_dlqChannelName).Should().Be(1);
}
public void When_Requeuing_A_Message_With_Supported_And_Enabled_Delay()
{
_stopWatch.Start();
_channel.Requeue(_requeueMessage, 1000);
_stopWatch.Stop();
//_should_call_the_messaging_gateway
A.CallTo(() => _gateway.Requeue(_requeueMessage, 1000)).MustHaveHappened();
//_should_have_used_gateway_delay_support
Assert.True((_stopWatch.ElapsedMilliseconds < 500));
}
public void When_Requeuing_A_Message_With_Unsupported_Delay()
{
_stopWatch.Start();
_channel.Requeue(_requeueMessage, 1000);
_stopWatch.Stop();
//_should_call_the_messaging_gateway
A.CallTo(() => _consumer.Requeue(_requeueMessage)).MustHaveHappened();
//_should_have_process_delayed_the_call
_stopWatch.ElapsedMilliseconds.Should().BeGreaterThan(900);
}
public void When_requeueing_a_message()
{
_sender.Send(_message);
_receivedMessage = _channel.Receive(2000);
_channel.Requeue(_receivedMessage);
_requeuedMessage = _channel.Receive(1000);
//clear the queue
_channel.Acknowledge(_requeuedMessage);
_requeuedMessage.Body.Value.Should().Be(_receivedMessage.Body.Value);
}
