public async Task CloudQueueClientListQueuesBasicAsync()
{
DelegatingHandlerImpl delegatingHandlerImpl = new DelegatingHandlerImpl(new DelegatingHandlerImpl());
CloudQueueClient client = GenerateCloudQueueClient(delegatingHandlerImpl);
string prefix = GenerateNewQueueName();
List <string> queueNames = new List <string>();
int count = 30;
for (int i = 0; i < count; i++)
{
queueNames.Add(prefix + i);
}
QueueResultSegment emptyResults = await client.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null, null);
Assert.AreEqual <int>(0, emptyResults.Results.Count());
foreach (string name in queueNames)
{
await client.GetQueueReference(name).CreateAsync();
}
QueueResultSegment results = await client.ListQueuesSegmentedAsync(prefix, QueueListingDetails.All, null, null, null, null);
foreach (CloudQueue queue in results.Results)
{
if (queueNames.Remove(queue.Name))
{
await queue.DeleteAsync();
}
else
{
Assert.Fail();
}
}
Assert.AreEqual <int>(count, results.Results.Count());
Assert.AreNotEqual(0, delegatingHandlerImpl.CallCount);
}
public void CloudQueueClientListQueuesBasic()
{
string prefix = "dotnetqueuetest" + Guid.NewGuid().ToString("N");
List <string> queueNames = new List <string>();
int count = 30;
for (int i = 0; i < count; i++)
{
queueNames.Add(prefix + i);
}
CloudQueueClient client = GenerateCloudQueueClient();
List <CloudQueue> emptyResults = client.ListQueues(prefix, QueueListingDetails.All, null, null).ToList();
Assert.AreEqual <int>(0, emptyResults.Count);
foreach (string name in queueNames)
{
client.GetQueueReference(name).Create();
}
List <CloudQueue> results = client.ListQueues(prefix, QueueListingDetails.All, null, null).ToList();
Assert.AreEqual <int>(results.Count, queueNames.Count);
foreach (CloudQueue queue in results)
{
if (queueNames.Remove(queue.Name))
{
queue.Delete();
}
else
{
Assert.Fail();
}
}
Assert.AreEqual <int>(0, queueNames.Count);
}
public void CloudQueueAddUpdateEncryptedEncodedMessage()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
byte[] messageBytes = new byte[100];
Random rand = new Random();
rand.NextBytes(messageBytes);
string inputMessage = Convert.ToBase64String(messageBytes);
CloudQueueMessage message = new CloudQueueMessage(inputMessage);
queue.EncodeMessage = false;
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
QueueRequestOptions options = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
// Add message
queue.AddMessage(message, null, null, options, null);
// Retrieve message
CloudQueueMessage retrMessage = queue.GetMessage(null, options, null);
Assert.AreEqual(inputMessage, retrMessage.AsString);
}
finally
{
queue.DeleteIfExists();
}
}
public async Task CloudQueuePeekMessageAsync()
{
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
await queue.CreateAsync();
CloudQueueMessage emptyMessage = await queue.PeekMessageAsync();
Assert.IsNull(emptyMessage);
string msgContent = Guid.NewGuid().ToString("N");
CloudQueueMessage message = new CloudQueueMessage(msgContent);
await queue.AddMessageAsync(message);
VerifyAddMessageResult(message);
CloudQueueMessage receivedMessage1 = await queue.PeekMessageAsync();
Assert.IsTrue(receivedMessage1.AsString == message.AsString);
await queue.DeleteAsync();
}
public async Task CloudQueuePeekMessagesAsync()
{
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
await queue.CreateAsync();
int messageCount = 30;
List <CloudQueueMessage> emptyMessages = (await queue.PeekMessagesAsync(messageCount)).ToList();
Assert.AreEqual(0, emptyMessages.Count);
List <string> messageContentList = new List <string>();
for (int i = 0; i < messageCount; i++)
{
string messageContent = i.ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
VerifyAddMessageResult(message);
messageContentList.Add(messageContent);
}
List <CloudQueueMessage> receivedMessages = (await queue.PeekMessagesAsync(messageCount)).ToList();
Assert.AreEqual(messageCount, receivedMessages.Count);
for (int i = 0; i < messageCount; i++)
{
Assert.IsTrue(messageContentList.Contains(receivedMessages[i].AsString));
}
await queue.DeleteAsync();
}
public async Task CloudQueueAddMessageVerifyContent()
{
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
await queue.CreateIfNotExistsAsync();
string msgContent = Guid.NewGuid().ToString("N");
CloudQueueMessage message = new CloudQueueMessage(msgContent);
message.NextVisibleTime = null;
await queue.AddMessageAsync(message);
VerifyAddMessageResult(message);
Assert.IsTrue(message.AsString == msgContent);
}
finally
{
await queue.DeleteAsync();
}
}
public void CloudQueueAddEncrypted64KMessage()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
string inputMessage = new string('a', 64 * 1024);
CloudQueueMessage message = new CloudQueueMessage(inputMessage);
queue.EncodeMessage = false;
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
QueueRequestOptions options = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
// Add message
queue.AddMessage(message, null, null, null, null);
// Add encrypted Message
TestHelper.ExpectedException <ArgumentException>(
() => queue.AddMessage(message, null, null, options, null),
"Adding an encrypted message that exceeds message limits should throw");
}
finally
{
queue.DeleteIfExists();
}
}
public async Task QueueRegionalSASTestAsync()
{
#if NETCORE
//CultureInfo currentCulture = CultureInfo.CurrentCulture;
//CultureInfo.CurrentCulture = new CultureInfo("it");
#else
string currentPrimaryLanguage = ApplicationLanguages.PrimaryLanguageOverride;
ApplicationLanguages.PrimaryLanguageOverride = "it";
#endif
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateAsync();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
// Prepare SAS authentication with full permissions
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
});
await queue.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
string sasTokenFromId = queue.GetSharedAccessSignature(null, id);
StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId);
CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId);
CloudQueueMessage receivedMessage1 = await sasQueueFromId.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage1.AsString);
string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
CloudQueueMessage receivedMessage2 = await sasQueueFromPolicy.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage2.AsString);
}
finally
{
#if NETCORE
//CultureInfo.CurrentCulture = currentCulture;
#else
ApplicationLanguages.PrimaryLanguageOverride = currentPrimaryLanguage;
#endif
queue.DeleteAsync().Wait();
}
}
public async Task CloudQueueAddMessageFullParameterAsync()
{
CloudQueueMessage futureMessage = new CloudQueueMessage("This message is for the future.");
CloudQueueMessage presentMessage = new CloudQueueMessage("This message is for the present.");
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateIfNotExistsAsync();
await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(2), null, null);
VerifyAddMessageResult(futureMessage);
// We should not be able to see the future message yet.
CloudQueueMessage retrievedMessage = await queue.GetMessageAsync();
Assert.IsNull(retrievedMessage);
await queue.AddMessageAsync(presentMessage, null, TimeSpan.Zero, null, null);
VerifyAddMessageResult(presentMessage);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromDays(1), null, null, null);
VerifyAddMessageResult(presentMessage);
// We should be able to see the present message.
retrievedMessage = await queue.GetMessageAsync();
Assert.IsNotNull(retrievedMessage);
Assert.AreEqual <string>(presentMessage.AsString, retrievedMessage.AsString);
await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(2), TimeSpan.FromDays(1), null, null);
VerifyAddMessageResult(futureMessage);
await queue.ClearAsync();
// -1 seconds should set an infinite ttl
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), null, null, null);
retrievedMessage = await queue.PeekMessageAsync();
Assert.AreEqual(DateTime.MaxValue.Year, retrievedMessage.ExpirationTime.Value.Year);
// There should be no upper bound on ttl
await queue.AddMessageAsync(presentMessage, TimeSpan.MaxValue, null, null, null);
// Check other edge cases
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(0), null, null);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(7 * 24 * 60 * 60), TimeSpan.FromSeconds(7 * 24 * 60 * 60 - 1), null, null);
await queue.AddMessageAsync(presentMessage, TimeSpan.FromSeconds(-1), TimeSpan.FromSeconds(1), null, null);
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromDays(1), TimeSpan.FromDays(2), null, null),
"Using a visibility timeout longer than the time to live should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromDays(8), null, null),
"Using a visibility longer than the maximum visibility timeout should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, null, TimeSpan.FromMinutes(-1), null, null),
"Using a negative visibility should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await queue.AddMessageAsync(futureMessage, TimeSpan.FromMinutes(-1), null, null, null),
"Using a negative TTL other than -1 seconds (infinite) should fail");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
() => queue.AddMessageAsync(futureMessage, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), null, null),
"Visibility timeout must be strictly less than the TTL");
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
() => queue.AddMessageAsync(presentMessage, null, CloudQueueMessage.MaxVisibilityTimeout, null, null),
"Null TTL will default to 7 days, which is the max visibility timeout. They cannot be equal.");
}
finally
{
await queue.DeleteAsync();
}
}
public async Task QueueContinuationTokenVerifyXmlWithinXml()
{
CloudQueueClient client = GenerateCloudQueueClient();
string prefix = "dotnetqueuetest" + Guid.NewGuid().ToString("N");
List <string> queueNames = new List <string>();
int count = 30;
for (int i = 0; i < count; i++)
{
queueNames.Add(prefix + i);
client.GetQueueReference(prefix + i).Create();
}
QueueContinuationToken token = null;
List <CloudQueue> results = new List <CloudQueue>();
do
{
QueueResultSegment segment = client.ListQueuesSegmented(prefix, QueueListingDetails.None, 5, token, null, null);
token = segment.ContinuationToken;
results.AddRange(segment.Results);
if (token != null)
{
Assert.AreEqual(null, token.GetSchema());
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, settings))
{
writer.WriteStartElement("test1");
writer.WriteStartElement("test2");
token.WriteXml(writer);
writer.WriteEndElement();
writer.WriteEndElement();
}
using (XmlReader reader = XMLReaderExtensions.CreateAsAsync(new MemoryStream(Encoding.Unicode.GetBytes(sb.ToString()))))
{
token = new QueueContinuationToken();
await reader.ReadStartElementAsync();
await reader.ReadStartElementAsync();
await token.ReadXmlAsync(reader);
await reader.ReadEndElementAsync();
await reader.ReadEndElementAsync();
}
}
}while (token != null);
foreach (CloudQueue queue in results)
{
if (queueNames.Remove(queue.Name))
{
queue.Delete();
}
else
{
Assert.Fail();
}
}
Assert.AreEqual <int>(0, queueNames.Count);
}
public void CloudQueueMessageEncryptionWithStrictMode()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
// Create the resolver to be used for unwrapping.
DictionaryKeyResolver resolver = new DictionaryKeyResolver();
resolver.Add(aesKey);
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
string messageStr = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageStr);
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
// Add message with policy.
QueueRequestOptions createOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
createOptions.RequireEncryption = true;
queue.AddMessage(message, null, null, createOptions, null);
// Set policy to null and add message while RequireEncryption flag is still set to true. This should throw.
createOptions.EncryptionPolicy = null;
TestHelper.ExpectedException <InvalidOperationException>(
() => queue.AddMessage(message, null, null, createOptions, null),
"Not specifying a policy when RequireEnryption is set to true should throw.");
// Retrieve message
QueueEncryptionPolicy retrPolicy = new QueueEncryptionPolicy(null, resolver);
QueueRequestOptions retrieveOptions = new QueueRequestOptions()
{
EncryptionPolicy = retrPolicy
};
retrieveOptions.RequireEncryption = true;
CloudQueueMessage retrMessage = queue.GetMessage(null, retrieveOptions, null);
// Update message with plain text.
string updatedMessage = Guid.NewGuid().ToString("N");
retrMessage.SetMessageContent(updatedMessage);
queue.UpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
// Retrieve updated message with RequireEncryption flag but no metadata on the service. This should throw.
TestHelper.ExpectedException <StorageException>(
() => queue.GetMessage(null, retrieveOptions, null),
"Retrieving with RequireEncryption set to true and no metadata on the service should fail.");
// Set RequireEncryption to false and retrieve.
retrieveOptions.RequireEncryption = false;
queue.GetMessage(null, retrieveOptions, null);
}
finally
{
queue.DeleteIfExists();
}
}