public void When_requeing_a_failed_message_with_delay()
{
//send & receive a message
_messageProducer.Send(_message);
var message = _messageConsumer.Receive(1000).Single();
message.Header.MessageType.Should().Be(MessageType.MT_COMMAND);
message.Header.HandledCount.Should().Be(0);
message.Header.DelayedMilliseconds.Should().Be(0);
_messageConsumer.Acknowledge(message);
//now requeue with a delay
_message.UpdateHandledCount();
_messageConsumer.Requeue(_message, 1000);
//receive and assert
var message2 = _messageConsumer.Receive(5000).Single();
message2.Header.MessageType.Should().Be(MessageType.MT_COMMAND);
message2.Header.HandledCount.Should().Be(1);
message2.Header.DelayedMilliseconds.Should().Be(1000);
_messageConsumer.Acknowledge(message2);
}
public void When_Requeuing_A_Message_With_No_Delay()
{
_channel.Requeue(_requeueMessage);
//_should_call_the_messaging_gateway
A.CallTo(() => _gateway.Requeue(_requeueMessage)).MustHaveHappened();
}
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_Unsupported_Delay()
{
_stopWatch.Start();
_channel.Requeue(_requeueMessage, 1000);
_stopWatch.Stop();
//_should_call_the_messaging_gateway
A.CallTo(() => _gateway.Requeue(_requeueMessage)).MustHaveHappened();
//_should_have_process_delayed_the_call
Assert.True((_stopWatch.ElapsedMilliseconds > 900));
}
public void When_requeueing_a_message()
{
_sender.Send(_sentMessage);
_receivedMessage = _receiver.Receive(2000);
_receivedReceiptHandle = _receivedMessage.Header.Bag["ReceiptHandle"].ToString();
_receiver.Requeue(_receivedMessage);
//should_delete_the_original_message_and_create_new_message
_requeuedMessage = _receiver.Receive(1000);
_requeuedMessage.Body.Value.Should().Be(_receivedMessage.Body.Value);
_requeuedMessage.Header.Bag["ReceiptHandle"].Should().Be(_receivedReceiptHandle);
}
/// <summary>
/// Requeues the specified message.
/// </summary>
/// <param name="message"></param>
public void Requeue(Message message, int delayMilliseconds = 0)
{
if (delayMilliseconds > 0 && !_messageConsumerSupportsDelay)
{
Task.Delay(delayMilliseconds).Wait();
}
if (_messageConsumerSupportsDelay)
{
(_messageConsumer as IAmAMessageConsumerSupportingDelay).Requeue(message, delayMilliseconds);
}
else
{
_messageConsumer.Requeue(message);
}
}
/// <summary>
/// Requeues the specified message.
/// </summary>
/// <param name="message"></param>
/// <param name="delayMilliseconds">How long should we delay before requeueing</param>
public void Requeue(Message message, int delayMilliseconds = 0)
{
_messageConsumer.Requeue(message, delayMilliseconds);
}
/// <summary>
/// Requeues the specified message.
/// </summary>
/// <param name="message"></param>
public void Requeue(Message message)
{
_messageConsumer.Requeue(message);
}
/// <summary>
/// Requeues the specified message.
/// </summary>
/// <param name="message"></param>
/// <param name="delayMilliseconds">How long should we delay before requeueing</param>
/// <returns>True if the message was re-queued false otherwise </returns>
public bool Requeue(Message message, int delayMilliseconds = 0)
{
return(_messageConsumer.Requeue(message, delayMilliseconds));
}