public void CreateQueue_ValidName_CreatesQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
client.CreateQueue(queueName);
_util.AssertQueueExists(queueName);
}
public void ListQueues_AtLeastOneQueue_ReturnsListContainingThatQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
var response = client.ListQueues();
Assert.IsTrue(response.Queues.Any(q => q.Name == queueName));
}
public void CreateQueue_AlreadyExistsWithNoMetadata_ReportsNoContentPerDocumentation()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
client.CreateQueue(queueName);
// I don't think I can/should-be-able-to test the return code at this level...
}
public void PutMessage_ValidMessage_AddsMessageToQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
string message = "Unit Test Message";
client.PutMessage(queueName, message);
_util.AssertQueueHasMessage(queueName);
}
public void CreateQueue_ValidNameAndMetadata_CreatesQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
client.CreateQueue(queueName, new Dictionary<string, string>() {
{ "SampleName", "SampleValue" }
});
_util.AssertQueueExists(queueName);
}
public void PutMessage_TooLargeMessage_ThrowsRequestBodyTooLargeException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
string message = new String('a', 64 * 1024 + 1);
client.PutMessage(queueName, message);
//expects exception
}
public void PutMessage_InvalidXMLCharacters_DoesNotThrowException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
string message = "{\"KeyValueLogPayload\": {\"UserIP\": \"::1\",\"URL\": \"http://fakeurl/foo?bar=baz&baz=bar\"}}";
Assert.DoesNotThrow(() =>
{
client.PutMessage(queueName, message);
});
}
public void CreateQueue_AlreadyExistsWithMatchingMetadata_ReportsNoContentPerDocumentation()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName, new Dictionary<string, string> {
{ "SampleKey", "SampleValue" }
});
client.CreateQueue(queueName, new Dictionary<string, string> {
{ "SampleKey", "SampleValue" }
});
// I don't think I can/should-be-able-to test the return code at this level...
}
public void ListQueues_MaxResultsSmallerThanQueueList_ReturnsOnlyThatManyResults()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueNames = new List<string>();
for (int i = 0; i < 5; i++)
{
var queueName = GenerateSampleQueueName(i.ToString());
_util.CreateQueue(queueName);
queueNames.Add(queueName);
}
var response = client.ListQueues(maxResults: 3);
Assert.AreEqual(3, response.Queues.Count);
}
public void ListQueues_WithPrefix_ReturnsListContainingOnlyQueuesWithThatPrefix()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueNames = new List<string>();
for (int i = 18; i < 21; i++)
{
var queueName = GenerateSampleQueueName(i.ToString());
_util.CreateQueue(queueName);
queueNames.Add(queueName);
}
var response = client.ListQueues("1");
Assert.AreEqual("1", response.Prefix);
Assert.IsTrue(response.Queues.Count(q => q.Name.StartsWith("1")) >= 2);
Assert.AreEqual(0, response.Queues.Count(q => !q.Name.StartsWith("1")));
}
public void CanGenerateSas_ClientConstructors()
{
// Arrange
var constants = new TestConstants(this);
var blobEndpoint = new Uri("https://127.0.0.1/" + constants.Sas.Account);
var blobSecondaryEndpoint = new Uri("https://127.0.0.1/" + constants.Sas.Account + "-secondary");
var storageConnectionString = new StorageConnectionString(constants.Sas.SharedKeyCredential, queueStorageUri: (blobEndpoint, blobSecondaryEndpoint));
string connectionString = storageConnectionString.ToString(true);
// Act - QueueServiceClient(string connectionString)
QueueServiceClient serviceClient = InstrumentClient(new QueueServiceClient(
connectionString));
Assert.IsTrue(serviceClient.CanGenerateAccountSasUri);
// Act - QueueServiceClient(string connectionString, string blobContainerName, BlobClientOptions options)
QueueServiceClient serviceClient2 = InstrumentClient(new QueueServiceClient(
connectionString,
GetOptions()));
Assert.IsTrue(serviceClient2.CanGenerateAccountSasUri);
// Act - QueueServiceClient(Uri blobContainerUri, BlobClientOptions options = default)
QueueServiceClient serviceClient3 = InstrumentClient(new QueueServiceClient(
blobEndpoint,
GetOptions()));
Assert.IsFalse(serviceClient3.CanGenerateAccountSasUri);
// Act - QueueServiceClient(Uri blobContainerUri, StorageSharedKeyCredential credential, BlobClientOptions options = default)
QueueServiceClient serviceClient4 = InstrumentClient(new QueueServiceClient(
blobEndpoint,
constants.Sas.SharedKeyCredential,
GetOptions()));
Assert.IsTrue(serviceClient4.CanGenerateAccountSasUri);
}
public TestFixture()
{
IHost host = new HostBuilder()
.ConfigureDefaultTestHost(b =>
{
b.AddAzureStorageQueues();
})
.Build();
var queueServiceClientProvider = host.Services.GetService <QueueServiceClientProvider>();
QueueServiceClient client = queueServiceClientProvider.GetHost();
QueueClient = client;
string queueName = string.Format("{0}-{1}", TestQueuePrefix, Guid.NewGuid());
Queue = client.GetQueueClient(queueName);
Queue.CreateIfNotExists();
string poisonQueueName = string.Format("{0}-poison", queueName);
PoisonQueue = client.GetQueueClient(poisonQueueName);
PoisonQueue.CreateIfNotExists();
}
public BlobListenerFactory(IHostIdProvider hostIdProvider,
BlobsOptions blobsOptions,
IWebJobsExceptionHandler exceptionHandler,
IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
BlobTriggerQueueWriterFactory blobTriggerQueueWriterFactory,
ISharedContextProvider sharedContextProvider,
ILoggerFactory loggerFactory,
FunctionDescriptor functionDescriptor,
BlobServiceClient hostBlobServiceClient,
QueueServiceClient hostQueueServiceClient,
BlobServiceClient dataBlobServiceClient,
QueueServiceClient dataQueueServiceClient,
BlobContainerClient container,
IBlobPathSource input,
BlobTriggerSource triggerKind,
ITriggeredFunctionExecutor executor,
IHostSingletonManager singletonManager)
{
_hostIdProvider = hostIdProvider ?? throw new ArgumentNullException(nameof(hostIdProvider));
_blobTriggerQueueWriterFactory = blobTriggerQueueWriterFactory ?? throw new ArgumentNullException(nameof(blobTriggerQueueWriterFactory));
_blobsOptions = blobsOptions ?? throw new ArgumentNullException(nameof(blobsOptions));
_exceptionHandler = exceptionHandler ?? throw new ArgumentNullException(nameof(exceptionHandler));
_blobWrittenWatcherSetter = blobWrittenWatcherSetter ?? throw new ArgumentNullException(nameof(blobWrittenWatcherSetter));
_sharedContextProvider = sharedContextProvider ?? throw new ArgumentNullException(nameof(sharedContextProvider));
_functionDescriptor = functionDescriptor ?? throw new ArgumentNullException(nameof(functionDescriptor));
_loggerFactory = loggerFactory;
_hostBlobServiceClient = hostBlobServiceClient ?? throw new ArgumentNullException(nameof(hostBlobServiceClient));
_hostQueueServiceClient = hostQueueServiceClient ?? throw new ArgumentNullException(nameof(hostQueueServiceClient));
_dataBlobServiceClient = dataBlobServiceClient ?? throw new ArgumentNullException(nameof(dataBlobServiceClient));
_dataQueueServiceClient = dataQueueServiceClient ?? throw new ArgumentNullException(nameof(dataQueueServiceClient));
_container = container ?? throw new ArgumentNullException(nameof(container));
_input = input ?? throw new ArgumentNullException(nameof(input));
_blobTriggerSource = triggerKind;
_executor = executor ?? throw new ArgumentNullException(nameof(executor));
_singletonManager = singletonManager ?? throw new ArgumentNullException(nameof(singletonManager));
}
public async Task SetPropertiesAsync_ExistingProperties()
{
// Arrange
QueueServiceClient service = GetServiceClient_SharedKey();
QueueServiceProperties properties = await service.GetPropertiesAsync();
QueueCorsRule[] originalCors = properties.Cors.ToArray();
properties.Cors =
new[]
{
new QueueCorsRule
{
MaxAgeInSeconds = 1000,
AllowedHeaders = "x-ms-meta-data*,x-ms-meta-target*,x-ms-meta-abc",
AllowedMethods = "PUT,GET",
AllowedOrigins = "*",
ExposedHeaders = "x-ms-meta-*"
}
};
// Act
await service.SetPropertiesAsync(properties);
// Assert
properties = await service.GetPropertiesAsync();
Assert.AreEqual(1, properties.Cors.Count());
Assert.IsTrue(properties.Cors[0].MaxAgeInSeconds == 1000);
// Cleanup
properties.Cors = originalCors;
await service.SetPropertiesAsync(properties);
properties = await service.GetPropertiesAsync();
Assert.AreEqual(originalCors.Count(), properties.Cors.Count());
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var queueServiceClient = new QueueServiceClient(_connectionString);
var serviceProperties = await queueServiceClient.GetPropertiesAsync(cancellationToken);
if (!string.IsNullOrEmpty(_queueName))
{
var queueClient = queueServiceClient.GetQueueClient(_queueName);
if (!await queueClient.ExistsAsync(cancellationToken))
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Queue '{_queueName}' not exists"));
}
await queueClient.GetPropertiesAsync(cancellationToken);
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public BlobTriggerBinding(ParameterInfo parameter,
BlobServiceClient hostBlobServiceClient,
QueueServiceClient hostQueueServiceClient,
BlobServiceClient dataBlobServiceClient,
QueueServiceClient dataQueueServiceClient,
IBlobPathSource path,
BlobTriggerSource blobTriggerSource,
IHostIdProvider hostIdProvider,
BlobsOptions blobsOptions,
IWebJobsExceptionHandler exceptionHandler,
IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
BlobTriggerQueueWriterFactory blobTriggerQueueWriterFactory,
ISharedContextProvider sharedContextProvider,
IHostSingletonManager singletonManager,
ILoggerFactory loggerFactory)
{
_parameter = parameter ?? throw new ArgumentNullException(nameof(parameter));
_hostBlobServiceClient = hostBlobServiceClient ?? throw new ArgumentNullException(nameof(hostBlobServiceClient));
_hostQueueServiceClient = hostQueueServiceClient ?? throw new ArgumentNullException(nameof(hostQueueServiceClient));
_dataBlobServiceClient = dataBlobServiceClient ?? throw new ArgumentNullException(nameof(dataBlobServiceClient));
_dataQueueServiceClient = dataQueueServiceClient ?? throw new ArgumentNullException(nameof(dataQueueServiceClient));
_accountName = _dataBlobServiceClient.AccountName;
_path = path ?? throw new ArgumentNullException(nameof(path));
_blobTriggerSource = blobTriggerSource;
_hostIdProvider = hostIdProvider ?? throw new ArgumentNullException(nameof(hostIdProvider));
_blobsOptions = blobsOptions ?? throw new ArgumentNullException(nameof(blobsOptions));
_exceptionHandler = exceptionHandler ?? throw new ArgumentNullException(nameof(exceptionHandler));
_blobWrittenWatcherSetter = blobWrittenWatcherSetter ?? throw new ArgumentNullException(nameof(blobWrittenWatcherSetter));
_blobTriggerQueueWriterFactory = blobTriggerQueueWriterFactory ?? throw new ArgumentNullException(nameof(blobTriggerQueueWriterFactory));
_sharedContextProvider = sharedContextProvider ?? throw new ArgumentNullException(nameof(sharedContextProvider));
_singletonManager = singletonManager ?? throw new ArgumentNullException(nameof(singletonManager));
_loggerFactory = loggerFactory;
_converter = CreateConverter(_dataBlobServiceClient);
_bindingDataContract = CreateBindingDataContract(path);
}
/// <summary>
/// connection string is provided as env variable (most unsecure)
/// </summary>
/// <returns></returns>
private void TryCreateClientUsingConnStr()
{
logger.LogInformation("trying to access queue using connection string...");
if (!string.IsNullOrEmpty(queueSettings.ConnectionStringSecretName))
{
try
{
var storageConnectionString = Environment.GetEnvironmentVariable(queueSettings.ConnectionStringEnvName);
if (!string.IsNullOrEmpty(storageConnectionString))
{
var queueServiceClient = new QueueServiceClient(storageConnectionString, new QueueClientOptions());
VerifyQueueServiceClient(queueServiceClient, queueSettings.QueueName);
QueueClient = queueServiceClient.GetQueueClient(queueSettings.QueueName);
DeadLetterQueueClient = queueServiceClient.GetQueueClient(queueSettings.DeadLetterQueueName);
logger.LogInformation("Succeed to access queue using connstr from env");
}
}
catch (Exception ex)
{
logger.LogError(ex, "trying to access queue using connection string...");
}
}
}
public AzureStorageEndToEndTests(TestFixture fixture)
{
_queueServiceClient = fixture.QueueServiceClient;
_blobServiceClient = fixture.BlobServiceClient;
}
public void UpdateMessage_UpdateContent_UpdatesContentOfMessageInQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var itemFromQueue = _util.GetItemFromQueue(queueName);
var newString = Convert.ToBase64String(Encoding.ASCII.GetBytes("2")); // the official SDK base 64's the values automatically
client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, newString);
var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
Assert.IsNotNull(itemFromQueueAgain);
Assert.AreEqual(itemFromQueue.Id, itemFromQueueAgain.Id);
Assert.AreEqual("1", itemFromQueue.AsString);
Assert.AreEqual("2", itemFromQueueAgain.AsString);
}
public async Task ClearMessagesAsync_MessagesInQueue_LeavesQueueEmpty()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1", "2", "3", "4" });
await client.ClearMessagesAsync(queueName);
_util.AssertQueueIsEmpty(queueName);
}
public QueueServiceClientByConnectionString(string connectionString)
{
ConnectionStringValidator.ThrowIfPremiumEndpointConnectionString(connectionString);
Client = new QueueServiceClient(connectionString);
}
public async Task DeleteMessageAsync_ValidMessage_DeletesItFromTheQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var itemFromQueue = _util.GetItemFromQueue(queueName);
await client.DeleteMessageAsync(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt);
_util.AssertQueueIsEmpty(queueName);
}
public async Task PeekMessagesAsync_NonExistentQueue_ThrowsQueueDoesNotExistException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
var response = await client.PeekMessagesAsync(queueName, 32);
// expects exception
}
public void PeekMessages_RequestItem_DoesNotDequeueTheItem()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var peekResponse = client.PeekMessages(queueName, 1);
Assert.AreEqual(1, peekResponse.Messages.Count);
var getResponse = client.GetMessages(queueName, 1);
Assert.AreEqual(1, getResponse.Messages.Count);
}
public static IWebJobsBuilder UseQueueService(this IWebJobsBuilder builder, QueueServiceClient queueServiceClient)
{
builder.Services.Add(ServiceDescriptor.Singleton <QueueServiceClientProvider>(new FakeQueueServiceClientProvider(queueServiceClient)));
return(builder);
}
public void SetUp()
{
queueServiceClient = AzuriteNUnitFixture.Instance.GetQueueServiceClient();
blobServiceClient = AzuriteNUnitFixture.Instance.GetBlobServiceClient();
blobServiceClient.GetBlobContainerClient(ContainerName).DeleteIfExists();
}
public QueuePersister(IAzureClientFactory <QueueServiceClient> clientFactory)
{
_client = clientFactory.CreateClient(ServiceCollectionExtensions.StorageClientName);
}
public QueueProvider(QueueServiceClient queueServiceClient, ILogger <QueueProvider> logger)
{
this._queueServiceClient = queueServiceClient;
this._logger = logger;
}
public async Task UpdateMessageAsync_NonExistentMessage_ThrowsException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
await client.UpdateMessageAsync(queueName, "123-abc", FakePopReceipt, 0);
// expects exception
}
public async Task InitializeAsync(WebJobsTestEnvironment testEnvironment)
{
RandomNameResolver nameResolver = new TestNameResolver();
Host = new HostBuilder()
.ConfigureDefaultTestHost <MultipleStorageAccountsEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(nameResolver);
})
.Build();
BlobServiceClient1 = new BlobServiceClient(testEnvironment.PrimaryStorageAccountConnectionString);
BlobServiceClient2 = new BlobServiceClient(testEnvironment.SecondaryStorageAccountConnectionString);
QueueServiceClient1 = new QueueServiceClient(testEnvironment.PrimaryStorageAccountConnectionString);
QueueServiceClient2 = new QueueServiceClient(testEnvironment.SecondaryStorageAccountConnectionString);
await CleanContainersAsync();
string inputName = nameResolver.ResolveInString(Input);
var inputContainer1 = BlobServiceClient1.GetBlobContainerClient(inputName);
await inputContainer1.CreateIfNotExistsAsync();
string outputName = nameResolver.ResolveWholeString(Output);
OutputContainer1 = BlobServiceClient1.GetBlobContainerClient(outputName);
await OutputContainer1.CreateIfNotExistsAsync();
var inputContainer2 = BlobServiceClient2.GetBlobContainerClient(inputName);
await inputContainer2.CreateIfNotExistsAsync();
OutputContainer2 = BlobServiceClient2.GetBlobContainerClient(outputName);
await OutputContainer2.CreateIfNotExistsAsync();
var inputQueue1 = QueueServiceClient1.GetQueueClient(inputName);
await inputQueue1.CreateIfNotExistsAsync();
OutputQueue1 = QueueServiceClient1.GetQueueClient(outputName);
await OutputQueue1.CreateIfNotExistsAsync();
var inputQueue2 = QueueServiceClient2.GetQueueClient(inputName);
await inputQueue2.CreateIfNotExistsAsync();
OutputQueue2 = QueueServiceClient2.GetQueueClient(outputName);
await OutputQueue2.CreateIfNotExistsAsync();
string outputTableName = nameResolver.ResolveWholeString(OutputTableName);
// upload some test blobs to the input containers of both storage accounts
BlockBlobClient blob = inputContainer1.GetBlockBlobClient("blob1");
await blob.UploadTextAsync(TestData);
blob = inputContainer2.GetBlockBlobClient("blob2");
await blob.UploadTextAsync(TestData);
// upload some test queue messages to the input queues of both storage accounts
await inputQueue1.SendMessageAsync(TestData);
await inputQueue2.SendMessageAsync(TestData);
Host.Start();
}
public async Task <DisposingQueue> GetTestQueueAsync(
QueueServiceClient service = default,
IDictionary <string, string> metadata = default)
=> await QueuesClientBuilder.GetTestQueueAsync(service, metadata);
/// <summary>
/// TODO.
/// </summary>
public StorageAccount(BlobServiceClient blobServiceClient, QueueServiceClient queueServiceClient)
{
_blobServiceClient = blobServiceClient;
_queueServiceClient = queueServiceClient;
}
public async Task PeekMessagesAsync_EmptyQueue_ReturnsEmptyCollection()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
var response = await client.PeekMessagesAsync(queueName, 32);
Assert.IsEmpty(response.Messages);
}
public void PutMessage_ValidMessageWithVisibilityTimeout_IsNotVisibleInQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
string message = "Unit Test Message";
client.PutMessage(queueName, message, visibilityTimeout: 5);
_util.AssertQueueInvisibleMessage(queueName);
}
public void DeleteMessage_BadlyFormattedPopReceipt_ThrowsInvalidQueryParameterException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
client.DeleteMessage(queueName, "abc-123", "bad format");
// expects exception
}
public static async Task CreateAsync(string account, string key, string queueName)
{
QueueServiceClient client = new QueueServiceClient(Client.GetConnectionString(account, key));
await client.CreateQueueAsync(queueName);
}
public async Task DeleteMessageAsync_NonexistentMessage_ThrowsMessageNotFoundException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
await client.DeleteMessageAsync(queueName, "abc-123", FakePopReceipt);
// expects exception
}
public void SetUp()
{
_fixture = new AzureStorageEndToEndTests.TestFixture(TestEnvironment);
_queueServiceClient = _fixture.QueueServiceClient;
_blobServiceClient = _fixture.BlobServiceClient;
}
public void ClearMessages_NoMessagesInQueue_LeavesQueueEmpty()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
client.ClearMessages(queueName);
_util.AssertQueueIsEmpty(queueName);
}
public void UpdateMessage_DifferentMessageText_ChangesMessageText()
{
const string rawFirstText = "1";
const string rawSecondText = "2";
var firstText = Convert.ToBase64String(Encoding.UTF8.GetBytes(rawFirstText));
var secondText = Convert.ToBase64String(Encoding.UTF8.GetBytes(rawSecondText));
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { firstText });
var itemFromQueue = _util.GetItemFromQueue(queueName, 1);
client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, secondText);
var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
Assert.AreEqual(rawSecondText, itemFromQueueAgain.AsString);
}
public async Task ClearMessagesAsync_QueueDoesNotExist_ThrowsQueueNotFoundException()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
await client.ClearMessagesAsync(queueName);
//expects exception
}
public static IWebJobsBuilder UseStorageServices(this IWebJobsBuilder builder, BlobServiceClient blobServiceClient, QueueServiceClient queueServiceClient)
{
builder.Services.AddSingleton <BlobServiceClientProvider>(new FakeBlobServiceClientProvider(blobServiceClient));
builder.Services.AddSingleton <QueueServiceClientProvider>(new FakeQueueServiceClientProvider(queueServiceClient));
return(builder);
}
public void UpdateMessage_ExtendVisibility_ExtendsMessageVisibilityInTheQueue()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var itemFromQueue = _util.GetItemFromQueue(queueName, 1);
var response = client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 30);
Assert.IsNotNullOrEmpty(response.PopReceipt);
Thread.Sleep(2000); // longer than the original visibility timeout
var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
Assert.IsNull(itemFromQueueAgain);
}
public Task DeleteQueue(QueueServiceClient queueServiceClient, string queueName)
{
return(queueServiceClient.DeleteQueueAsync(queueName));
}
public void UpdateMessage_InvalidXMLMessageTextCharacters_DoesNotThrowException()
{
const string rawFirstText = "<QueueMessage><MessageText>Test</MessageText></QueueMessage>";
const string rawSecondText = "{\"KeyValueLogPayload\": {\"UserIP\": \"::1\",\"URL\": \"http://fakeurl/foo?bar=baz&baz=bar\"}}";
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { rawFirstText });
var itemFromQueue = _util.GetItemFromQueue(queueName, 1);
Assert.DoesNotThrow(() =>
{
client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, rawSecondText);
});
}
public FakeQueueServiceClientProvider(QueueServiceClient queueServiceClient)
: base(null, null, null)
{
_queueServiceClient = queueServiceClient;
}
public async Task UpdateMessageAsync_ClearVisibility_AllowsMessageToBeRetrievedAgain()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var itemFromQueue = _util.GetItemFromQueue(queueName);
await client.UpdateMessageAsync(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0);
var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
Assert.IsNotNull(itemFromQueueAgain);
Assert.AreEqual(itemFromQueue.Id, itemFromQueueAgain.Id);
}
public void PeekMessages_RequestUndefinedNumberOfItemsFromFullQueue_ReturnsOneItem()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, Enumerable.Range(1, 40).Select(n => n.ToString()).ToList());
var expectedMessage = "1";
var response = client.PeekMessages(queueName);
Assert.AreEqual(1, response.Messages.Count);
var message = response.Messages.Single();
// Base 64 encode the expected message since Azure SDK did so when enqueueing it
Assert.AreEqual(Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(expectedMessage)), message.MessageText);
}
static async Task DeleteQueueAsync(string connectionString, string queueName)
{
QueueServiceClient serviceClient = new QueueServiceClient(connectionString);
QueueClient queue = serviceClient.GetQueueClient(queueName);
await queue.DeleteAsync();
}
public ServersController()
{
_context = new ModelDataContext(System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString);
_queueService = new QueueServiceClient();
}
/// <summary>
/// Create a new <see cref="EncryptedQueueClient"/> object by
/// concatenating <paramref name="queueName"/> to
/// the end of the <paramref name="client"/>'s
/// <see cref="QueueServiceClient.Uri"/>. The new
/// <see cref="EncryptedQueueClient"/>
/// uses the same request policy pipeline as the
/// <see cref="QueueServiceClient"/>.
/// </summary>
/// <param name="client">The <see cref="QueueServiceClient"/>.</param>
/// <param name="queueName">The name of the encrypted block blob.</param>
/// <returns>A new <see cref="EncryptedQueueClient"/> instance.</returns>
public static EncryptedQueueClient GetEncryptedQueueClient(
this QueueServiceClient client,
string queueName)
=> new EncryptedQueueClient(client.Uri.AppendToPath(queueName), client.Pipeline, client.ClientDiagnostics);
static async Task CreateQueueAsync(string connectionString, string queueName)
{
QueueServiceClient serviceClient = new QueueServiceClient(connectionString);
QueueClient queue = await serviceClient.CreateQueueAsync(queueName);
}
public QueueMessage(string storageAccount)
{
_queueServiceClient = new QueueServiceClient(storageAccount);
}
public void SetUp()
{
_queueServiceClient = AzuriteNUnitFixture.Instance.GetQueueServiceClient();
}
public void SetUp()
{
queueServiceClient = AzuriteNUnitFixture.Instance.GetQueueServiceClient();
queueServiceClient.GetQueueClient(QueueName).DeleteIfExists();
}
public HostStartTests()
{
queueServiceClient = AzuriteNUnitFixture.Instance.GetQueueServiceClient();
}
public ServersController()
{
_context = new ModelDataContext(System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString);
_queueService = new QueueServiceClient();
}
public void GetMessages_RequestItemFromPopulatedQueue_ReturnsItemWithPopReceiptAndDequeueCount()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, new List<string>() { "1" });
var response = client.GetMessages(queueName, 1, 30);
Assert.AreEqual(1, response.Messages.Count);
var message = response.Messages.Single();
Assert.IsNotNullOrEmpty(message.PopReceipt);
Assert.Greater(message.DequeueCount, 0);
}
public QueueWithCreateIfNotExists(QueueServiceClient queueService, string queueName) => this.queue = queueService.GetQueueClient(queueName);
public void PeekMessages_Request32ItemsFromFullQueue_Returns32Items()
{
IQueueServiceClient client = new QueueServiceClient(_accountSettings);
var queueName = GenerateSampleQueueName();
_util.CreateQueue(queueName);
_util.AddItemsToQueue(queueName, Enumerable.Range(1, 40).Select(n => n.ToString()).ToList());
var response = client.PeekMessages(queueName, 32);
Assert.AreEqual(32, response.Messages.Count);
for (int i = 1; i <= 32; i++)
{
// Base 64 encode the expected message since Azure SDK did so when enqueueing it
var expectedMessage = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(i.ToString()));
Assert.IsTrue(response.Messages.Any(m => m.MessageText.Equals(expectedMessage)));
}
}
