public async Task ThrowsIfEntityAlreadyExists() { var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString); var queueName = Guid.NewGuid().ToString("D").Substring(0, 8); var topicName = Guid.NewGuid().ToString("D").Substring(0, 8); var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8); await client.CreateQueueAsync(queueName); await client.CreateTopicAsync(topicName); await client.CreateSubscriptionAsync(topicName, subscriptionName); Assert.That( async() => await client.CreateQueueAsync(queueName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityAlreadyExists)); Assert.That( async() => await client.CreateTopicAsync(topicName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityAlreadyExists)); Assert.That( async() => await client.CreateSubscriptionAsync(topicName, subscriptionName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityAlreadyExists)); await client.DeleteQueueAsync(queueName); await client.DeleteTopicAsync(topicName); }
public async Task ForwardingEntity() { // queueName--Fwd to--> destinationName--fwd dlq to-- > dqlDestinationName var queueName = Guid.NewGuid().ToString("D").Substring(0, 8); var destinationName = Guid.NewGuid().ToString("D").Substring(0, 8); var dlqDestinationName = Guid.NewGuid().ToString("D").Substring(0, 8); var mgmtClient = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString); await mgmtClient.CreateQueueAsync(dlqDestinationName); await mgmtClient.CreateQueueAsync( new CreateQueueOptions(destinationName) { ForwardDeadLetteredMessagesTo = dlqDestinationName }); await mgmtClient.CreateQueueAsync( new CreateQueueOptions(queueName) { ForwardTo = destinationName }); await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = sbClient.CreateSender(queueName); await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "mid" }); ServiceBusReceiver receiver = sbClient.CreateReceiver(destinationName); ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); await receiver.DeadLetterMessageAsync(msg.LockToken); receiver = sbClient.CreateReceiver(dlqDestinationName); msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); await receiver.CompleteMessageAsync(msg.LockToken); await mgmtClient.DeleteQueueAsync(queueName); await mgmtClient.DeleteQueueAsync(destinationName); await mgmtClient.DeleteQueueAsync(dlqDestinationName); }
public async Task GetUpdateDeleteQueue() { string queueName = Guid.NewGuid().ToString("D").Substring(0, 8); string connectionString = TestEnvironment.ServiceBusConnectionString; var client = new ServiceBusManagementClient(connectionString); var qd = new CreateQueueOptions(queueName); await client.CreateQueueAsync(qd); #region Snippet:GetQueue QueueProperties queue = await client.GetQueueAsync(queueName); #endregion #region Snippet:UpdateQueue queue.LockDuration = TimeSpan.FromSeconds(60); QueueProperties updatedQueue = await client.UpdateQueueAsync(queue); #endregion Assert.AreEqual(TimeSpan.FromSeconds(60), updatedQueue.LockDuration); #region Snippet:DeleteQueue await client.DeleteQueueAsync(queueName); #endregion Assert.That( async() => await client.GetQueueAsync(queueName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound)); }
public async Task CreateQueue() { string queueName = Guid.NewGuid().ToString("D").Substring(0, 8); string connectionString = TestEnvironment.ServiceBusConnectionString; try { #region Snippet:CreateQueue //@@ string connectionString = "<connection_string>"; //@@ string queueName = "<queue_name>"; var client = new ServiceBusManagementClient(connectionString); var queueDescription = new QueueDescription(queueName) { AutoDeleteOnIdle = TimeSpan.FromDays(7), DefaultMessageTimeToLive = TimeSpan.FromDays(2), DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1), EnableBatchedOperations = true, DeadLetteringOnMessageExpiration = true, EnablePartitioning = false, ForwardDeadLetteredMessagesTo = null, ForwardTo = null, LockDuration = TimeSpan.FromSeconds(45), MaxDeliveryCount = 8, MaxSizeInMegabytes = 2048, RequiresDuplicateDetection = true, RequiresSession = true, UserMetadata = "some metadata" }; queueDescription.AuthorizationRules.Add(new SharedAccessAuthorizationRule( "allClaims", new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen })); // The CreateQueueAsync method will return the created queue // which would include values for all of the // QueueDescription properties (the service will supply // default values for properties not included in the creation). QueueDescription createdQueue = await client.CreateQueueAsync(queueDescription); #endregion Assert.AreEqual(queueDescription, createdQueue); } finally { await new ServiceBusManagementClient(connectionString).DeleteQueueAsync(queueName); } }
public async Task AuthenticateWithAAD() { var queueName = Guid.NewGuid().ToString("D").Substring(0, 8); var topicName = Guid.NewGuid().ToString("D").Substring(0, 8); var client = new ServiceBusManagementClient(TestEnvironment.FullyQualifiedNamespace, TestEnvironment.Credential); var queueOptions = new CreateQueueOptions(queueName); QueueProperties createdQueue = await client.CreateQueueAsync(queueOptions); Assert.AreEqual(queueOptions, new CreateQueueOptions(createdQueue)); var topicOptions = new CreateTopicOptions(topicName); TopicProperties createdTopic = await client.CreateTopicAsync(topicOptions); Assert.AreEqual(topicOptions, new CreateTopicOptions(createdTopic)); await client.DeleteQueueAsync(queueName); await client.DeleteTopicAsync(topicName); }
public async Task AuthenticateWithAAD() { var queueName = Guid.NewGuid().ToString("D").Substring(0, 8); var topicName = Guid.NewGuid().ToString("D").Substring(0, 8); var client = new ServiceBusManagementClient(TestEnvironment.FullyQualifiedNamespace, TestEnvironment.Credential); QueueDescription queueDescription = new QueueDescription(queueName); QueueDescription createdQueue = await client.CreateQueueAsync(queueDescription); Assert.AreEqual(queueDescription, createdQueue); TopicDescription topicDescription = new TopicDescription(topicName); TopicDescription createdTopic = await client.CreateTopicAsync(topicDescription); Assert.AreEqual(topicDescription, createdTopic); await client.DeleteQueueAsync(queueName); await client.DeleteTopicAsync(topicName); }
public async Task ThrowsIfEntityDoesNotExist() { var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString); Assert.That( async() => await client.GetQueueAsync("NonExistingPath"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.GetQueueAsync("NonExistingTopic"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.GetSubscriptionAsync("NonExistingTopic", "NonExistingPath"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.UpdateQueueAsync(new QueueProperties("NonExistingPath")), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.UpdateTopicAsync(new TopicProperties("NonExistingPath")), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.UpdateSubscriptionAsync(new SubscriptionProperties("NonExistingTopic", "NonExistingPath")), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.DeleteQueueAsync("NonExistingPath"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.DeleteTopicAsync("NonExistingPath"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.DeleteSubscriptionAsync("NonExistingTopic", "NonExistingPath"), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); var queueName = Guid.NewGuid().ToString("D").Substring(0, 8); var topicName = Guid.NewGuid().ToString("D").Substring(0, 8); await client.CreateQueueAsync(queueName); await client.CreateTopicAsync(topicName); Assert.That( async() => await client.GetQueueAsync(topicName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); Assert.That( async() => await client.GetTopicAsync(queueName), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); await client.DeleteQueueAsync(queueName); await client.DeleteTopicAsync(topicName); }
public async Task GetQueueRuntimeInfo() { var queueName = nameof(GetQueueRuntimeInfo).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8); var mgmtClient = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString); await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); QueueProperties queue = await mgmtClient.CreateQueueAsync(queueName); queue = await mgmtClient.GetQueueAsync(queueName); // Changing Last Updated Time queue.AutoDeleteOnIdle = TimeSpan.FromMinutes(100); QueueProperties updatedQueue = await mgmtClient.UpdateQueueAsync(queue); // Populating 1 active message, 1 dead letter message and 1 scheduled message // Changing Last Accessed Time ServiceBusSender sender = sbClient.CreateSender(queueName); await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "1" }); await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "2" }); await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "3", ScheduledEnqueueTime = DateTime.UtcNow.AddDays(1) }); ServiceBusReceiver receiver = sbClient.CreateReceiver(queueName); ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); await receiver.DeadLetterMessageAsync(msg.LockToken); List <QueueRuntimeProperties> runtimeInfoList = new List <QueueRuntimeProperties>(); await foreach (QueueRuntimeProperties queueRuntimeInfo in mgmtClient.GetQueuesRuntimePropertiesAsync()) { runtimeInfoList.Add(queueRuntimeInfo); } runtimeInfoList = runtimeInfoList.Where(e => e.Name.StartsWith(nameof(GetQueueRuntimeInfo).ToLower())).ToList(); Assert.True(runtimeInfoList.Count == 1, $"Expected 1 queue but {runtimeInfoList.Count} queues returned"); QueueRuntimeProperties runtimeInfo = runtimeInfoList.First(); Assert.NotNull(runtimeInfo); Assert.AreEqual(queueName, runtimeInfo.Name); Assert.True(runtimeInfo.CreatedAt < runtimeInfo.UpdatedAt); Assert.True(runtimeInfo.UpdatedAt < runtimeInfo.AccessedAt); Assert.AreEqual(1, runtimeInfo.ActiveMessageCount); Assert.AreEqual(1, runtimeInfo.DeadLetterMessageCount); Assert.AreEqual(1, runtimeInfo.ScheduledMessageCount); Assert.AreEqual(3, runtimeInfo.TotalMessageCount); Assert.True(runtimeInfo.SizeInBytes > 0); QueueRuntimeProperties singleRuntimeInfo = await mgmtClient.GetQueueRuntimePropertiesAsync(runtimeInfo.Name); Assert.AreEqual(runtimeInfo.AccessedAt, singleRuntimeInfo.AccessedAt); Assert.AreEqual(runtimeInfo.CreatedAt, singleRuntimeInfo.CreatedAt); Assert.AreEqual(runtimeInfo.UpdatedAt, singleRuntimeInfo.UpdatedAt); Assert.AreEqual(runtimeInfo.TotalMessageCount, singleRuntimeInfo.TotalMessageCount); Assert.AreEqual(runtimeInfo.ActiveMessageCount, singleRuntimeInfo.ActiveMessageCount); Assert.AreEqual(runtimeInfo.DeadLetterMessageCount, singleRuntimeInfo.DeadLetterMessageCount); Assert.AreEqual(runtimeInfo.ScheduledMessageCount, singleRuntimeInfo.ScheduledMessageCount); Assert.AreEqual(runtimeInfo.SizeInBytes, singleRuntimeInfo.SizeInBytes); await mgmtClient.DeleteQueueAsync(queueName); }
public async Task BasicQueueCrudOperations() { var queueName = nameof(BasicQueueCrudOperations).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8); var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString); var queueOptions = new CreateQueueOptions(queueName) { AutoDeleteOnIdle = TimeSpan.FromHours(1), DefaultMessageTimeToLive = TimeSpan.FromDays(2), DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1), EnableBatchedOperations = false, DeadLetteringOnMessageExpiration = true, EnablePartitioning = false, ForwardDeadLetteredMessagesTo = null, ForwardTo = null, LockDuration = TimeSpan.FromSeconds(45), MaxDeliveryCount = 8, MaxSizeInMegabytes = 2048, RequiresDuplicateDetection = true, RequiresSession = false, UserMetadata = nameof(BasicQueueCrudOperations), Status = EntityStatus.Disabled }; queueOptions.AuthorizationRules.Add(new SharedAccessAuthorizationRule( "allClaims", new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen })); QueueProperties createdQueue = await client.CreateQueueAsync(queueOptions); Assert.AreEqual(queueOptions, new CreateQueueOptions(createdQueue)); QueueProperties getQueue = await client.GetQueueAsync(queueOptions.Name); Assert.AreEqual(createdQueue, getQueue); getQueue.EnableBatchedOperations = false; getQueue.MaxDeliveryCount = 9; getQueue.AuthorizationRules.Clear(); getQueue.AuthorizationRules.Add(new SharedAccessAuthorizationRule( "noManage", new[] { AccessRights.Send, AccessRights.Listen })); getQueue.EnableBatchedOperations = true; getQueue.Status = EntityStatus.Disabled; getQueue.AutoDeleteOnIdle = TimeSpan.FromMinutes(6); getQueue.MaxSizeInMegabytes = 1024; QueueProperties updatedQueue = await client.UpdateQueueAsync(getQueue); Assert.AreEqual(getQueue, updatedQueue); bool isExists = await client.QueueExistsAsync(queueName); Assert.True(isExists); List <QueueProperties> queueList = new List <QueueProperties>(); await foreach (QueueProperties queue in client.GetQueuesAsync()) { queueList.Add(queue); } queueList = queueList.Where(e => e.Name.StartsWith(nameof(BasicQueueCrudOperations).ToLower())).ToList(); Assert.True(queueList.Count == 1, $"Expected 1 queue but {queueList.Count} queues returned"); Assert.AreEqual(queueList.First().Name, queueName); await client.DeleteQueueAsync(updatedQueue.Name); Assert.That( async() => await client.GetQueueAsync(queueOptions.Name), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound)); isExists = await client.QueueExistsAsync(queueName); Assert.False(isExists); }