public async Task When_Publish_Given_PerMessageScopeDisabled_Then_TheScopeIsNotCreatedAndConsumerObtainedFromRoot()
{
// arrange
var consumerMock = new Mock <SomeMessageAConsumer>();
_dependencyResolverMock.Setup(x => x.Resolve(typeof(SomeMessageAConsumer))).Returns(() => consumerMock.Object);
const string topic = "topic-a";
_settings.Producers.Add(Producer(typeof(SomeMessageA), topic));
var consumerSettings = Consumer(typeof(SomeMessageA), topic, typeof(SomeMessageAConsumer));
consumerSettings.IsDisposeConsumerEnabled = true;
_settings.Consumers.Add(consumerSettings);
_settings.IsMessageScopeEnabled = false;
_providerSettings.EnableMessageSerialization = false;
var m = new SomeMessageA();
// act
await _subject.Value.Publish(m);
// assert
_dependencyResolverMock.Verify(x => x.Resolve(typeof(ILoggerFactory)), Times.Once);
_dependencyResolverMock.Verify(x => x.CreateScope(), Times.Never);
_dependencyResolverMock.Verify(x => x.Resolve(typeof(SomeMessageAConsumer)), Times.Once);
_dependencyResolverMock.VerifyNoOtherCalls();
consumerMock.Verify(x => x.OnHandle(m, topic), Times.Once);
consumerMock.Verify(x => x.Dispose(), Times.Once);
consumerMock.VerifyNoOtherCalls();
}
public void When_Publish_Given_MessageSerializationSetting_Then_DeliversMessageInstanceToRespectiveConsumers(bool enableMessageSerialization)
{
// arrange
const string topicA = "topic-a";
const string topicA2 = "topic-a-2";
const string topicB = "topic-b";
_settings.Producers.Add(Producer(typeof(SomeMessageA), topicA));
_settings.Producers.Add(Producer(typeof(SomeMessageB), topicB));
_settings.Consumers.Add(Consumer(typeof(SomeMessageA), topicA, typeof(SomeMessageAConsumer)));
_settings.Consumers.Add(Consumer(typeof(SomeMessageA), topicA2, typeof(SomeMessageAConsumer2)));
_settings.Consumers.Add(Consumer(typeof(SomeMessageB), topicB, typeof(SomeMessageBConsumer)));
var aConsumerMock = new Mock <SomeMessageAConsumer>();
var aConsumer2Mock = new Mock <SomeMessageAConsumer2>();
var bConsumerMock = new Mock <SomeMessageBConsumer>();
_dependencyResolverMock.Setup(x => x.Resolve(typeof(SomeMessageAConsumer))).Returns(aConsumerMock.Object);
_dependencyResolverMock.Setup(x => x.Resolve(typeof(SomeMessageAConsumer2))).Returns(aConsumer2Mock.Object);
_dependencyResolverMock.Setup(x => x.Resolve(typeof(SomeMessageBConsumer))).Returns(bConsumerMock.Object);
_providerSettings.EnableMessageSerialization = enableMessageSerialization;
var m = new SomeMessageA();
// act
_subject.Value.Publish(m).Wait();
// assert
if (enableMessageSerialization)
{
aConsumerMock.Verify(x => x.OnHandle(It.Is <SomeMessageA>(a => a.Equals(m)), topicA), Times.Once);
}
else
{
aConsumerMock.Verify(x => x.OnHandle(m, topicA), Times.Once);
}
aConsumerMock.VerifyNoOtherCalls();
aConsumer2Mock.Verify(x => x.OnHandle(It.IsAny <SomeMessageA>(), topicA2), Times.Never);
aConsumer2Mock.VerifyNoOtherCalls();
bConsumerMock.Verify(x => x.OnHandle(It.IsAny <SomeMessageB>(), topicB), Times.Never);
bConsumerMock.VerifyNoOtherCalls();
}
protected bool Equals(SomeMessageA other)
{
return(Value.Equals(other.Value));
}
