public async Task Mock_ShouldListQueues_WhenClientAvailable()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
var queues = await client.ListQueuesAsync();
Assert.NotNull(queues);
}
public async Task MockStartMessageReceiver_ShouldRetrieveMessageWithSyncProcessor_WhenQueueAndMessageExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
await client.SendMessageAsync("Hello World!", FifoQueueName);
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
message =>
{
Assert.Equal("Hello World!", message);
_messagePicked = true;
return(true);
}, cancellationToken);
await client.AwaitMessageProcessedAttempt(FifoQueueName);
cancellationTokenSource.Cancel();
Assert.True(_messagePicked);
_messagePicked = false;
}
public async Task MockCreateStandardFifoQueueAsync_ShouldReturnQueueUrl_WhenCreatingFifoQueue()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
var queueUrl = await client.CreateStandardFifoQueueAsync("test.fifo");
Assert.Equal("https://mockRegion/queue/test.fifo", queueUrl);
}
public async Task MockSendMessageBatchAsync_ShouldPutAMessageOnTheQueue_WhenQueueExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
var batch = new List <BatchMessageRequest>
{
new BatchMessageRequest("testMessage1"),
new BatchMessageRequest("testMessage2", new Dictionary <string, string>
{
{ "key2", "value2" }
})
}.ToArray();
var response = await client.SendMessageBatchAsync(batch, FifoQueueName);
Assert.Empty(response.GetFailed());
Assert.Equal(2, response.GetSuccessful().Length);
Assert.True(response.Success);
Assert.True(response.SendResults[0].Success);
Assert.Equal("testMessage1", response.SendResults[0].MessageRequest.Message);
Assert.Null(response.SendResults[0].Error);
Assert.True(response.SendResults[1].Success);
Assert.Equal("testMessage2", response.SendResults[1].MessageRequest.Message);
Assert.Equal("value2", response.SendResults[1].MessageRequest.MessageAttributes["key2"]);
Assert.Null(response.SendResults[1].Error);
}
public async Task MockPollQueueWithRetryAsync_ShouldThrowQueueDoesNotExistException_WhenQueueDoesNotExist()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await Assert.ThrowsAsync <QueueDoesNotExistException>(() =>
client.PollQueueWithRetryAsync("mockQueue.fifo", 1, 1, 3, 1, 1, message => true));
}
public async Task AwaitMessageProcessedAttempt_ShouldAwaitMessageProcessingBeforeReturning()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
var batch = new List <BatchMessageRequest>
{
new BatchMessageRequest("Hello World!")
}.ToArray();
var response = await client.SendMessageBatchAsync(batch, FifoQueueName);
var receivedTask = client.AwaitMessageProcessedAttempt(FifoQueueName);
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
message =>
{
Assert.Equal("Hello World!", message);
return(true);
}, new CancellationToken());
await receivedTask;
var messages = client.GetMessages(FifoQueueName);
Assert.Empty(messages);
}
public async Task AwaitMessageProcessedAttempt_ShouldWaitUntilMessageProcessorHasBeenCalled_WhenMessageProcessorFails()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
async(message) =>
{
await Task.Delay(1000);
return(false);
}, cancellationToken);
await client.SendMessageAsync("Hello World!", FifoQueueName);
var stopwatch = new Stopwatch();
stopwatch.Start();
await client.AwaitMessageProcessedAttempt(FifoQueueName);
stopwatch.Stop();
Assert.True(stopwatch.ElapsedMilliseconds > 900);
}
public async Task MockQueue_ShouldNotRemoveMessageFromQueue_IfFalseIsReturned()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
await client.SendMessageAsync("Hello World!", FifoQueueName);
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
async(message) =>
{
Assert.Single(client.GetMessages(FifoQueueName));
Assert.True(client.GetMessages(FifoQueueName).First().IsLocked);
Assert.Equal("Hello World!", message);
_messagePicked = true;
return(await Task.FromResult(false));
}, cancellationToken);
await client.AwaitMessageProcessedAttempt(FifoQueueName);
cancellationTokenSource.Cancel();
Assert.True(_messagePicked);
Assert.Single(client.GetMessages(FifoQueueName));
Assert.False(client.GetMessages(FifoQueueName).First().IsLocked);
_messagePicked = false;
}
public async Task MockSendMessageAsync_ShouldPutAMessageOnTheQueue_WhenQueueExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync("mockQueue.fifo");
var messageId = await client.SendMessageAsync("Hello World!", "mockQueue.fifo");
Assert.NotNull(messageId);
}
public void MockStartMessageReceiver_ShouldThrowQueueDoesNotExistException_WhenQueueDoesNotExist()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
Assert.ThrowsAsync <QueueDoesNotExistException>(() =>
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
message => true, cancellationToken));
}
public async Task GetNumberOfMessagesOnQueue_ShouldReturnNumberOfMessagesOnQueue_WhenMessageExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
await client.SendMessageAsync("Foo", FifoQueueName);
var actual = await client.GetNumberOfMessagesOnQueue(FifoQueueName);
Assert.Equal(FifoQueueName, actual.QueueName);
Assert.Equal(1, actual.ApproximateNumberOfMessages);
}
public async Task MockGetMessagesOnQueue_ShouldContainSentMessage_WhenQueueExists()
{
var queueName = "mockQueue.fifo";
var messageContents = "Hello World!";
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(queueName);
await client.SendMessageAsync(messageContents, queueName);
var actual = client.GetMessages(queueName);
Assert.Equal(1, actual.Count);
Assert.Equal(messageContents, actual.First());
}
public async Task MockDeleteQueue_ShouldDeleteQueue_IfQueueExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync("mockQueue.fifo");
var queuesOnClientBeforeDeletion = await client.ListQueuesAsync();
await client.DeleteQueueAsync("mockQueue.fifo");
var queuesOnClientAfterDeletion = await client.ListQueuesAsync();
Assert.Equal(1, queuesOnClientBeforeDeletion.Count);
Assert.Equal(0, queuesOnClientAfterDeletion.Count);
}
public async Task MockDeleteQueue_ShouldDeleteQueue_IfQueueExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
var queuesOnClientBeforeDeletion = await client.ListQueuesAsync();
await client.DeleteQueueAsync(FifoQueueName);
var queuesOnClientAfterDeletion = await client.ListQueuesAsync();
Assert.Single(queuesOnClientBeforeDeletion);
Assert.Empty(queuesOnClientAfterDeletion);
}
public async Task SQSMessage_ShouldNotRemoveMessageFromQueue_WhenNotAcked()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync(FifoQueueName);
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
client.StartMessageReceiver(FifoQueueName, new MessageReceiverOptions(),
async(ISQSMessage message) => { Assert.Equal("Bar", message.Body); }, cancellationToken);
await client.SendMessageAsync("Bar", FifoQueueName);
await client.AwaitMessageProcessedAttempt(FifoQueueName);
cancellationTokenSource.Cancel();
Assert.Single(client.GetMessages(FifoQueueName));
}
public async Task MockPollQueueAsync_ShouldRetrieveMessageWithAsyncProcessor_WhenQueueAndMessageExists()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await client.CreateStandardFifoQueueAsync("mockQueue.fifo");
await client.SendMessageAsync("Hello World!", "mockQueue.fifo");
var cancellationToken = client.PollQueueAsync("mockQueue.fifo", 1, 1, async(message) =>
{
Assert.Equal("Hello World!", message);
_messagePicked = true;
return(await Task.FromResult(true));
});
Task.Delay(1000).Wait();
cancellationToken.Cancel();
Assert.True(_messagePicked);
_messagePicked = false;
}
public async Task MockSendMessageAsync_ShouldThrowQueueDoesNotExistException_WhenQueueDoesNotExist()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await Assert.ThrowsAsync <QueueDoesNotExistException>(() => client.SendMessageAsync("test", "test"));
}
public async Task MockCreateStandardFifoQueueAsync_ShouldThrowArgumentException_WhenQueueNameDoesNotEndWithFifo()
{
var client = new SQSClientMock("mockEndpoint", "mockRegion");
await Assert.ThrowsAsync <ArgumentException>(() => client.CreateStandardFifoQueueAsync("test"));
}
