public void SynchronousTestListAllQueueMessages()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
for (int i = 0; i < 28; i++)
{
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i)));
}
HashSet <int> locatedMessages = new HashSet <int>();
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, false);
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);
}
provider.DeleteQueue(queueName);
}
private void PublishMessages(QueueName requestQueueName, QueueName replyQueueName, ref int processedMessages, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
processedMessages = 0;
Random random = new Random();
while (true)
{
long x = random.Next();
long y = random.Next();
Message <CalculatorOperation> message = new Message <CalculatorOperation>(TimeSpan.FromMinutes(5), new CalculatorOperation(replyQueueName, "+", x, y));
queueingService.PostMessages(requestQueueName, message);
bool handled = false;
while (true)
{
// process reply messages
using (Claim claim = queueingService.ClaimMessage(replyQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)))
{
foreach (QueuedMessage queuedMessage in claim.Messages)
{
CalculatorResult result = queuedMessage.Body.ToObject <CalculatorResult>();
if (result._id == message.Body._id)
{
// this is the reply to this thread's operation
Assert.AreEqual(message.Body._operand1 + message.Body._operand2, result._result);
Assert.AreEqual(x + y, result._result);
queueingService.DeleteMessage(replyQueueName, queuedMessage.Id, claim);
processedMessages++;
handled = true;
}
else if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
if (handled)
{
break;
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
if (token.IsCancellationRequested)
{
// shutdown trigger
return;
}
}
}
public void SynchronousTestPostQueueMessages_Typed_0()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
Message <SampleMetadata> typedMessage = new Message <SampleMetadata>(TimeSpan.FromMinutes(40), new SampleMetadata(1, "Stuff!"));
//
// Typed messages
//
enqueued = provider.PostMessages <SampleMetadata>(queueName);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
enqueued = provider.PostMessages <SampleMetadata>(queueName, Enumerable.Empty <Message <SampleMetadata> >());
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(0, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
public void SynchronousTestPostQueueMessages_Generic_2()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
Message genericMessage = new Message(TimeSpan.FromMinutes(50), new JObject(new JProperty("type", "generic")));
//
// Generic messages
//
enqueued = provider.PostMessages(queueName, genericMessage, genericMessage);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(2, enqueued.Ids.Count());
Assert.AreEqual(false, enqueued.Partial);
enqueued = provider.PostMessages(queueName, new[] { genericMessage, genericMessage });
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(2, enqueued.Ids.Count());
Assert.AreEqual(false, enqueued.Partial);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(4, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
public void SynchronousTestPostQueueMessages_Generic_0()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
MessagesEnqueued enqueued;
//
// Generic messages
//
enqueued = provider.PostMessages(queueName);
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
enqueued = provider.PostMessages(queueName, Enumerable.Empty <Message>());
Assert.IsNotNull(enqueued);
Assert.AreEqual(false, enqueued.Partial);
Assert.IsNotNull(enqueued.Ids);
Assert.IsFalse(enqueued.Ids.Contains(null));
Assert.AreEqual(0, enqueued.Ids.Count());
Assert.AreSame(MessagesEnqueued.Empty, enqueued);
//
// Validation
//
ReadOnlyCollection <QueuedMessage> messages = ListAllMessages(provider, queueName, null, true, true);
Assert.IsNotNull(messages);
Assert.AreEqual(0, messages.Count);
//
// Cleanup
//
provider.DeleteQueue(queueName);
}
public void SynchronousTestListAllQueueMessagesWithUpdates()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
for (int i = 0; i < 28; i++)
{
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(i, "Some Message " + i)));
}
HashSet <int> locatedMessages = new HashSet <int>();
QueuedMessageList messages = provider.ListMessages(queueName, null, null, true, false);
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;
provider.DeleteMessage(queueName, messages[0].Id, null);
while (messages.Count > 0)
{
QueuedMessageList tempList = provider.ListMessages(queueName, messages.NextPageId, null, true, false);
if (tempList.Count > 0)
{
Assert.IsTrue(locatedMessages.Add(tempList[0].Body.ToObject <SampleMetadata>().ValueA), "Received the same message more than once.");
provider.DeleteMessage(queueName, tempList[0].Id, null);
}
messages = provider.ListMessages(queueName, messages.NextPageId, null, true, false);
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);
}
provider.DeleteQueue(queueName);
}
public void SynchronousTestQueueStatistics()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
QueueStatistics statistics = provider.GetQueueStatistics(queueName);
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));
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
statistics = provider.GetQueueStatistics(queueName);
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));
provider.DeleteQueue(queueName);
}
public void SynchronousTestQueueClaims()
{
IQueueingService provider = CreateProvider();
QueueName queueName = CreateRandomQueueName();
provider.CreateQueue(queueName);
provider.PostMessages(queueName, new Message <SampleMetadata>(TimeSpan.FromSeconds(120), new SampleMetadata(3, "yes")));
QueueStatistics statistics;
using (Claim claim = provider.ClaimMessage(queueName, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(1)))
{
Assert.AreEqual(TimeSpan.FromMinutes(5), claim.TimeToLive);
Assert.IsNotNull(claim.Messages);
Assert.AreEqual(1, claim.Messages.Count);
statistics = provider.GetQueueStatistics(queueName);
Assert.AreEqual(1, statistics.MessageStatistics.Claimed);
QueuedMessage message = provider.GetMessage(queueName, claim.Messages[0].Id);
Assert.IsNotNull(message);
TimeSpan age = claim.Age;
Thread.Sleep(TimeSpan.FromSeconds(2));
claim.Refresh();
Assert.IsTrue(claim.Age >= age + TimeSpan.FromSeconds(2));
claim.Renew(TimeSpan.FromMinutes(10));
Assert.AreEqual(TimeSpan.FromMinutes(10), claim.TimeToLive);
}
statistics = provider.GetQueueStatistics(queueName);
Assert.AreEqual(0, statistics.MessageStatistics.Claimed);
provider.DeleteQueue(queueName);
}
private void SubscribeMessages(QueueName requestQueueName, ref int processedMessages, CancellationToken token)
{
IQueueingService queueingService = CreateProvider();
processedMessages = 0;
while (true)
{
// process request messages
using (Claim claim = queueingService.ClaimMessage(requestQueueName, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)))
{
List <QueuedMessage> messagesToDelete = new List <QueuedMessage>();
foreach (QueuedMessage queuedMessage in claim.Messages)
{
if (token.IsCancellationRequested)
{
return;
}
CalculatorOperation operation = queuedMessage.Body.ToObject <CalculatorOperation>();
CalculatorResult result;
switch (operation._command)
{
case "+":
result = new CalculatorResult(operation, operation._operand1 + operation._operand2);
break;
case "-":
result = new CalculatorResult(operation, operation._operand1 - operation._operand2);
break;
case "*":
result = new CalculatorResult(operation, operation._operand1 * operation._operand2);
break;
case "/":
result = new CalculatorResult(operation, operation._operand1 / operation._operand2);
break;
default:
throw new InvalidOperationException();
}
messagesToDelete.Add(queuedMessage);
queueingService.PostMessages(operation._replyQueueName, new Message <CalculatorResult>(TimeSpan.FromMinutes(5), result));
processedMessages++;
}
if (messagesToDelete.Count > 0)
{
queueingService.DeleteMessages(requestQueueName, messagesToDelete.Select(i => i.Id));
}
}
if (token.IsCancellationRequested)
{
return;
}
}
}
