public void CloudQueueMessageSetContent()
{
var s = "1234";
var bytes = Encoding.UTF8.GetBytes(s);
var s64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
var message = new CloudQueueMessage();
Assert.IsNull(message.RawBytes);
Assert.IsNull(message.RawString);
message.SetMessageContent2(bytes);
Assert.AreSame(bytes, message.RawBytes);
Assert.IsNull(message.RawString);
Assert.AreEqual(QueueMessageType.RawBytes, message.MessageType);
Assert.AreEqual(s, message.AsString);
Assert.IsTrue(bytes.SequenceEqual(message.AsBytes));
message.SetMessageContent2(s64, true);
Assert.IsNull(message.RawBytes);
Assert.AreEqual(s64, message.RawString);
Assert.AreEqual(QueueMessageType.Base64Encoded, message.MessageType);
Assert.AreEqual(s, message.AsString);
Assert.IsTrue(bytes.SequenceEqual(message.AsBytes));
message.SetMessageContent2(s, false);
Assert.IsNull(message.RawBytes);
Assert.AreEqual(s, message.RawString);
Assert.AreEqual(QueueMessageType.RawString, message.MessageType);
Assert.AreEqual(s, message.AsString);
Assert.IsTrue(bytes.SequenceEqual(message.AsBytes));
// obsolete APIs
message.SetMessageContent(bytes);
Assert.IsNull(message.RawBytes);
Assert.AreEqual(s64, message.RawString);
Assert.AreEqual(QueueMessageType.Base64Encoded, message.MessageType);
Assert.AreEqual(s, message.AsString);
Assert.IsTrue(bytes.SequenceEqual(message.AsBytes));
message.SetMessageContent(s);
Assert.IsNull(message.RawBytes);
Assert.AreEqual(s, message.RawString);
Assert.AreEqual(QueueMessageType.RawString, message.MessageType);
Assert.AreEqual(s, message.AsString);
Assert.IsTrue(bytes.SequenceEqual(message.AsBytes));
}
public void CloudQueueAddGetByteMessage()
{
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
byte[] testData = new byte[20];
CloudQueueMessage message = new CloudQueueMessage(testData);
queue.AddMessage(message);
CloudQueueMessage receivedMessage1 = queue.GetMessage();
Assert.IsTrue(receivedMessage1.AsString == message.AsString);
TestHelper.AssertStreamsAreEqual(new MemoryStream(receivedMessage1.AsBytes), new MemoryStream(message.AsBytes));
receivedMessage1.SetMessageContent(Guid.NewGuid().ToString("N"));
queue.UpdateMessage(receivedMessage1, TimeSpan.FromSeconds(1), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
queue.DeleteMessage(receivedMessage1);
queue.Delete();
}
public static CloudQueueMessage CreateCloudQueueMessageFromByteArray([ReadOnlyArray] byte[] content)
#endif
{
CloudQueueMessage message = new CloudQueueMessage(null);
message.SetMessageContent(content);
return message;
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudQueueMessage"/> class with the given byte array.
/// </summary>
/// <param name="content">The content of the message as a byte array.</param>
/// <returns>The new message as a <see cref="CloudQueueMessage"/> object.</returns>
public static CloudQueueMessage CreateCloudQueueMessageFromByteArray([ReadOnlyArray] byte[] content)
{
CloudQueueMessage message = new CloudQueueMessage(null);
message.SetMessageContent(content);
return(message);
}
private void DoCloudQueueAddUpdateEncryptedMessageAPM(IKey key, DictionaryKeyResolver keyResolver)
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
queue.CreateIfNotExists();
string messageStr = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageStr);
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(key, null);
QueueRequestOptions createOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
// Add message
IAsyncResult result = queue.BeginAddMessage(message, null, null, createOptions, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
queue.EndAddMessage(result);
policy = new QueueEncryptionPolicy(null, keyResolver);
QueueRequestOptions retrieveOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
// Retrieve message
result = queue.BeginGetMessage(null, retrieveOptions, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
CloudQueueMessage retrMessage = queue.EndGetMessage(result);
Assert.AreEqual(messageStr, retrMessage.AsString);
// Update message
string updatedMessage = Guid.NewGuid().ToString("N");
retrMessage.SetMessageContent(updatedMessage);
result = queue.BeginUpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility, createOptions, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
queue.EndUpdateMessage(result);
// Retrieve updated message
result = queue.BeginGetMessage(null, retrieveOptions, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
retrMessage = queue.EndGetMessage(result);
Assert.AreEqual(updatedMessage, retrMessage.AsString);
}
}
finally
{
queue.DeleteIfExists();
}
}
public async Task CloudQueueMessageBasicOperation()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(TestHelper.GenerateNewQueueName());
await queue.CreateAsync();
await queue.AddMessageAsync(new CloudQueueMessage("abcde"));
CloudQueueMessage receivedMessage1 = await queue.GetMessageAsync();
receivedMessage1.SetMessageContent(Guid.NewGuid().ToString("N"));
await queue.UpdateMessageAsync(receivedMessage1, null, MessageUpdateFields.Content);
await queue.DeleteMessageAsync(receivedMessage1);
}
public void CloudQueueUpdateMessageFullParameter()
{
string name = GenerateNewQueueName();
CloudQueue queue = DefaultQueueClient.GetQueueReference(name);
queue.Create();
queue.AddMessage(new CloudQueueMessage("message in queue"));
CloudQueueMessage messageFromQueue = queue.GetMessage(TimeSpan.FromDays(1));
var nextVisibleTime = messageFromQueue.NextVisibleTime.Value;
// Modify the message contents client-side
messageFromQueue.SetMessageContent("new message content!");
// Increase the message's visibility timeout.
queue.UpdateMessage(messageFromQueue, TimeSpan.FromDays(2), MessageUpdateFields.Visibility);
// The extra visibility time we get should be 1 day + small delta server time.
Assert.IsTrue(messageFromQueue.NextVisibleTime - nextVisibleTime >= TimeSpan.FromDays(1));
// Decrease the message's visibility timeout.
queue.UpdateMessage(messageFromQueue, TimeSpan.FromDays(1), MessageUpdateFields.Visibility);
// Now the extra time equals a small delta server time.
Assert.IsTrue(messageFromQueue.NextVisibleTime - nextVisibleTime < TimeSpan.FromHours(1));
// Update the message's visibility and content.
queue.UpdateMessage(messageFromQueue, TimeSpan.FromSeconds(1), MessageUpdateFields.Visibility | MessageUpdateFields.Content);
// Wait for message timeout to expire, then retrieve it again.
Thread.Sleep(TimeSpan.FromSeconds(1.5));
CloudQueueMessage messageRetrievedAgain = queue.GetMessage();
// The content should have been modified.
Assert.AreEqual(messageFromQueue.AsString, messageRetrievedAgain.AsString);
// Update with zero visibility timeout
queue.UpdateMessage(messageRetrievedAgain, TimeSpan.Zero, MessageUpdateFields.Visibility);
// The message is now expired. Retrieve it again.
messageRetrievedAgain = queue.GetMessage();
// The content should be the same as before.
Assert.AreEqual(messageFromQueue.AsString, messageRetrievedAgain.AsString);
queue.Delete();
}
private void DoCloudQueueAddUpdateEncryptedMessage(IKey key, DictionaryKeyResolver keyResolver)
{
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(key, null);
// Add message
QueueRequestOptions createOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
queue.AddMessage(message, null, null, createOptions, null);
// Retrieve message
QueueEncryptionPolicy retrPolicy = new QueueEncryptionPolicy(null, keyResolver);
QueueRequestOptions retrieveOptions = new QueueRequestOptions()
{
EncryptionPolicy = retrPolicy
};
CloudQueueMessage retrMessage = queue.GetMessage(null, retrieveOptions, null);
Assert.AreEqual(messageStr, retrMessage.AsString);
// Update message
string updatedMessage = Guid.NewGuid().ToString("N");
retrMessage.SetMessageContent(updatedMessage);
queue.UpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility, createOptions, null);
// Retrieve updated message
retrMessage = queue.GetMessage(null, retrieveOptions, null);
Assert.AreEqual(updatedMessage, retrMessage.AsString);
}
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();
}
static CloudQueueMessage Serialize(TransportMessage message, string messageId, string popReceipt)
{
var cloudStorageQueueTransportMessage = new CloudStorageQueueTransportMessage
{
Headers = message.Headers,
Body = message.Body
};
var cloudQueueMessage = new CloudQueueMessage(messageId, popReceipt);
cloudQueueMessage.SetMessageContent(JsonConvert.SerializeObject(cloudStorageQueueTransportMessage));
return cloudQueueMessage;
}
static CloudQueueMessage Serialize(string messageId, string popReceipt, Dictionary<string, string> headers, byte[] body)
{
var cloudStorageQueueTransportMessage = new CloudStorageQueueTransportMessage
{
Headers = headers,
Body = body
};
var cloudQueueMessage = new CloudQueueMessage(messageId, popReceipt);
cloudQueueMessage.SetMessageContent(JsonConvert.SerializeObject(cloudStorageQueueTransportMessage));
return cloudQueueMessage;
}
private CloudQueueMessage BuildCloudQueueMessage(TransportMessage message)
{
var jsonMsg = JObject.FromObject(message);
var msgBytes = (Serializer.Serialize(jsonMsg) as MemoryStream).ToArray();
var queueMessage = new CloudQueueMessage(message.Id, "");
queueMessage.SetMessageContent(msgBytes);
return queueMessage;
}
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();
}
}
