public void Acknowledge_CallsModelBasicAck()
{
//Arrange
ulong deliveryTag = 1;
var message = new DeliveredRabbitMessage { DeliveryTag = deliveryTag };
var model = Substitute.For<IModel>();
var sut = new ConfirmingSubscription(model);
//Act
sut.Acknowledge(message);
//Assert
model.Received().BasicAck(deliveryTag,false);
}
public void Failure_CallsModelBasicNack()
{
//Arrange
ulong deliveryTag = 1;
var message = new DeliveredRabbitMessage { DeliveryTag = deliveryTag };
var model = Substitute.For<IModel>();
var sut = new ConfirmingSubscription(model);
//Act
sut.Failure(message,new Exception());
//Assert
model.Received().BasicNack(deliveryTag, false, false);
}
public async Task ConsumeMessages_WhenHandlerThrows_AcksOtherMessage()
{
var message1 = new DeliveredRabbitMessage();
var message2 = new DeliveredRabbitMessage();
var source = new MockMessageSource(new [] { message1, message2 });
var handler = Substitute.For<IMessageHandler>();
handler.When(x => x.HandleMessage(message1, Arg.Any<CancellationToken>()))
.Do(x => { throw new Exception(); });
var sut = new AsyncMessageConsumer(source) { ConcurrencyLevel = 2 };
//Act
await sut.ConsumeMessages(handler,CancellationToken.None);
//Assert
Assert.That(source.Acks.Contains(message2));
}
public async Task ConsumeMessages_WhenCompletesSuccessfully_AcksMessages()
{
var message1 = new DeliveredRabbitMessage();
var message2 = new DeliveredRabbitMessage();
var source = new MockMessageSource(new [] { message1, message2 });
var handler = Substitute.For<IMessageHandler>();
handler.HandleMessage(message1, Arg.Any<CancellationToken>())
.Returns(Task.Delay(0));
var sut = new AsyncMessageConsumer(source) { ConcurrencyLevel = 2 };
//Act
await sut.ConsumeMessages(handler, CancellationToken.None);
//Assert
Assert.That(source.Acks.Contains(message1));
Assert.That(source.Acks.Contains(message2));
}
public async Task ConsumeMessages_HandlesMessagesFromSource()
{
var message1 = new DeliveredRabbitMessage();
var message2 = new DeliveredRabbitMessage();
var source = new MockMessageSource(new [] {message1,message2});
var handler = Substitute.For<IMessageHandler>();
handler.HandleMessage(message1, Arg.Any<CancellationToken>())
.Returns(Task.Delay(0));
var sut = new AsyncMessageConsumer(source) { ConcurrencyLevel = 2 };
//Act
await sut.ConsumeMessages(handler, CancellationToken.None);
//Assert
handler.Received().HandleMessage(message1, Arg.Any<CancellationToken>()).IgnoreAwait();
handler.Received().HandleMessage(message2, Arg.Any<CancellationToken>()).IgnoreAwait();
}
public override bool TryGetNextMessage(out DeliveredRabbitMessage message)
{
message = null;
BasicGetResult result = _model.BasicGet(QueueName, false);
if (result == null)
{
return false;
}
message = new DeliveredRabbitMessage
{
Body = result.Body,
DeliveryTag = result.DeliveryTag,
Exchange = result.Exchange,
Properties = result.BasicProperties,
Redelivered = result.Redelivered,
RoutingKey = result.RoutingKey,
};
return true;
}
public void Failure(DeliveredRabbitMessage message, Exception exception)
{
Nacks.Add(new KeyValuePair<DeliveredRabbitMessage, Exception>(message,exception));
}
public void Cancel(DeliveredRabbitMessage message)
{
Canceled.Add(message);
}
public void Acknowledge(DeliveredRabbitMessage message)
{
Acks.Add(message);
}
public abstract bool TryGetNextMessage(out DeliveredRabbitMessage message);
public virtual void Failure(DeliveredRabbitMessage message, Exception exception)
{
_model.BasicNack(message.DeliveryTag, false, false);
}
public virtual void Cancel(DeliveredRabbitMessage message)
{
_model.BasicNack(message.DeliveryTag, false, true);
}
public async Task ConsumeMessages_WhenHandlerThrowsAsync_NacksMessage()
{
var message1 = new DeliveredRabbitMessage();
var source = new MockMessageSource(new [] { message1, new DeliveredRabbitMessage()});
var exception = new Exception();
var handler = Substitute.For<IMessageHandler>();
handler.HandleMessage(message1, Arg.Any<CancellationToken>())
.Returns(y => Task.Run(async () =>{
await Task.Yield();
throw exception;
}));
var sut = new AsyncMessageConsumer(source) { ConcurrencyLevel = 2 };
//Act
await sut.ConsumeMessages(handler,CancellationToken.None);
//Assert
Assert.That(source.Nacks.Contains(new KeyValuePair<DeliveredRabbitMessage, Exception>(message1, exception)));
}
public async Task ConsumeMessages_WhenHandlersAreCancelled_DoesNotAcknowledgeOrFail()
{
var message = new DeliveredRabbitMessage();
var source = new MockMessageSource(new[] { message });
var handler = Substitute.For<IMessageHandler>();
var sut = new AsyncMessageConsumer(source);
handler.HandleMessage(Arg.Any<DeliveredRabbitMessage>(), Arg.Any<CancellationToken>())
.Returns(c => Task.Delay(-1, c.Arg<CancellationToken>()));
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(0.1)))
{
//Act
await sut.ConsumeMessages(handler, cts.Token);
}
//Assert
Assert.That(source.Acks.Any(), Is.False);
Assert.That(source.Nacks.Any(), Is.False);
Assert.That(source.Canceled.Contains(message));
}
public async Task ConsumeMessages_WhenAlreadyCancelled_DoesNothing()
{
var message1 = new DeliveredRabbitMessage();
var message2 = new DeliveredRabbitMessage();
var source = new MockMessageSource(new[] { message1, message2 });
var handler = Substitute.For<IMessageHandler>();
handler.HandleMessage(message1, Arg.Any<CancellationToken>())
.Returns(Task.Delay(0));
var sut = new AsyncMessageConsumer(source) { ConcurrencyLevel = 2 };
using (var cts = new CancellationTokenSource())
{
cts.Cancel();
//Act
await sut.ConsumeMessages(handler, cts.Token);
}
//Assert
handler.DidNotReceive().HandleMessage(message1, Arg.Any<CancellationToken>()).IgnoreAwait();
handler.DidNotReceive().HandleMessage(message2, Arg.Any<CancellationToken>()).IgnoreAwait();
}
public bool TryGetNextMessage(out DeliveredRabbitMessage message)
{
var result = _messages.TryDequeue(out message);
OnGetNextMessage(message);
return result;
}
public virtual void Acknowledge(DeliveredRabbitMessage message)
{
_model.BasicAck(message.DeliveryTag, false);
}
public override bool TryGetNextMessage(out DeliveredRabbitMessage message)
{
return _queue.TryDequeue(out message);
}
