public async Task Can_Remove_Encryption()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration { ServerSideEncryption = new ServerSideEncryption() });
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration { ServerSideEncryption = null });
// Assert
queue.ServerSideEncryption.ShouldBeNull();
}
public async Task Can_Update_Delivery_Delay()
{
// Arrange
var oldDeliveryDelay = TimeSpan.FromMinutes(2);
var newDeliveryDelay = TimeSpan.FromMinutes(5);
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration()
{
DeliveryDelay = oldDeliveryDelay
});
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration()
{
DeliveryDelay = newDeliveryDelay
});
// Assert
queue.DeliveryDelay.ShouldBe(newDeliveryDelay);
}
public async Task Then_The_Error_Queue_Is_Not_Created()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
// Act
await queue.CreateAsync(new SqsBasicConfiguration()
{
ErrorQueueOptOut = true
});
// Assert
await Patiently.AssertThatAsync(
OutputHelper, async() => !await queue.ErrorQueue.ExistsAsync(CancellationToken.None));
}
public async Task Can_Update_Redrive_Policy()
{
// Arrange
int maximumReceives = 42;
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(new SqsBasicConfiguration());
// Act
await queue.UpdateRedrivePolicyAsync(
new RedrivePolicy(maximumReceives, queue.ErrorQueue.Arn));
// Assert
queue.RedrivePolicy.ShouldNotBeNull();
queue.RedrivePolicy.MaximumReceives.ShouldBe(maximumReceives);
}
public async Task Then_The_Message_Retention_Period_Is_Updated()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new ErrorQueue(
Region,
UniqueName,
client,
loggerFactory);
var queueConfig = new SqsBasicConfiguration()
{
ErrorQueueRetentionPeriod = JustSayingConstants.MaximumRetentionPeriod,
ErrorQueueOptOut = true,
};
// Act
await queue.CreateAsync(queueConfig);
queueConfig.ErrorQueueRetentionPeriod = TimeSpan.FromSeconds(100);
await queue.UpdateQueueAttributeAsync(queueConfig, CancellationToken.None);
// Assert
queue.MessageRetentionPeriod.ShouldBe(TimeSpan.FromSeconds(100));
}
public async Task Can_Update_Retention_Period()
{
// Arrange
var oldRetentionPeriod = TimeSpan.FromSeconds(600);
var newRetentionPeriod = TimeSpan.FromSeconds(700);
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
await queue.CreateAsync(
new SqsBasicConfiguration { MessageRetention = oldRetentionPeriod });
// Act
await queue.UpdateQueueAttributeAsync(
new SqsBasicConfiguration { MessageRetention = newRetentionPeriod }, CancellationToken.None);
// Assert
queue.MessageRetentionPeriod.ShouldBe(newRetentionPeriod);
}
public async Task CanSubscribeUsingQueueArn()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var snsClient = clientFactory.GetSnsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var anotherUniqueName = $"{Guid.NewGuid():N}-integration-tests";
var topicResponse = await snsClient.CreateTopicAsync(anotherUniqueName);
var subscriptionArn = await snsClient.SubscribeQueueAsync(topicResponse.TopicArn, sqsClient, queueResponse.QueueUrl);
var queueArn = (await sqsClient.GetQueueAttributesAsync(queueResponse.QueueUrl, new List <string> {
SQSConstants.ATTRIBUTE_QUEUE_ARN
})).Attributes[SQSConstants.ATTRIBUTE_QUEUE_ARN];
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueArn <SimpleMessage>(queueArn))
.Publications(c =>
c.WithTopicArn <SimpleMessage>(topicResponse.TopicArn)
)
)
.AddJustSayingHandlers(new[] { handler });
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
public async Task CanPublishUsingQueueUrl()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueUrl <SimpleMessage>(queueResponse.QueueUrl))
.Publications(c =>
c.WithQueueUrl <SimpleMessage>(queueResponse.QueueUrl)
)
)
.AddJustSayingHandlers(new[] { handler });
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
public async Task Then_The_Error_Queue_Is_Created()
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
1,
loggerFactory);
// Act
await queue.CreateAsync(new SqsBasicConfiguration());
// Assert
await Patiently.AssertThatAsync(
async() => await queue.ErrorQueue.ExistsAsync(),
40.Seconds());
}
public async Task Messages_Are_Throttled_But_Still_Delivered(int throttleMessageCount)
{
// Arrange
ILoggerFactory loggerFactory = OutputHelper.ToLoggerFactory();
IAwsClientFactory clientFactory = CreateClientFactory();
int retryCountBeforeSendingToErrorQueue = 1;
var client = clientFactory.GetSqsClient(Region);
var queue = new SqsQueueByName(
Region,
UniqueName,
client,
retryCountBeforeSendingToErrorQueue,
loggerFactory);
if (!await queue.ExistsAsync(CancellationToken.None))
{
await queue.CreateAsync(new SqsBasicConfiguration());
if (!IsSimulator)
{
// Wait for up to 60 secs for queue creation to be guaranteed completed by AWS
using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
while (!cts.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(2));
if (await queue.ExistsAsync(CancellationToken.None))
{
break;
}
}
}
}
Assert.True(await queue.ExistsAsync(CancellationToken.None), "The queue was not created.");
OutputHelper.WriteLine($"{DateTime.Now} - Adding {throttleMessageCount} messages to the queue.");
var entriesAdded = 0;
// Add some messages
do
{
var entries = new List <SendMessageBatchRequestEntry>();
for (int j = 0; j < 10; j++)
{
var batchEntry = new SendMessageBatchRequestEntry
{
MessageBody = $"{{\"Subject\":\"SimpleMessage\", \"Message\": {{ \"Content\": \"{entriesAdded}\"}}}}",
Id = Guid.NewGuid().ToString()
};
entries.Add(batchEntry);
entriesAdded++;
}
await client.SendMessageBatchAsync(queue.Uri.AbsoluteUri, entries);
}while (entriesAdded < throttleMessageCount);
OutputHelper.WriteLine($"{DateTime.Now} - Done adding messages.");
int count = 0;
var handler = Substitute.For <IHandlerAsync <SimpleMessage> >();
handler.Handle(Arg.Any <SimpleMessage>())
.ReturnsForAnyArgs(true)
.AndDoes((_) => Interlocked.Increment(ref count));
IServiceCollection services = GivenJustSaying(LogLevel.Warning)
.ConfigureJustSaying((builder) => builder.WithLoopbackQueue <SimpleMessage>(UniqueName))
.AddSingleton(handler);
TimeSpan timeToProcess = TimeSpan.Zero;
// Act
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
var stopwatch = Stopwatch.StartNew();
var delay = IsSimulator ? TimeSpan.FromMilliseconds(100) : TimeSpan.FromSeconds(5);
await listener.StartAsync(cancellationToken);
do
{
await Task.Delay(delay, cancellationToken);
OutputHelper.WriteLine($"{DateTime.Now} - Handled {count} messages. Waiting for completion.");
}while (count < throttleMessageCount && !cancellationToken.IsCancellationRequested);
stopwatch.Stop();
timeToProcess = stopwatch.Elapsed;
});
// Assert
OutputHelper.WriteLine($"{DateTime.Now} - Handled {count:N0} messages.");
OutputHelper.WriteLine($"{DateTime.Now} - Took {timeToProcess.TotalMilliseconds} ms");
OutputHelper.WriteLine($"{DateTime.Now} - Throughput {(float)count / timeToProcess.TotalMilliseconds * 1000} messages/second");
Assert.Equal(throttleMessageCount, count);
}
