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 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))); } }