public void CloudQueueClientListQueuesBasic()
{
string prefix = "lib35queuetest" + Guid.NewGuid().ToString("N");
List <string> queueNames = new List <string>();
int count = 30;
for (int i = 0; i < count; i++)
{
queueNames.Add(prefix + i);
}
List <CloudQueue> emptyResults = DefaultQueueClient.ListQueues(prefix, QueueListingDetails.All, null, null).ToList();
Assert.AreEqual <int>(0, emptyResults.Count);
foreach (string name in queueNames)
{
DefaultQueueClient.GetQueueReference(name).Create();
}
List <CloudQueue> results = DefaultQueueClient.ListQueues(prefix, QueueListingDetails.All, null, null).ToList();
Assert.AreEqual <int>(results.Count, queueNames.Count);
foreach (var queue in results)
{
if (queueNames.Remove(queue.Name))
{
queue.Delete();
}
else
{
Assert.Fail();
}
}
Assert.AreEqual <int>(0, queueNames.Count);
}
public void CloudQueueGetSetPermissions()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(GenerateNewQueueName());
try
{
queue.Create();
QueuePermissions emptyPermission = queue.GetPermissions();
Assert.AreEqual(emptyPermission.SharedAccessPolicies.Count, 0);
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
queue.SetPermissions(permissions);
Thread.Sleep(30 * 1000);
CloudQueue queueToRetrieve = DefaultQueueClient.GetQueueReference(queue.Name);
QueuePermissions permissionsToRetrieve = queueToRetrieve.GetPermissions();
Assert.AreEqual(permissions.SharedAccessPolicies.Count, permissionsToRetrieve.SharedAccessPolicies.Count);
//Assert.AreEqual(start, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessStartTime.Value.UtcDateTime);
//Assert.AreEqual(expiry, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(permissions.SharedAccessPolicies[id].Permissions, permissionsToRetrieve.SharedAccessPolicies[id].Permissions);
}
finally
{
queue.DeleteIfExists();
}
}
public void CloudQueueUpdateMessageBoundaryAndNegativeCheck()
{
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
queue.AddMessage(new CloudQueueMessage("message in queue"));
CloudQueueMessage messageFromQueue = queue.GetMessage(TimeSpan.FromDays(1));
messageFromQueue.SetMessageContent("newer message content");
// If Visibility is not flagged for modification, an exception should be raised.
TestHelper.ExpectedException <ArgumentException>(
() => queue.UpdateMessage(messageFromQueue, TimeSpan.FromDays(1), MessageUpdateFields.Content),
"Visibility is not flagged for modification");
// If visibility timeout is greater than the maximum time to live, an exception should be raised.
TestHelper.ExpectedException <ArgumentException>(
() => queue.UpdateMessage(messageFromQueue, TimeSpan.FromDays(7) + TimeSpan.FromSeconds(1), MessageUpdateFields.Visibility),
"visibility timeout is greater than the maximum time to live");
// If visibility timeout is negative, an exception should be raised.
TestHelper.ExpectedException <ArgumentException>(
() => queue.UpdateMessage(messageFromQueue, TimeSpan.FromSeconds(-1), MessageUpdateFields.Visibility),
"visibility timeout is negative");
// If the message has no ID and pop receipt, an exception should be raised.
CloudQueueMessage messageNotReceived = new CloudQueueMessage("This message has never been in a queue before.");
TestHelper.ExpectedException <ArgumentException>(
() => queue.UpdateMessage(messageNotReceived, TimeSpan.FromDays(1), MessageUpdateFields.Visibility),
"the message has no ID and pop receipt");
queue.Delete();
}
public void CloudQueueAddGetMessage()
{
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
string msgContent = Guid.NewGuid().ToString("N");
CloudQueueMessage message = new CloudQueueMessage(msgContent);
queue.AddMessage(message);
CloudQueueMessage receivedMessage1 = queue.GetMessage();
Assert.IsTrue(receivedMessage1.AsString == message.AsString);
receivedMessage1.SetMessageContent(Guid.NewGuid().ToString("N"));
queue.UpdateMessage(receivedMessage1, TimeSpan.FromSeconds(1), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
queue.DeleteMessage(receivedMessage1);
queue.Delete();
}
public void CloudQueueMessageNormalBoundaryTest()
{
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
CloudQueue queueRefWithoutBase64Encoding = DefaultQueueClient.GetQueueReference(name);
queueRefWithoutBase64Encoding.EncodeMessage = false;
// a string with ascii chars of length 8*6144 will have Base64-encoded length 8*8192 (64kB)
// the following three test strings with length 8*6144-1, 8*6144, and 8*6144+1
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 6144 - 1);
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 6144);
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 6144 + 1);
// boundary value 8*8192-1, 8*8192, 8*8192+1
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 8192 - 1);
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 8192);
CloudQueueMessageBase64EncodingBoundaryTest(queue, queueRefWithoutBase64Encoding, 8 * 8192 + 1);
queue.Delete();
}
public void CloudQueueMessageQueueAddLargeMessage()
{
long maxStringLength = CloudQueueMessage.MaxMessageSize;
long maxByteArrayLength = CloudQueueMessage.MaxMessageSize * 3 / 4;
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
{
char[] longMessageChars = new char[maxStringLength];
for (long i = 0; i < longMessageChars.LongLength; i++)
{
longMessageChars[i] = (char)('A' + (i % 26));
}
CloudQueueMessage longMessageFromString = new CloudQueueMessage(new string(longMessageChars));
// Do not encode the message. This allows a maximally-sized string to be used.
queue.EncodeMessage = false;
// The following call should succeed.
queue.AddMessage(longMessageFromString);
CloudQueueMessage retrievedMessage = queue.GetMessage();
Assert.AreEqual(longMessageFromString.AsString, retrievedMessage.AsString);
}
{
byte[] longMessageBytes = new byte[maxByteArrayLength];
for (long i = 0; i < longMessageBytes.LongLength; i++)
{
longMessageBytes[i] = (byte)i;
}
CloudQueueMessage longMessageFromByteArray = new CloudQueueMessage(longMessageBytes);
// The following call should throw an exception because byte array messages must be base 64 encoded.
queue.EncodeMessage = false;
TestHelper.ExpectedException <ArgumentException>(
() => queue.AddMessage(longMessageFromByteArray),
"AddMessage should throw an exception because byte array messages must be base 64 encoded");
// Encode the message in base 64. This is the only way to use byte arrays in a message.
queue.EncodeMessage = true;
// The following call should succeed.
queue.AddMessage(longMessageFromByteArray);
CloudQueueMessage retrievedMessage = queue.GetMessage();
byte[] expectedBytes = longMessageFromByteArray.AsBytes;
byte[] foundBytes = retrievedMessage.AsBytes;
Assert.AreEqual(expectedBytes.Length, foundBytes.Length);
for (int i = 0; i < expectedBytes.Length; i++)
{
Assert.AreEqual(expectedBytes[i], foundBytes[i]);
}
}
queue.Delete();
}
