public async Task UpdateAsync_UpdateDequeuedMessage()
{
await using DisposingQueue test = await GetTestQueueAsync();
var message0 = "foo";
var message1 = "bar";
await test.Queue.SendMessageAsync(message0);
Models.QueueMessage message = (await test.Queue.ReceiveMessagesAsync(1)).Value.First();
Response <Models.UpdateReceipt> update = await test.Queue.UpdateMessageAsync(
message.MessageId,
message.PopReceipt,
message1);
Assert.AreNotEqual(update.Value.PopReceipt, message.PopReceipt);
Assert.AreNotEqual(update.Value.NextVisibleOn, message.NextVisibleOn);
Models.QueueMessage newMessage = message.Update(update);
Assert.AreEqual(message.MessageId, newMessage.MessageId);
Assert.AreEqual(message.MessageText, newMessage.MessageText);
Assert.AreEqual(message.InsertedOn, newMessage.InsertedOn);
Assert.AreEqual(message.ExpiresOn, newMessage.ExpiresOn);
Assert.AreEqual(message.DequeueCount, newMessage.DequeueCount);
Assert.AreNotEqual(message.PopReceipt, newMessage.PopReceipt);
Assert.AreNotEqual(message.NextVisibleOn, newMessage.NextVisibleOn);
Assert.AreEqual(update.Value.PopReceipt, newMessage.PopReceipt);
Assert.AreEqual(update.Value.NextVisibleOn, newMessage.NextVisibleOn);
}
public async Task QueuePermissionsRawPermissions(string permissionsString)
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
QueueSasBuilder queueSasBuilder = new QueueSasBuilder
{
StartsOn = Recording.UtcNow.AddHours(-1),
ExpiresOn = Recording.UtcNow.AddHours(1),
QueueName = test.Queue.Name
};
queueSasBuilder.SetPermissions(
rawPermissions: permissionsString,
normalize: true);
StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(TestConfigDefault.AccountName, TestConfigDefault.AccountKey);
QueueUriBuilder queueUriBuilder = new QueueUriBuilder(test.Queue.Uri)
{
Sas = queueSasBuilder.ToSasQueryParameters(sharedKeyCredential)
};
QueueClient sasQueueClient = new QueueClient(queueUriBuilder.ToUri(), GetOptions());
// Act
await sasQueueClient.PeekMessagesAsync();
}
public async Task AccountPermissionsRawPermissions(string permissionsString)
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
AccountSasBuilder accountSasBuilder = new AccountSasBuilder
{
StartsOn = Recording.UtcNow.AddHours(-1),
ExpiresOn = Recording.UtcNow.AddHours(1),
Services = AccountSasServices.Queues,
ResourceTypes = AccountSasResourceTypes.All
};
accountSasBuilder.SetPermissions(permissionsString);
Assert.AreEqual("rwdxylacuptfi", accountSasBuilder.Permissions);
StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(TestConfigDefault.AccountName, TestConfigDefault.AccountKey);
Uri uri = new Uri($"{test.Queue.Uri}?{accountSasBuilder.ToSasQueryParameters(sharedKeyCredential)}");
QueueClient queueClient = new QueueClient(uri, GetOptions());
// Act
await queueClient.GetPropertiesAsync();
}
public async Task GetQueuesAsync_Metadata()
{
QueueServiceClient service = GetServiceClient_SharedKey();
await using DisposingQueue test = await GetTestQueueAsync(service);
IDictionary<string, string> metadata = BuildMetadata();
await test.Queue.SetMetadataAsync(metadata);
QueueItem first = await service.GetQueuesAsync(QueueTraits.Metadata).FirstAsync();
Assert.IsNotNull(first.Metadata);
}
public async Task DeleteAsync_Error()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
// Act
await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>(
test.Queue.DeleteMessageAsync(GetNewMessageId(), GetNewString()),
actualException => Assert.AreEqual("MessageNotFound", actualException.ErrorCode));
}
public async Task EnqueueAsync_Min()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
// Act
Response <Models.SendReceipt> response = await test.Queue.SendMessageAsync(string.Empty);
// Assert
Assert.NotNull(response.Value);
}
public async Task GetQueuesAsync()
{
QueueServiceClient service = GetServiceClient_SharedKey();
await using DisposingQueue test = await GetTestQueueAsync(service);
IList<QueueItem> queues = await service.GetQueuesAsync().ToListAsync();
Assert.IsTrue(queues.Count >= 1);
var accountName = new QueueUriBuilder(service.Uri).AccountName;
TestHelper.AssertCacheableProperty(accountName, () => service.AccountName);
}
private async Task<TestExceptionPolicy> PerformSecondaryStorageTest(int numberOfReadFailuresToSimulate, bool retryOn404 = false)
{
QueueServiceClient service = GetServiceClient_SecondaryAccount_ReadEnabledOnRetry(numberOfReadFailuresToSimulate, out TestExceptionPolicy testExceptionPolicy, retryOn404);
await using DisposingQueue test = await GetTestQueueAsync(service);
IList<QueueItem> queues = await EnsurePropagatedAsync(
async () => await service.GetQueuesAsync().ToListAsync(),
queues => queues.Count > 0);
return testExceptionPolicy;
}
public async Task GetQueuesAsync_MaxResults()
{
QueueServiceClient service = GetServiceClient_SharedKey();
await using DisposingQueue test1 = await GetTestQueueAsync(service);
await using DisposingQueue test2 = await GetTestQueueAsync(service);
Page<QueueItem> page = await
service.GetQueuesAsync()
.AsPages(pageSizeHint: 1)
.FirstAsync();
Assert.AreEqual(1, page.Values.Count);
}
public static IDisposable GetNewQueue(out QueueClient queue, QueueServiceClient service = default, IDictionary <string, string> metadata = default)
{
var containerName = TestHelper.GetNewQueueName();
service = service ?? GetServiceClient_SharedKey();
var result = new DisposingQueue(service.GetQueueClient(containerName), metadata ?? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase));
queue = result.QueueClient;
return(result);
}
public async Task DeleteAsync()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
Models.SendReceipt enqueuedMessage = (await test.Queue.SendMessageAsync(string.Empty)).Value;
// Act
Response result = await test.Queue.DeleteMessageAsync(enqueuedMessage.MessageId, enqueuedMessage.PopReceipt);
// Assert
Assert.IsNotNull(result.Headers.RequestId);
}
public async Task EnqueueAsync()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
// Act
Response <Models.SendReceipt> response = await test.Queue.SendMessageAsync(
messageText : GetNewString(),
visibilityTimeout : new TimeSpan(0, 0, 1),
timeToLive : new TimeSpan(1, 0, 0));
// Assert
Assert.NotNull(response.Value);
}
public async Task Ctor_AzureSasCredential()
{
// Arrange
string sas = GetNewAccountSasCredentials(resourceTypes: AccountSasResourceTypes.Service).ToString();
await using DisposingQueue test = await GetTestQueueAsync();
Uri uri = GetServiceClient_SharedKey().Uri;
// Act
var sasClient = InstrumentClient(new QueueServiceClient(uri, new AzureSasCredential(sas), GetOptions()));
QueueServiceProperties properties = await sasClient.GetPropertiesAsync();
// Assert
Assert.IsNotNull(properties);
}
public async Task GetQueuesAsync_Marker()
{
QueueServiceClient service = GetServiceClient_SharedKey();
await using DisposingQueue test = await GetTestQueueAsync(service);
var marker = default(string);
var queues = new List<QueueItem>();
await foreach (Page<QueueItem> page in service.GetQueuesAsync().AsPages(marker))
{
queues.AddRange(page.Values);
}
Assert.AreNotEqual(0, queues.Count);
Assert.AreEqual(queues.Count, queues.Select(c => c.Name).Distinct().Count());
Assert.IsTrue(queues.Any(c => test.Queue.Uri == InstrumentClient(service.GetQueueClient(c.Name)).Uri));
}
public async Task AccountPermissionsRawPermissions_InvalidPermission()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
AccountSasBuilder accountSasBuilder = new AccountSasBuilder
{
StartsOn = Recording.UtcNow.AddHours(-1),
ExpiresOn = Recording.UtcNow.AddHours(1),
Services = AccountSasServices.Queues,
ResourceTypes = AccountSasResourceTypes.All
};
TestHelper.AssertExpectedException(
() => accountSasBuilder.SetPermissions("werteyfg"),
new ArgumentException("e is not a valid SAS permission"));
}
public async Task DequeueAsync_Min()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
// Act
Response <Models.QueueMessage[]> response = await test.Queue.ReceiveMessagesAsync();
// Assert
Assert.AreEqual(1, response.Value.Count());
}
public async Task ClearAsync()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
// Act
Response response = await test.Queue.ClearMessagesAsync();
// Assert
Assert.IsNotNull(response.Headers.RequestId);
}
public async Task PeekAsync()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
// Act
Response <Models.PeekedMessage[]> response = await test.Queue.PeekMessagesAsync(maxMessages : 2);
// Assert
Assert.AreEqual(2, response.Value.Count());
}
/// <summary>
/// Creates an encrypted queue client from a normal queue client. Note that this method does not copy over any
/// client options from the container client. You must pass in your own options. These options will be mutated.
/// </summary>
public async Task <DisposingQueue> GetTestEncryptedQueueAsync(
ClientSideEncryptionOptions encryptionOptions,
string queueName = default,
IDictionary <string, string> metadata = default)
{
// normally set through property on subclass; this is easier to hook up in current test infra with internals access
var options = GetOptions();
options._clientSideEncryptionOptions = encryptionOptions;
var service = GetServiceClient_SharedKey(options);
metadata ??= new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
QueueClient queue = InstrumentClient(service.GetQueueClient(GetNewQueueName()));
return(await DisposingQueue.CreateAsync(queue, metadata));
}
public async Task QueuePermissionsRawPermissions_Invalid()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
QueueSasBuilder queueSasBuilder = new QueueSasBuilder
{
StartsOn = Recording.UtcNow.AddHours(-1),
ExpiresOn = Recording.UtcNow.AddHours(1),
QueueName = test.Queue.Name
};
// Act
TestHelper.AssertExpectedException(
() => queueSasBuilder.SetPermissions(
rawPermissions: "ptsdfsd",
normalize: true),
new ArgumentException("s is not a valid SAS permission"));
}
public async Task DequeueAsync()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
await test.Queue.SendMessageAsync(GetNewString());
// Act
Response <Models.QueueMessage[]> response = await test.Queue.ReceiveMessagesAsync(
maxMessages : 2,
visibilityTimeout : new TimeSpan(1, 0, 0));
// Assert
Assert.AreEqual(2, response.Value.Count());
}
public async Task UpdateAsync_Min()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
var message0 = "foo";
var message1 = "bar";
Models.SendReceipt enqueuedMessage = (await test.Queue.SendMessageAsync(message0)).Value;
// Act
Response <Models.UpdateReceipt> result = await test.Queue.UpdateMessageAsync(
enqueuedMessage.MessageId,
enqueuedMessage.PopReceipt,
message1);
// Assert
Assert.IsNotNull(result.GetRawResponse().Headers.RequestId);
}
public async Task UpdateAsync_UpdatePeek()
{
// Arrange
await using DisposingQueue test = await GetTestQueueAsync();
var message0 = "foo";
var message1 = "bar";
Models.SendReceipt enqueuedMessage = (await test.Queue.SendMessageAsync(message0)).Value;
// Act
await test.Queue.UpdateMessageAsync(enqueuedMessage.MessageId, enqueuedMessage.PopReceipt, message1);
// Assert
Response <Models.PeekedMessage[]> peekedMessages = await test.Queue.PeekMessagesAsync(1);
Models.PeekedMessage peekedMessage = peekedMessages.Value.First();
Assert.AreEqual(1, peekedMessages.Value.Count());
Assert.AreEqual(message1, peekedMessage.MessageText);
}