public async Task TestListAllQueueMessagesWithUpdates()
{
IQueueingService provider = CreateProvider();
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10))))
{
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
List <Task> postMessagesTasks = new List <Task>();
for (int i = 0; i < 28; i++)
{
postMessagesTasks.Add(provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i))));
}
await Task.Factory.ContinueWhenAll(postMessagesTasks.ToArray(), TaskExtrasExtensions.PropagateExceptions);
HashSet <int> locatedMessages = new HashSet <int>();
QueuedMessageList messages = await provider.ListMessagesAsync(queueName, null, null, true, false, cancellationTokenSource.Token);
foreach (QueuedMessage message in messages)
{
Assert.IsTrue(locatedMessages.Add(message.Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once.");
}
int deletedMessage = messages[0].Body.ToObject <SampleMetadata>().ValueA;
await provider.DeleteMessageAsync(queueName, messages[0].Id, null, cancellationTokenSource.Token);
while (messages.Count > 0)
{
QueuedMessageList tempList = await provider.ListMessagesAsync(queueName, messages.NextPageId, null, true, false, cancellationTokenSource.Token);
if (tempList.Count > 0)
{
Assert.IsTrue(locatedMessages.Add(tempList[0].Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once.");
await provider.DeleteMessageAsync(queueName, tempList[0].Id, null, cancellationTokenSource.Token);
}
messages = await provider.ListMessagesAsync(queueName, messages.NextPageId, null, true, false, cancellationTokenSource.Token);
foreach (QueuedMessage message in messages)
{
Assert.IsTrue(locatedMessages.Add(message.Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once.");
}
}
Assert.AreEqual(28, locatedMessages.Count);
for (int i = 0; i < 28; i++)
{
Assert.IsTrue(locatedMessages.Contains(i), "The message listing did not include message '{0}', which was in the queue when the listing started and still in it afterwards.", i);
}
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
}
public async Task TestQueueExists()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
Assert.IsTrue(await provider.QueueExistsAsync(queueName, cancellationTokenSource.Token));
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
Assert.IsFalse(await provider.QueueExistsAsync(queueName, cancellationTokenSource.Token));
}
public async Task CleanupTestQueues()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)));
QueueName queueName = CreateRandomQueueName();
ReadOnlyCollection <CloudQueue> allQueues = await ListAllQueuesAsync(provider, null, false, cancellationTokenSource.Token, null);
Task[] deleteTasks = Array.ConvertAll(allQueues.ToArray(), queue =>
{
Console.WriteLine("Deleting queue: {0}", queue.Name);
return(provider.DeleteQueueAsync(queue.Name, cancellationTokenSource.Token));
});
Task.WaitAll(deleteTasks);
}
public async Task TestListQueues()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
foreach (CloudQueue queue in await ListAllQueuesAsync(provider, null, true, cancellationTokenSource.Token, null))
{
Console.WriteLine("{0}: {1}", queue.Name, queue.Href);
}
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestPostQueueMessages()
{
IQueueingService provider = CreateProvider();
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10))))
{
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
JObject genericBody =
new JObject(
new JProperty("type", "generic"));
Message genericMessage = new Message(TimeSpan.FromMinutes(50), genericBody);
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token);
await provider.PostMessagesAsync(queueName, Enumerable.Empty <Message>(), cancellationTokenSource.Token);
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, genericMessage);
await provider.PostMessagesAsync(queueName, new[] { genericMessage }, cancellationTokenSource.Token);
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, genericMessage, genericMessage);
await provider.PostMessagesAsync(queueName, new[] { genericMessage, genericMessage }, cancellationTokenSource.Token);
Message <SampleMetadata> typedMessage = new Message <SampleMetadata>(TimeSpan.FromMinutes(40), new SampleMetadata(1, "Stuff!"));
await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token);
await provider.PostMessagesAsync <SampleMetadata>(queueName, Enumerable.Empty <Message <SampleMetadata> >(), cancellationTokenSource.Token);
await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token, typedMessage);
await provider.PostMessagesAsync <SampleMetadata>(queueName, new[] { typedMessage }, cancellationTokenSource.Token);
await provider.PostMessagesAsync <SampleMetadata>(queueName, cancellationTokenSource.Token, typedMessage, typedMessage);
await provider.PostMessagesAsync <SampleMetadata>(queueName, new[] { typedMessage, typedMessage }, cancellationTokenSource.Token);
ReadOnlyCollection <QueuedMessage> messages = await ListAllMessagesAsync(provider, queueName, null, true, true, cancellationTokenSource.Token, null);
Assert.IsNotNull(messages);
Assert.AreEqual(12, messages.Count);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
}
public async Task TestQueueClaims()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
QueueStatistics statistics;
using (Claim claim = await provider.ClaimMessageAsync(queueName, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(1), cancellationTokenSource.Token))
{
Assert.AreEqual(TimeSpan.FromMinutes(5), claim.TimeToLive);
Assert.IsNotNull(claim.Messages);
Assert.AreEqual(1, claim.Messages.Count);
statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(1, statistics.MessageStatistics.Claimed);
QueuedMessage message = await provider.GetMessageAsync(queueName, claim.Messages[0].Id, cancellationTokenSource.Token);
Assert.IsNotNull(message);
TimeSpan age = claim.Age;
await Task.Delay(TimeSpan.FromSeconds(2));
await claim.RefreshAsync(cancellationTokenSource.Token);
Assert.IsTrue(claim.Age >= age + TimeSpan.FromSeconds(2));
await claim.RenewAsync(TimeSpan.FromMinutes(10), cancellationTokenSource.Token);
Assert.AreEqual(TimeSpan.FromMinutes(10), claim.TimeToLive);
}
statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(0, statistics.MessageStatistics.Claimed);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestQueueStatistics()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
QueueStatistics statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.IsNotNull(statistics);
QueueMessagesStatistics messageStatistics = statistics.MessageStatistics;
Assert.IsNotNull(messageStatistics);
Assert.AreEqual(messageStatistics.Free, 0);
Assert.AreEqual(messageStatistics.Claimed, 0);
Assert.AreEqual(messageStatistics.Total, 0);
Assert.IsNull(messageStatistics.Oldest);
Assert.IsNull(messageStatistics.Newest);
Console.WriteLine("Statistics:");
Console.WriteLine();
Console.WriteLine(JsonConvert.SerializeObject(statistics, Formatting.Indented));
await provider.PostMessagesAsync(queueName, cancellationTokenSource.Token, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
statistics = await provider.GetQueueStatisticsAsync(queueName, cancellationTokenSource.Token);
Assert.IsNotNull(statistics);
messageStatistics = statistics.MessageStatistics;
Assert.IsNotNull(messageStatistics);
Assert.AreEqual(messageStatistics.Free, 1);
Assert.AreEqual(messageStatistics.Claimed, 0);
Assert.AreEqual(messageStatistics.Total, 1);
Assert.IsNotNull(messageStatistics.Oldest);
Assert.IsNotNull(messageStatistics.Newest);
Console.WriteLine("Statistics:");
Console.WriteLine();
Console.WriteLine(JsonConvert.SerializeObject(statistics, Formatting.Indented));
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestQueueMetadataDynamic()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
JObject metadata = new JObject(
new JProperty("valueA", 3),
new JProperty("valueB", "yes"));
await provider.SetQueueMetadataAsync(queueName, metadata, cancellationTokenSource.Token);
JObject result = await provider.GetQueueMetadataAsync(queueName, cancellationTokenSource.Token);
Assert.AreEqual(3, result["valueA"]);
Assert.AreEqual("yes", result["valueB"]);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestQueueMetadataStatic()
{
IQueueingService provider = CreateProvider();
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(10)));
QueueName queueName = CreateRandomQueueName();
await provider.CreateQueueAsync(queueName, cancellationTokenSource.Token);
SampleMetadata metadata = new SampleMetadata(3, "yes");
Assert.AreEqual(3, metadata.ValueA);
Assert.AreEqual("yes", metadata.ValueB);
await provider.SetQueueMetadataAsync(queueName, metadata, cancellationTokenSource.Token);
SampleMetadata result = await provider.GetQueueMetadataAsync <SampleMetadata>(queueName, cancellationTokenSource.Token);
Assert.AreEqual(metadata.ValueA, result.ValueA);
Assert.AreEqual(metadata.ValueB, result.ValueB);
await provider.DeleteQueueAsync(queueName, cancellationTokenSource.Token);
}
public async Task TestQueueMessages()
{
int clientCount = 3;
int serverCount = 2;
Assert.IsTrue(clientCount > 0);
Assert.IsTrue(serverCount > 0);
QueueName requestQueueName = CreateRandomQueueName();
QueueName[] responseQueueNames = Enumerable.Range(0, clientCount).Select(i => CreateRandomQueueName()).ToArray();
IQueueingService provider = CreateProvider();
CancellationTokenSource testCancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(300)));
Stopwatch initializationTimer = Stopwatch.StartNew();
Console.WriteLine("Creating request queue...");
await provider.CreateQueueAsync(requestQueueName, testCancellationTokenSource.Token);
Console.WriteLine("Creating {0} response queues...", responseQueueNames.Length);
await Task.Factory.ContinueWhenAll(responseQueueNames.Select(queueName => (Task)provider.CreateQueueAsync(queueName, testCancellationTokenSource.Token)).ToArray(), TaskExtrasExtensions.PropagateExceptions);
TimeSpan initializationTime = initializationTimer.Elapsed;
Console.WriteLine("Initialization time: {0} sec", initializationTime.TotalSeconds);
TimeSpan testDuration = TimeSpan.FromSeconds(10);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(testDuration);
Stopwatch processingTimer = Stopwatch.StartNew();
List <Task <int> > clientTasks = new List <Task <int> >();
List <Task <int> > serverTasks = new List <Task <int> >();
for (int i = 0; i < clientCount; i++)
{
clientTasks.Add(PublishMessages(requestQueueName, responseQueueNames[i], cancellationTokenSource.Token));
}
for (int i = 0; i < serverCount; i++)
{
serverTasks.Add(SubscribeMessages(requestQueueName, cancellationTokenSource.Token));
}
// wait for all client and server tasks to finish processing
await Task.Factory.ContinueWhenAll(clientTasks.Concat(serverTasks).Cast <Task>().ToArray(), TaskExtrasExtensions.PropagateExceptions);
int clientTotal = 0;
int serverTotal = 0;
for (int i = 0; i < clientTasks.Count; i++)
{
Console.WriteLine("Client {0}: {1} messages", i, clientTasks[i].Result);
clientTotal += clientTasks[i].Result;
}
for (int i = 0; i < serverTasks.Count; i++)
{
Console.WriteLine("Server {0}: {1} messages", i, serverTasks[i].Result);
serverTotal += serverTasks[i].Result;
}
double clientRate = clientTotal / testDuration.TotalSeconds;
double serverRate = serverTotal / testDuration.TotalSeconds;
Console.WriteLine("Total client messages: {0} ({1} messages/sec, {2} messages/sec/client)", clientTotal, clientRate, clientRate / clientCount);
Console.WriteLine("Total server messages: {0} ({1} messages/sec, {2} messages/sec/server)", serverTotal, serverRate, serverRate / serverCount);
Console.WriteLine("Deleting request queue...");
await provider.DeleteQueueAsync(requestQueueName, testCancellationTokenSource.Token);
Console.WriteLine("Deleting {0} response queues...", responseQueueNames.Length);
await Task.Factory.ContinueWhenAll(responseQueueNames.Select(queueName => provider.DeleteQueueAsync(queueName, testCancellationTokenSource.Token)).ToArray(), TaskExtrasExtensions.PropagateExceptions);
if (clientTotal == 0)
{
Assert.Inconclusive("No messages were fully processed by the test.");
}
}
