public async Task OnMessageReceivedSadPath2()
{
var mockReceiver = new Mock <IReceiver>()
.SetupProperty(m => m.MessageHandler);
var mockDatabase = new Mock <IDatabase>();
var service = new ExampleService(mockReceiver.Object, mockDatabase.Object);
await service.StartAsync(CancellationToken.None);
var fakeMessage = new FakeReceiverMessage("MyPayload")
{
Headers = { ["operation"] = "invalid" }
};
await service.Receiver.MessageHandler.OnMessageReceivedAsync(mockReceiver.Object, fakeMessage);
fakeMessage.HandledBy.Should().Be(nameof(fakeMessage.RejectAsync));
mockDatabase.Verify(m => m.CreateAsync("MyPayload"), Times.Never());
mockDatabase.Verify(m => m.UpdateAsync("MyPayload"), Times.Never());
mockDatabase.Verify(m => m.DeleteAsync("MyPayload"), Times.Never());
// TODO: Verify that the error log was sent
}
public async Task DataReceivedAsyncHappyPath()
{
// Arrange
var dataReceiver = GetMockReceiver(ReceivingService.DataReceiverName).Object;
var commandReceiver = GetMockReceiver(ReceivingService.CommandReceiverName).Object;
var mockReceivingService = new Mock <ReceivingService>(GetReceiverLookup(dataReceiver, commandReceiver));
mockReceivingService.Protected().As <IProtected>()
.Setup(m => m.WriteLine(It.IsAny <string>()))
.Verifiable();
mockReceivingService.Protected().As <IProtected>()
.Setup(m => m.FormatMessage(It.IsAny <string>()))
.Returns("formatted-message")
.Verifiable();
var receivingService = mockReceivingService.Object.Unlock();
var message = new FakeReceiverMessage("test-message");
// Act
await receivingService.DataReceivedAsync(message);
// Assert
mockReceivingService.Protected().As <IProtected>()
.Verify(m => m.WriteLine("formatted-message"), Times.Once());
mockReceivingService.Protected().As <IProtected>()
.Verify(m => m.FormatMessage("test-message"), Times.Once());
message.HandledBy.Should().Be(nameof(message.AcknowledgeAsync));
}
public async Task HappyPathNewSetting()
{
var receiver = new FakeReceiver("fake");
MessagingConfigurationProvider provider = typeof(MessagingConfigurationProvider).New(receiver, null);
var newSettings = @"{
""foo"": ""abc""
}";
var message = new FakeReceiverMessage(newSettings);
var reloaded = false;
ChangeToken.OnChange(provider.GetReloadToken, () => reloaded = true);
var dataBefore = GetData(provider);
// Simulate the FakeReceiver receiving a message.
await receiver.MessageHandler.OnMessageReceivedAsync(receiver, message);
// The protected Data property should have been replaced.
GetData(provider).Should().NotBeSameAs(dataBefore);
// Data should contain the new settings.
GetData(provider).Should().ContainKey("foo");
GetData(provider)["foo"].Should().Be("abc");
// It should report that it has been reloaded.
reloaded.Should().BeTrue();
// The received message should have been handled by acknowledging it.
message.Handled.Should().BeTrue();
message.HandledBy.Should().Be(nameof(message.AcknowledgeAsync));
}
public async Task InvalidMessage()
{
var receiver = new FakeReceiver("fake");
MessagingConfigurationProvider provider = typeof(MessagingConfigurationProvider).New(receiver, null);
var reloaded = false;
ChangeToken.OnChange(provider.GetReloadToken, () => reloaded = true);
var newSettings = "This is {not] a [valid} JSON string: \"";
var message = new FakeReceiverMessage(newSettings);
var dataBefore = GetData(provider);
// Simulate the FakeReceiver receiving a message.
await receiver.MessageHandler.OnMessageReceivedAsync(receiver, message);
// The protected Data property should not have been replaced.
GetData(provider).Should().BeSameAs(dataBefore);
// It should report that it has been reloaded.
reloaded.Should().BeFalse();
// The received message should have been handled by acknowledging it.
message.Handled.Should().BeTrue();
message.HandledBy.Should().Be(nameof(message.RejectAsync));
}
public async Task CommandReceivedAsyncHappyPath1(string stringPayload, Casing expectedCasing)
{
// Arrange
var dataReceiver = GetMockReceiver(ReceivingService.DataReceiverName).Object;
var commandReceiver = GetMockReceiver(ReceivingService.CommandReceiverName).Object;
var receivingService = new ReceivingService(GetReceiverLookup(dataReceiver, commandReceiver));
var message = new FakeReceiverMessage(stringPayload);
// Act
await receivingService.Unlock().CommandReceivedAsync(message);
// Assert
receivingService.Casing.Should().Be(expectedCasing);
message.HandledBy.Should().Be(nameof(message.AcknowledgeAsync));
}
public async Task ReplayMethodHappyPath2()
{
Func <IReceiverMessage, Task> capturedCallback = null;
Action <DateTime, DateTime?, Func <IReceiverMessage, Task>, string, string, bool, AutoOffsetReset> mockReplayEngineCallback =
(start, end, callback, topic, bootstrapServers, enableAutoOffsetStore, autoOffsetReset) =>
{
capturedCallback = callback;
};
var mockReplayEngine = new Mock <IReplayEngine>();
mockReplayEngine.Setup(m => m.Replay(It.IsAny <DateTime>(), It.IsAny <DateTime?>(), It.IsAny <Func <IReceiverMessage, Task> >(),
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <AutoOffsetReset>()))
.Returns(Task.CompletedTask)
.Callback(mockReplayEngineCallback);
var mockMessageHandler = new Mock <IMessageHandler>();
mockMessageHandler.Setup(m => m.OnMessageReceivedAsync(It.IsAny <IReceiver>(), It.IsAny <IReceiverMessage>()))
.Returns(Task.CompletedTask);
var receiver =
new KafkaReceiver("name", "one_topic", "groupId", "servers", true, AutoOffsetReset.Earliest, mockReplayEngine.Object);
receiver.MessageHandler = mockMessageHandler.Object;
var expectedStart = new DateTime(2020, 9, 3, 20, 22, 58, DateTimeKind.Local).ToUniversalTime();
var expectedEnd = new DateTime(2020, 9, 3, 20, 23, 19, DateTimeKind.Local).ToUniversalTime();
await receiver.Replay(expectedStart, expectedEnd, null);
mockReplayEngine.Verify(m =>
m.Replay(expectedStart, expectedEnd, It.IsAny <Func <IReceiverMessage, Task> >(), "one_topic", "servers", true, AutoOffsetReset.Earliest),
Times.Once());
capturedCallback.Should().NotBeNull();
var message = new FakeReceiverMessage("Hello, world!");
await capturedCallback(message);
mockMessageHandler.Verify(m => m.OnMessageReceivedAsync(receiver, message), Times.Once());
}
public async Task CommandReceivedAsyncHappyPath2()
{
// Arrange
var dataReceiver = GetMockReceiver(ReceivingService.DataReceiverName).Object;
var commandReceiver = GetMockReceiver(ReceivingService.CommandReceiverName).Object;
var receivingService = new ReceivingService(GetReceiverLookup(dataReceiver, commandReceiver));
var message = new FakeReceiverMessage("UnknownCasing");
// Assume
receivingService.Casing.Should().Be(Casing.Default);
// Act
await receivingService.Unlock().CommandReceivedAsync(message);
// Assert
receivingService.Casing.Should().Be(Casing.Default);
message.HandledBy.Should().Be(nameof(message.AcknowledgeAsync));
}
public async Task OnMessageReceivedHappyPath1()
{
var mockReceiver = new Mock <IReceiver>()
.SetupProperty(m => m.MessageHandler);
var mockDatabase = new Mock <IDatabase>();
var service = new ExampleService(mockReceiver.Object, mockDatabase.Object);
await service.StartAsync(CancellationToken.None);
var fakeMessage = new FakeReceiverMessage("MyPayload")
{
Headers = { ["operation"] = "create" }
};
await service.Receiver.MessageHandler.OnMessageReceivedAsync(mockReceiver.Object, fakeMessage);
mockDatabase.Verify(m => m.CreateAsync("MyPayload"), Times.Once());
fakeMessage.HandledBy.Should().Be(nameof(fakeMessage.AcknowledgeAsync));
mockDatabase.Verify(m => m.UpdateAsync("MyPayload"), Times.Never());
mockDatabase.Verify(m => m.DeleteAsync("MyPayload"), Times.Never());
}
