public void When_max_size_is_exceeded_shrink()
{
//Arrange
const int limit = 5;
var outbox = new InMemoryOutbox()
{
EntryLimit = limit,
CompactionPercentage = 0.5
};
for (int i = 1; i <= limit; i++)
{
outbox.Add(new MessageTestDataBuilder());
}
//Act
outbox.EntryCount.Should().Be(5);
outbox.Add(new MessageTestDataBuilder());
Task.Delay(500).Wait(); //Allow time for compaction to run
//should clear compaction percentage from the outbox, and then add the new one
outbox.EntryCount.Should().Be(3);
}
public void When_shrinking_evict_oldest_messages_first()
{
//Arrange
const int limit = 5;
var outbox = new InMemoryOutbox()
{
EntryLimit = limit,
CompactionPercentage = 0.5
};
var messageIds = new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
for (int i = 0; i <= limit - 1; i++)
{
outbox.Add(new MessageTestDataBuilder().WithId(messageIds[i]));
Task.Delay(1000);
}
//Act
outbox.EntryCount.Should().Be(5);
outbox.Add(new MessageTestDataBuilder());
Task.Delay(500).Wait(); //Allow time for compaction to run
//should clear compaction percentage from the outbox, and then add the new one
outbox.Get(messageIds[0]).Should().BeNull();
outbox.Get(messageIds[1]).Should().BeNull();
outbox.Get(messageIds[2]).Should().BeNull();
outbox.Get(messageIds[3]).Should().NotBeNull();
outbox.Get(messageIds[4]).Should().NotBeNull();
}
public void When_outstanding_in_outbox_they_are_retrieved_correctly()
{
var minimumAgeInMs = 500;
var outbox = new InMemoryOutbox();
outbox.Add(new MessageTestDataBuilder());
outbox.Add(new MessageTestDataBuilder());
Thread.Sleep(minimumAgeInMs);
outbox.Add(new MessageTestDataBuilder());
outbox.Add(new MessageTestDataBuilder());
var messagesToDispatch = outbox.OutstandingMessages(minimumAgeInMs);
var allMessages = outbox.OutstandingMessages(0);
foreach (var message in messagesToDispatch)
{
outbox.MarkDispatched(message.Id);
}
var messagesAfterDispatch = outbox.OutstandingMessages(minimumAgeInMs);
Assert.Equal(2, messagesToDispatch.Count());
Assert.Equal(4, allMessages.Count());
Assert.Empty(messagesAfterDispatch);
}
public void When_over_ttl_but_no_sweep_run()
{
//Arrange
var outbox = new InMemoryOutbox()
{
//set low time to live but long sweep perioc
EntryTimeToLive = TimeSpan.FromMilliseconds(50),
ExpirationScanInterval = TimeSpan.FromMilliseconds(10000)
};
var messageId = Guid.NewGuid();
var messageToAdd = new Message(
new MessageHeader(messageId, "test_topic", MessageType.MT_DOCUMENT),
new MessageBody("message body"));
//Act
outbox.Add(messageToAdd);
Task.Delay(50).Wait(); //TTL has passed, but not expired yet
var message = outbox.Get(messageId);
//Assert
message.Should().NotBeNull();
message.Id.Should().Be(messageId);
}
public async Task When_outstanding_in_outbox_sweep_clears_them_async()
{
//Arrange
const int milliSecondsSinceSent = 500;
var outbox = new InMemoryOutbox();
var commandProcessor = new FakeCommandProcessor();
var sweeper = new OutboxSweeper(milliSecondsSinceSent, commandProcessor);
var messages = new Message[] { new MessageTestDataBuilder(), new MessageTestDataBuilder(), new MessageTestDataBuilder() };
foreach (var message in messages)
{
outbox.Add(message);
commandProcessor.Post(message.ToStubRequest());
}
//Act
await Task.Delay(milliSecondsSinceSent * 2); // -- let the messages expire
sweeper.SweepAsyncOutbox();
await Task.Delay(200);
//Assert
outbox.EntryCount.Should().Be(3);
commandProcessor.Dispatched.Count.Should().Be(3);
commandProcessor.Deposited.Count.Should().Be(3);
}
public void When_expiring_a_cache_entry_no_longer_there()
{
//Arrange
var outbox = new InMemoryOutbox()
{
//set some aggressive outbox reclamation times for the test
EntryTimeToLive = TimeSpan.FromMilliseconds(50),
ExpirationScanInterval = TimeSpan.FromMilliseconds(100)
};
var messageId = Guid.NewGuid();
var messageToAdd = new Message(
new MessageHeader(messageId, "test_topic", MessageType.MT_DOCUMENT),
new MessageBody("message body"));
//Act
outbox.Add(messageToAdd);
Task.Delay(500).Wait(); //give the entry to time to expire
//Trigger a cache clean
outbox.Get(messageId);
Task.Delay(500).Wait(); //Give the sweep time to run
var message = outbox.Get(messageId);
//Assert
message.Should().BeNull();
}
public void When_there_are_multiple_items_and_some_are_dispatched()
{
//Arrange
var outbox = new InMemoryOutbox();
var messageIds = new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), };
for (int i = 0; i <= 4; i++)
{
outbox.Add(new MessageTestDataBuilder().WithId(messageIds[i]));
}
//Act
var now = DateTime.UtcNow;
outbox.MarkDispatched(messageIds[0], now);
outbox.MarkDispatched(messageIds[4], now);
Task.Delay(500).Wait();
var sentMessages = outbox.DispatchedMessages(5000);
var outstandingMessages = outbox.OutstandingMessages(0);
//Assert
sentMessages.Count().Should().Be(2);
outstandingMessages.Count().Should().Be(3);
sentMessages.Any(msg => msg.Id == messageIds[0]).Should().BeTrue();
sentMessages.Any(msg => msg.Id == messageIds[4]).Should().BeTrue();
outstandingMessages.Any(msg => msg.Id == messageIds[1]).Should().BeTrue();
outstandingMessages.Any(msg => msg.Id == messageIds[2]).Should().BeTrue();
outstandingMessages.Any(msg => msg.Id == messageIds[3]).Should().BeTrue();
}
public void When_paging_a_list_of_messages()
{
//Arrange
var outbox = new InMemoryOutbox();
for (int i = 0; i <= 8; i++) // -- nine items
{
outbox.Add(new MessageTestDataBuilder());
}
//Act
var firstPage = outbox.Get(5, 1);
var secondPage = outbox.Get(5, 2);
//Assert
firstPage.Count().Should().Be(5);
secondPage.Count().Should().Be(4); // -- only 4 on the second page
}
public void When_there_are_multiple_items_retrieve_by_id()
{
//Arrange
var outbox = new InMemoryOutbox();
var messageIds = new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), };
for (int i = 0; i <= 4; i++)
{
outbox.Add(new MessageTestDataBuilder().WithId(messageIds[i]));
}
//Act
var message = outbox.Get(messageIds[2]);
//Assert
message.Id.Should().Be(messageIds[2]);
}
public void When_looking_for_undispatched_messages_in_outbox()
{
//Arrange
var outbox = new InMemoryOutbox();
var messageId = Guid.NewGuid();
var messageToAdd = new Message(
new MessageHeader(messageId, "test_topic", MessageType.MT_DOCUMENT),
new MessageBody("message body"));
//Act
outbox.Add(messageToAdd);
var outstandingMessages = outbox.OutstandingMessages(0);
//Assert
outstandingMessages.Count().Should().Be(1);
outstandingMessages.First().Id.Should().Be(messageId);
}
public void When_marking_dispatched_in_outbox()
{
//Arrange
var outbox = new InMemoryOutbox();
var messageId = Guid.NewGuid();
var messageToAdd = new Message(
new MessageHeader(messageId, "test_topic", MessageType.MT_DOCUMENT),
new MessageBody("message body"));
//Act
outbox.Add(messageToAdd);
var dispatchedAt = DateTime.Now;
outbox.MarkDispatched(messageId, dispatchedAt);
var dispatchedMessages = outbox.DispatchedMessages(500);
//Assert
dispatchedMessages.Count().Should().Be(1);
dispatchedMessages.First().Id.Should().Be(messageId);
}
public void When_reading_from_outbox()
{
//Arrange
var outbox = new InMemoryOutbox();
var messageId = Guid.NewGuid();
var messageToAdd = new Message(
new MessageHeader(messageId, "test_topic", MessageType.MT_DOCUMENT),
new MessageBody("message body"));
//Act
outbox.Add(messageToAdd);
var retrievedMessage = outbox.Get(messageId);
//Assert
retrievedMessage.Should().NotBeNull();
retrievedMessage.Id.Should().Be(messageId);
retrievedMessage.Header.Topic.Should().Be(messageToAdd.Header.Topic);
retrievedMessage.Header.MessageType.Should().Be(messageToAdd.Header.MessageType);
retrievedMessage.Body.Value.Should().Be(messageToAdd.Body.Value);
}
public void When_too_new_to_sweep_leaves_them()
{
//Arrange
const int milliSecondsSinceSent = 500;
var outbox = new InMemoryOutbox();
var commandProcessor = new FakeCommandProcessor();
var sweeper = new OutboxSweeper(milliSecondsSinceSent, outbox, commandProcessor);
var messages = new Message[] { new MessageTestDataBuilder(), new MessageTestDataBuilder(), new MessageTestDataBuilder() };
foreach (var message in messages)
{
outbox.Add(message);
commandProcessor.Post(message.ToStubRequest());
}
//Act
sweeper.Sweep();
//Assert
commandProcessor.Dispatched.Count.Should().Be(3);
commandProcessor.Posted.Count.Should().Be(0);
}