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 CorrelationFilterProperties()
{
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
await client.CreateSubscriptionAsync(topicName, subscriptionName);
var filter = new CorrelationRuleFilter();
filter.Properties.Add("stringKey", "stringVal");
filter.Properties.Add("intKey", 5);
filter.Properties.Add("dateTimeKey", DateTime.UtcNow);
RuleProperties rule = await client.CreateRuleAsync(
topicName,
subscriptionName,
new CreateRuleOptions("rule1", filter));
Assert.True(filter.Properties.Count == 3);
Assert.AreEqual(filter, rule.Filter);
await client.DeleteTopicAsync(topicName);
}
public async Task SqlFilterParams()
{
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
await client.CreateTopicAsync(topicName);
await client.CreateSubscriptionAsync(topicName, subscriptionName);
SqlRuleFilter sqlFilter = new SqlRuleFilter(
"PROPERTY(@propertyName) = @stringPropertyValue " +
"AND PROPERTY(intProperty) = @intPropertyValue " +
"AND PROPERTY(longProperty) = @longPropertyValue " +
"AND PROPERTY(boolProperty) = @boolPropertyValue " +
"AND PROPERTY(doubleProperty) = @doublePropertyValue ")
{
Parameters =
{
{ "@propertyName", "MyProperty" },
{ "@stringPropertyValue", "string" },
{ "@intPropertyValue", 3 },
{ "@longPropertyValue", 3L },
{ "@boolPropertyValue", true },
{ "@doublePropertyValue", 3.0 },
}
};
RuleDescription rule = await client.CreateRuleAsync(topicName, subscriptionName, new RuleDescription("rule1", sqlFilter));
Assert.AreEqual(sqlFilter, rule.Filter);
await client.DeleteTopicAsync(topicName);
}
public async Task CreateTopicAndSubscription()
{
#if !SNIPPET
string topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
string subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
string connectionString = TestEnvironment.ServiceBusConnectionString;
var client = new ServiceBusAdministrationClient(connectionString);
#endif
try
{
#region Snippet:CreateTopicAndSubscription
#if SNIPPET
string connectionString = "<connection_string>";
string topicName = "<topic_name>";
var client = new ServiceBusManagementClient(connectionString);
#endif
var topicOptions = new CreateTopicOptions(topicName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
EnablePartitioning = false,
MaxSizeInMegabytes = 2048,
RequiresDuplicateDetection = true,
UserMetadata = "some metadata"
};
topicOptions.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
TopicProperties createdTopic = await client.CreateTopicAsync(topicOptions);
#if SNIPPET
string subscriptionName = "<subscription_name>";
#endif
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
EnableBatchedOperations = true,
UserMetadata = "some metadata"
};
SubscriptionProperties createdSubscription = await client.CreateSubscriptionAsync(subscriptionOptions);
#endregion
Assert.AreEqual(topicOptions, new CreateTopicOptions(createdTopic)
{
MaxMessageSizeInKilobytes = topicOptions.MaxMessageSizeInKilobytes
});
Assert.AreEqual(subscriptionOptions, new CreateSubscriptionOptions(createdSubscription));
}
finally
{
await client.DeleteTopicAsync(topicName);
}
}
public async Task GetUpdateDeleteTopicAndSubscription()
{
string topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
string subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
string connectionString = TestEnvironment.ServiceBusConnectionString;
var client = new ServiceBusManagementClient(connectionString);
var topicOptions = new CreateTopicOptions(topicName);
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName);
await client.CreateTopicAsync(topicOptions);
await client.CreateSubscriptionAsync(subscriptionOptions);
#region Snippet:GetTopic
TopicProperties topic = await client.GetTopicAsync(topicName);
#endregion
#region Snippet:GetSubscription
SubscriptionProperties subscription = await client.GetSubscriptionAsync(topicName, subscriptionName);
#endregion
#region Snippet:UpdateTopic
topic.UserMetadata = "some metadata";
TopicProperties updatedTopic = await client.UpdateTopicAsync(topic);
#endregion
Assert.AreEqual("some metadata", updatedTopic.UserMetadata);
#region Snippet:UpdateSubscription
subscription.UserMetadata = "some metadata";
SubscriptionProperties updatedSubscription = await client.UpdateSubscriptionAsync(subscription);
#endregion
Assert.AreEqual("some metadata", updatedSubscription.UserMetadata);
// need to delete the subscription before the topic, as deleting
// the topic would automatically delete the subscription
#region Snippet:DeleteSubscription
await client.DeleteSubscriptionAsync(topicName, subscriptionName);
#endregion
Assert.That(
async() =>
await client.GetSubscriptionAsync(topicName, subscriptionName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
#region Snippet:DeleteTopic
await client.DeleteTopicAsync(topicName);
#endregion
Assert.That(
async() =>
await client.GetTopicAsync(topicName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
}
public async Task GetTopicRuntimeInfo()
{
var topicName = nameof(GetTopicRuntimeInfo).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
TopicProperties getTopic = await client.GetTopicAsync(topicName);
// Changing Last Updated Time
getTopic.AutoDeleteOnIdle = TimeSpan.FromMinutes(100);
await client.UpdateTopicAsync(getTopic);
await client.CreateSubscriptionAsync(topicName, subscriptionName);
List <TopicRuntimeProperties> runtimeInfoList = new List <TopicRuntimeProperties>();
await foreach (TopicRuntimeProperties topicRuntimeInfo in client.GetTopicsRuntimePropertiesAsync())
{
runtimeInfoList.Add(topicRuntimeInfo);
}
runtimeInfoList = runtimeInfoList.Where(e => e.Name.StartsWith(nameof(GetTopicRuntimeInfo).ToLower())).ToList();
Assert.True(runtimeInfoList.Count == 1, $"Expected 1 topic but {runtimeInfoList.Count} topics returned");
TopicRuntimeProperties runtimeInfo = runtimeInfoList.First();
Assert.NotNull(runtimeInfo);
Assert.AreEqual(topicName, runtimeInfo.Name);
Assert.True(runtimeInfo.CreatedAt < runtimeInfo.UpdatedAt);
Assert.True(runtimeInfo.UpdatedAt < runtimeInfo.AccessedAt);
Assert.AreEqual(1, runtimeInfo.SubscriptionCount);
TopicRuntimeProperties singleTopicRI = await client.GetTopicRuntimePropertiesAsync(runtimeInfo.Name);
Assert.AreEqual(runtimeInfo.AccessedAt, singleTopicRI.AccessedAt);
Assert.AreEqual(runtimeInfo.CreatedAt, singleTopicRI.CreatedAt);
Assert.AreEqual(runtimeInfo.UpdatedAt, singleTopicRI.UpdatedAt);
Assert.AreEqual(runtimeInfo.SizeInBytes, singleTopicRI.SizeInBytes);
Assert.AreEqual(runtimeInfo.SubscriptionCount, singleTopicRI.SubscriptionCount);
Assert.AreEqual(runtimeInfo.ScheduledMessageCount, singleTopicRI.ScheduledMessageCount);
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);
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 BasicTopicCrudOperations()
{
var topicName = nameof(BasicTopicCrudOperations).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
var options = new CreateTopicOptions(topicName)
{
AutoDeleteOnIdle = TimeSpan.FromHours(1),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
EnablePartitioning = false,
MaxSizeInMegabytes = 2048,
RequiresDuplicateDetection = true,
UserMetadata = nameof(BasicTopicCrudOperations)
};
options.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
TopicProperties createdTopic = await client.CreateTopicAsync(options);
Assert.AreEqual(options, new CreateTopicOptions(createdTopic));
TopicProperties getTopic = await client.GetTopicAsync(options.Name);
Assert.AreEqual(createdTopic, getTopic);
getTopic.EnableBatchedOperations = false;
getTopic.DefaultMessageTimeToLive = TimeSpan.FromDays(3);
getTopic.DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(2);
getTopic.EnableBatchedOperations = false;
getTopic.MaxSizeInMegabytes = 1024;
TopicProperties updatedTopic = await client.UpdateTopicAsync(getTopic);
Assert.AreEqual(getTopic, updatedTopic);
bool exists = await client.TopicExistsAsync(topicName);
Assert.True(exists);
List <TopicProperties> topicList = new List <TopicProperties>();
await foreach (TopicProperties topic in client.GetTopicsAsync())
{
topicList.Add(topic);
}
topicList = topicList.Where(e => e.Name.StartsWith(nameof(BasicTopicCrudOperations).ToLower())).ToList();
Assert.True(topicList.Count == 1, $"Expected 1 topic but {topicList.Count} topics returned");
Assert.AreEqual(topicList.First().Name, topicName);
await client.DeleteTopicAsync(updatedTopic.Name);
Assert.That(
async() =>
await client.GetTopicAsync(options.Name),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound));
exists = await client.TopicExistsAsync(topicName);
Assert.False(exists);
}
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 GetSubscriptionRuntimeInfoTest()
{
var topicName = nameof(GetSubscriptionRuntimeInfoTest).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
TopicProperties getTopic = await client.GetTopicAsync(topicName);
// Changing Last Updated Time
getTopic.AutoDeleteOnIdle = TimeSpan.FromMinutes(100);
await client.UpdateTopicAsync(getTopic);
SubscriptionProperties subscriptionDescription = await client.CreateSubscriptionAsync(topicName, subscriptionName);
// Changing Last Updated Time for subscription
subscriptionDescription.AutoDeleteOnIdle = TimeSpan.FromMinutes(100);
await client.UpdateSubscriptionAsync(subscriptionDescription);
// Populating 1 active message, 1 dead letter message and 1 scheduled message
// Changing Last Accessed Time
ServiceBusSender sender = sbClient.CreateSender(topicName);
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(topicName, subscriptionName);
ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync();
await receiver.DeadLetterMessageAsync(msg.LockToken);
List <SubscriptionRuntimeProperties> runtimeInfoList = new List <SubscriptionRuntimeProperties>();
await foreach (SubscriptionRuntimeProperties subscriptionRuntimeInfo in client.GetSubscriptionsRuntimePropertiesAsync(topicName))
{
runtimeInfoList.Add(subscriptionRuntimeInfo);
}
runtimeInfoList = runtimeInfoList.Where(e => e.TopicName.StartsWith(nameof(GetSubscriptionRuntimeInfoTest).ToLower())).ToList();
Assert.True(runtimeInfoList.Count == 1, $"Expected 1 subscription but {runtimeInfoList.Count} subscriptions returned");
SubscriptionRuntimeProperties runtimeInfo = runtimeInfoList.First();
Assert.NotNull(runtimeInfo);
Assert.AreEqual(topicName, runtimeInfo.TopicName);
Assert.AreEqual(subscriptionName, runtimeInfo.SubscriptionName);
Assert.True(runtimeInfo.CreatedAt < runtimeInfo.UpdatedAt);
Assert.True(runtimeInfo.UpdatedAt < runtimeInfo.AccessedAt);
Assert.AreEqual(1, runtimeInfo.ActiveMessageCount);
Assert.AreEqual(1, runtimeInfo.DeadLetterMessageCount);
Assert.AreEqual(2, runtimeInfo.TotalMessageCount);
SubscriptionRuntimeProperties singleRuntimeInfo = await client.GetSubscriptionRuntimePropertiesAsync(topicName, subscriptionName);
Assert.AreEqual(runtimeInfo.CreatedAt, singleRuntimeInfo.CreatedAt);
Assert.AreEqual(runtimeInfo.AccessedAt, singleRuntimeInfo.AccessedAt);
Assert.AreEqual(runtimeInfo.UpdatedAt, singleRuntimeInfo.UpdatedAt);
Assert.AreEqual(runtimeInfo.SubscriptionName, singleRuntimeInfo.SubscriptionName);
Assert.AreEqual(runtimeInfo.TotalMessageCount, singleRuntimeInfo.TotalMessageCount);
Assert.AreEqual(runtimeInfo.ActiveMessageCount, singleRuntimeInfo.ActiveMessageCount);
Assert.AreEqual(runtimeInfo.DeadLetterMessageCount, singleRuntimeInfo.DeadLetterMessageCount);
Assert.AreEqual(runtimeInfo.TopicName, singleRuntimeInfo.TopicName);
List <TopicRuntimeProperties> topicRuntimePropertiesList = new List <TopicRuntimeProperties>();
await foreach (TopicRuntimeProperties topicRuntime in client.GetTopicsRuntimePropertiesAsync())
{
topicRuntimePropertiesList.Add(topicRuntime);
}
topicRuntimePropertiesList = topicRuntimePropertiesList.Where(e => e.Name.StartsWith(nameof(GetSubscriptionRuntimeInfoTest).ToLower())).ToList();
Assert.True(topicRuntimePropertiesList.Count == 1, $"Expected 1 subscription but {topicRuntimePropertiesList.Count} subscriptions returned");
TopicRuntimeProperties topicRuntimeProperties = topicRuntimePropertiesList.First();
Assert.NotNull(topicRuntimeProperties);
Assert.AreEqual(topicName, topicRuntimeProperties.Name);
Assert.True(topicRuntimeProperties.CreatedAt < topicRuntimeProperties.UpdatedAt);
Assert.True(topicRuntimeProperties.UpdatedAt < topicRuntimeProperties.AccessedAt);
Assert.AreEqual(1, topicRuntimeProperties.ScheduledMessageCount);
TopicRuntimeProperties singleTopicRuntimeProperties = await client.GetTopicRuntimePropertiesAsync(topicName);
Assert.AreEqual(topicRuntimeProperties.CreatedAt, singleTopicRuntimeProperties.CreatedAt);
Assert.AreEqual(topicRuntimeProperties.AccessedAt, singleTopicRuntimeProperties.AccessedAt);
Assert.AreEqual(topicRuntimeProperties.UpdatedAt, singleTopicRuntimeProperties.UpdatedAt);
Assert.AreEqual(topicRuntimeProperties.ScheduledMessageCount, singleTopicRuntimeProperties.ScheduledMessageCount);
Assert.AreEqual(topicRuntimeProperties.Name, singleTopicRuntimeProperties.Name);
await client.DeleteTopicAsync(topicName);
}
public async Task BasicRuleCrudOperations()
{
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
var rule1 = new CreateRuleOptions
{
Filter = new TrueRuleFilter(),
Name = "rule1"
};
await client.CreateSubscriptionAsync(
new CreateSubscriptionOptions(topicName, subscriptionName),
rule1);
RuleProperties getRule1 = await client.GetRuleAsync(topicName, subscriptionName, "rule1");
Assert.AreEqual(rule1, new CreateRuleOptions(getRule1));
var sqlRuleFilter = new SqlRuleFilter("stringValue = @stringParam AND intValue = @intParam AND longValue = @longParam AND dateValue = @dateParam AND timeSpanValue = @timeSpanParam");
sqlRuleFilter.Parameters.Add("@stringParam", "string");
sqlRuleFilter.Parameters.Add("@intParam", 1);
sqlRuleFilter.Parameters.Add("@longParam", (long)12);
sqlRuleFilter.Parameters.Add("@dateParam", DateTime.UtcNow);
sqlRuleFilter.Parameters.Add("@timeSpanParam", TimeSpan.FromDays(1));
var rule2 = new CreateRuleOptions
{
Name = "rule2",
Filter = sqlRuleFilter,
Action = new SqlRuleAction("SET a='b'")
};
await client.CreateRuleAsync(topicName, subscriptionName, rule2);
RuleProperties getRule2 = await client.GetRuleAsync(topicName, subscriptionName, "rule2");
Assert.AreEqual(rule2, new CreateRuleOptions(getRule2));
var correlationRuleFilter = new CorrelationRuleFilter()
{
ContentType = "contentType",
CorrelationId = "correlationId",
Label = "label",
MessageId = "messageId",
ReplyTo = "replyTo",
ReplyToSessionId = "replyToSessionId",
SessionId = "sessionId",
To = "to"
};
correlationRuleFilter.Properties.Add("customKey", "customValue");
var rule3 = new CreateRuleOptions()
{
Name = "rule3",
Filter = correlationRuleFilter,
Action = null
};
await client.CreateRuleAsync(topicName, subscriptionName, rule3);
RuleProperties getRule3 = await client.GetRuleAsync(topicName, subscriptionName, "rule3");
Assert.AreEqual(rule3, new CreateRuleOptions(getRule3));
List <RuleProperties> ruleList = new List <RuleProperties>();
await foreach (RuleProperties rule in client.GetRulesAsync(topicName, subscriptionName))
{
ruleList.Add(rule);
}
RuleProperties[] ruleArr = ruleList.ToArray();
Assert.True(ruleArr.Length == 3);
Assert.AreEqual(rule1, new CreateRuleOptions(ruleArr[0]));
Assert.AreEqual(rule2, new CreateRuleOptions(ruleArr[1]));
Assert.AreEqual(rule3, new CreateRuleOptions(ruleArr[2]));
((CorrelationRuleFilter)getRule3.Filter).CorrelationId = "correlationIdModified";
SubscriptionProperties sub = await client.GetSubscriptionAsync(topicName, subscriptionName);
RuleProperties updatedRule3 = await client.UpdateRuleAsync(topicName, subscriptionName, getRule3);
Assert.AreEqual(getRule3, updatedRule3);
bool exists = await client.RuleExistsAsync(topicName, subscriptionName, rule1.Name);
Assert.True(exists);
await client.DeleteRuleAsync(topicName, subscriptionName, "rule1");
Assert.That(
async() =>
await client.GetRuleAsync(topicName, subscriptionName, "rule1"),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound));
exists = await client.RuleExistsAsync(topicName, subscriptionName, rule1.Name);
Assert.False(exists);
await client.DeleteTopicAsync(topicName);
}
public async Task BasicSubscriptionCrudOperations()
{
var topicName = nameof(BasicSubscriptionCrudOperations).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
var options = new CreateSubscriptionOptions(topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromHours(1),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
RequiresSession = true,
UserMetadata = nameof(BasicSubscriptionCrudOperations)
};
SubscriptionProperties createdSubscription = await client.CreateSubscriptionAsync(options);
Assert.AreEqual(options, new CreateSubscriptionOptions(createdSubscription));
SubscriptionProperties getSubscription = await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.AreEqual(options, new CreateSubscriptionOptions(getSubscription));
getSubscription.DefaultMessageTimeToLive = TimeSpan.FromDays(3);
getSubscription.MaxDeliveryCount = 9;
SubscriptionProperties updatedSubscription = await client.UpdateSubscriptionAsync(getSubscription);
Assert.AreEqual(getSubscription, updatedSubscription);
bool exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.True(exists);
List <SubscriptionProperties> subscriptionList = new List <SubscriptionProperties>();
await foreach (SubscriptionProperties subscription in client.GetSubscriptionsAsync(topicName))
{
subscriptionList.Add(subscription);
}
subscriptionList = subscriptionList.Where(e => e.TopicName.StartsWith(nameof(BasicSubscriptionCrudOperations).ToLower())).ToList();
Assert.True(subscriptionList.Count == 1, $"Expected 1 subscription but {subscriptionList.Count} subscriptions returned");
Assert.AreEqual(subscriptionList.First().TopicName, topicName);
Assert.AreEqual(subscriptionList.First().SubscriptionName, subscriptionName);
await client.DeleteSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.That(
async() =>
await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound));
await client.DeleteTopicAsync(options.TopicName);
exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.False(exists);
}