public void HeaderMapping()
{
var content = new Foo();
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
const String replyExchangeType = "direct";
const String replyExchangeName = "exchange-name";
const String replyRoutingKey = "routing-key";
const String correlationId = "one-correlation-id";
var replyTo = $"{replyExchangeType}://{replyExchangeName}/{replyRoutingKey}";
var args = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
MessageId = messageId,
Timestamp = new AmqpTimestamp(timestamp),
CorrelationId = correlationId,
ReplyTo = replyTo
}
};
var message = new FakeConsumedMessage(content, args);
var actual = message.To<Foo>();
Assert.Equal(messageId, actual.Headers.MessageId);
Assert.Equal(timestamp, actual.Headers.Timestamp);
Assert.Equal(correlationId, actual.Headers.CorrelationId);
Assert.Equal(replyTo, actual.Headers.ReplyConfiguration.ToString());
}
public void ProperContentType()
{
var content = new Foo();
var message = new FakeConsumedMessage(content, FakeBasicDeliverEventArgs());
var actual = message.As<Foo>();
Assert.Equal(content, actual.Content);
}
public void NoSubscriptions()
{
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Foo(), args);
var subscriptions = _configuration.FindSubscriptions(message);
Assert.Equal(0, subscriptions.Count());
}
public void OneSubscription()
{
var configuration = new SubscriptionConfiguration();
configuration.Consumes(new FakeConsumer(_ => null));
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Foo(), args);
var subscriptions = configuration.FindSubscriptions(message);
Assert.Equal(1, subscriptions.Count());
}
public void TwoSubscriptionsForTheSameMessage()
{
_configuration.Consumes(new FakeConsumer(_ => null));
_configuration.Consumes(new FakeConsumer(_ => null));
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Foo(), args);
var subscriptions = _configuration.FindSubscriptions(message);
Assert.Equal(2, subscriptions.Count());
}
public void OnSuccess()
{
var model = new Mock<IModel>();
var strategy = new Mock<IFallbackStrategy>();
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Object(), args);
var result = message.ConsumeAsync(new SubscriptionConfiguration(strategy.Object)).Result;
Assert.IsType<Success>(result);
result.Reply(model.Object);
strategy.Verify(_ => _.Apply(model.Object), Times.Never);
}
public void ConsumerTag()
{
var content = new Foo();
const String consumerTag = "one-tag";
var args = new BasicDeliverEventArgs
{
ConsumerTag = consumerTag,
BasicProperties = new BasicProperties()
};
var message = new FakeConsumedMessage(content, args);
var actual = message.As<Foo>();
Assert.Equal(consumerTag, actual.ConsumerTag);
}
public void OnError()
{
var model = new Mock<IModel>();
var strategy = new Mock<IFallbackStrategy>();
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Object(), args);
var configuration = new SubscriptionConfiguration(strategy.Object);
configuration.Consumes(new FakeConsumer(consumedMessage => { throw new Exception(); }));
var result = message.ConsumeAsync(configuration).Result;
Assert.IsType<ConsumingFailure>(result);
result.Reply(model.Object);
strategy.Verify(_ => _.Apply(model.Object), Times.Never);
}
public void CustomHeader()
{
var content = new Foo();
var args = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
Headers = new Dictionary<String, Object>
{
{ "a", "b" }
}
}
};
var message = new FakeConsumedMessage(content, args);
var actual = message.As<Foo>();
Assert.Equal("b", actual.Headers["a"]);
}
private static Mock<IModel> BuildModel(UInt64 deliveryTag,
Func<ConsumedMessageBase, AggregateConsumingResult> func)
{
var args = new BasicDeliverEventArgs
{
DeliveryTag = deliveryTag,
BasicProperties = new BasicProperties()
};
var configuration = new SubscriptionConfiguration();
var builder = new Mock<IConsumedMessageBuilder>();
var message = new FakeConsumedMessage(args, func);
builder.Setup(_ => _.Build(args)).Returns(message);
var model = new Mock<IModel>();
var consumer = new AtLeastOnceConsumerWrapper(model.Object, builder.Object, configuration);
consumer.CallConsumeInternal(args).Wait();
return model;
}
public void HeaderMapping()
{
var content = new Foo();
const String messageId = "one-id";
const Int64 timestamp = 123456789L;
var args = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
MessageId = messageId,
Timestamp = new AmqpTimestamp(timestamp)
}
};
var message = new FakeConsumedMessage(content, args);
var actual = message.As<Foo>();
Assert.Equal(messageId, actual.Headers.MessageId);
Assert.Equal(timestamp, actual.Headers.Timestamp);
}
public void OnSuccess()
{
var inboundChannel = new Mock<IInboundChannel>();
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(new Object(), args);
var strategy = new Mock<IFallbackStrategy>();
_configuration.FallbackBy((c, q) => strategy.Object);
var builder = new Mock<IConsumedMessageBuilder>();
builder.Setup(_ => _.Build(args)).Returns(message);
var outboundChannel = new Mock<IOutboundChannel>().Object;
var consumer = new AtLeastOnceConsumer(inboundChannel.Object,
outboundChannel,
default(Queue),
builder.Object,
_configuration);
var result = consumer.ConsumeAsync(args).Result;
Assert.IsType<Success>(result);
strategy.Verify(_ => _.Apply(outboundChannel, message), Times.Never);
}
public void OnReiteratedError()
{
var inboundChannel = new Mock<IInboundChannel>();
var strategy = new Mock<IFallbackStrategy>();
var args = FakeBasicDeliverEventArgs();
args.Redelivered = true;
var message = new FakeConsumedMessage(new Object(), args);
_configuration.FallbackBy((c, q) => strategy.Object);
_configuration.Consumes(new FakeConsumer(consumedMessage => { throw new Exception(); }));
var builder = new Mock<IConsumedMessageBuilder>();
builder.Setup(_ => _.Build(args)).Returns(message);
var outboundChannel = new Mock<IOutboundChannel>().Object;
var consumer = new AtLeastOnceConsumerWrapper(inboundChannel.Object,
outboundChannel,
default(Queue),
builder.Object,
_configuration);
var result = consumer.CallConsumeInternalAsync(args).Result;
Assert.IsType<ReiteratedConsumingFailure>(result);
strategy.Verify(_ => _.Apply(outboundChannel, message), Times.Once);
}
private static Mock<IInboundChannel> BuildInboundChannel(UInt64 deliveryTag,
Func<ConsumedMessageBase, AggregateConsumingResult> func,
ConsumingConfiguration configuration)
{
var args = new BasicDeliverEventArgs
{
DeliveryTag = deliveryTag,
BasicProperties = new BasicProperties()
};
var builder = new Mock<IConsumedMessageBuilder>();
var message = new FakeConsumedMessage(args, func);
builder.Setup(_ => _.Build(args)).Returns(message);
var channel = new Mock<IInboundChannel>();
var consumer = new AtLeastOnceConsumerWrapper(channel.Object,
new Mock<IOutboundChannel>().Object,
default(Queue),
builder.Object,
configuration);
consumer.CallConsumeInternal(args).Wait();
return channel;
}
public void WrongContentType()
{
var content = new Foo();
var message = new FakeConsumedMessage(content, FakeBasicDeliverEventArgs());
Assert.Throws<InvalidCastException>(() => message.As<Bar>());
}
public void DeadLetterExchangeStrategy()
{
var args = FakeBasicDeliverEventArgs();
var message = new FakeConsumedMessage(null, args);
var broker = new Mock<IBroker>();
var queue = new Queue("queue_name");
Func<String, String> f = _ => $"{_}-DeadLetter";
var dleName = f(queue.Name);
broker.Setup(_ => _.DeclareDurableDirectExchange(dleName)).Returns(new Exchange(dleName, "direct"));
var strategy = DeadLetterStrategy.New(broker.Object,
queue,
_ => $"{_}-DeadLetter");
var outboundChannel = new Mock<IOutboundChannel>();
strategy.Apply(outboundChannel.Object, message);
outboundChannel.Verify(_ => _.ForwardAsync(message,
It.Is<Exchange>(__ => __.Name == dleName),
String.Empty),
Times.Once);
}
