public void ForwardDeadLetteredMessagesToAllowsMaxLengthMinusBaseUrl(string baseUrl, int lengthOfName)
{
var longName = string.Join(string.Empty, Enumerable.Repeat('a', lengthOfName));
var sub = new SubscriptionProperties("sb://fakeservicebus", "Fake SubscriptionName");
sub.ForwardDeadLetteredMessagesTo = $"{baseUrl}{longName}";
Assert.AreEqual($"{baseUrl}{longName}", sub.ForwardDeadLetteredMessagesTo);
}
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 void ForwardDeadLetteredMessagesToThrowsArgumentOutOfRangeException(string baseUrl, int lengthOfName)
{
var longName = string.Join(string.Empty, Enumerable.Repeat('a', lengthOfName));
var sub = new SubscriptionProperties("sb://fakeservicebus", "Fake SubscriptionName");
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => sub.ForwardDeadLetteredMessagesTo = $"{baseUrl}{longName}");
Assert.AreEqual($"Entity path '{longName}' exceeds the '260' character limit.{Environment.NewLine}Parameter name: ForwardDeadLetteredMessagesTo", ex.Message);
Assert.AreEqual($"ForwardDeadLetteredMessagesTo", ex.ParamName);
}
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));
}
private SubscriptionProperties CreateNewSubscriptionProperties(SubscriptionProperties subscriptionProperties)
{
subscriptionProperties.AutoDeleteOnIdle = _createSubscriptionOptions.AutoDeleteOnIdle;
subscriptionProperties.DeadLetteringOnMessageExpiration = _createSubscriptionOptions.DeadLetteringOnMessageExpiration;
subscriptionProperties.DefaultMessageTimeToLive = _createSubscriptionOptions.DefaultMessageTimeToLive;
subscriptionProperties.EnableBatchedOperations = _createSubscriptionOptions.EnableBatchedOperations;
subscriptionProperties.EnableDeadLetteringOnFilterEvaluationExceptions = _createSubscriptionOptions.EnableDeadLetteringOnFilterEvaluationExceptions;
subscriptionProperties.ForwardDeadLetteredMessagesTo = _createSubscriptionOptions.ForwardDeadLetteredMessagesTo;
subscriptionProperties.ForwardTo = _createSubscriptionOptions.ForwardTo;
subscriptionProperties.LockDuration = _createSubscriptionOptions.LockDuration;
subscriptionProperties.MaxDeliveryCount = _createSubscriptionOptions.MaxDeliveryCount;
subscriptionProperties.RequiresSession = _createSubscriptionOptions.RequiresSession;
return(subscriptionProperties);
}
protected async Task DeleteSubscriptionAsync(string subscription)
{
SubscriptionProperties existingSubscription = null;
try
{
existingSubscription = await _serviceBusAdminClient.GetSubscriptionAsync(_topic, subscription);
}
catch { }
if (existingSubscription is not null)
{
await _serviceBusAdminClient.DeleteSubscriptionAsync(_topic, subscription);
}
}
public async Task UnknownElementsInAtomXmlHandledCorrectly()
{
string subscriptionDescriptionXml = $@"<entry xmlns=""{AdministrationClientConstants.AtomNamespace}"">" +
$@"<title xmlns=""{AdministrationClientConstants.AtomNamespace}"">testqueue1</title>" +
$@"<content xmlns=""{AdministrationClientConstants.AtomNamespace}"">" +
$@"<SubscriptionDescription xmlns=""{AdministrationClientConstants.ServiceBusNamespace}"">" +
$"<LockDuration>{XmlConvert.ToString(TimeSpan.FromMinutes(1))}</LockDuration>" +
$"<RequiresSession>true</RequiresSession>" +
$"<DefaultMessageTimeToLive>{XmlConvert.ToString(TimeSpan.FromMinutes(60))}</DefaultMessageTimeToLive>" +
$"<DeadLetteringOnMessageExpiration>false</DeadLetteringOnMessageExpiration>" +
$"<DeadLetteringOnFilterEvaluationExceptions>false</DeadLetteringOnFilterEvaluationExceptions>" +
$"<MaxDeliveryCount>10</MaxDeliveryCount>" +
$"<EnableBatchedOperations>true</EnableBatchedOperations>" +
$"<Status>Active</Status>" +
$"<ForwardTo>fq1</ForwardTo>" +
$"<UserMetadata></UserMetadata>" +
$"<AutoDeleteOnIdle>{XmlConvert.ToString(TimeSpan.FromMinutes(60))}</AutoDeleteOnIdle>" +
$"<IsClientAffine>prop1</IsClientAffine>" +
$"<ClientAffineProperties><ClientId>xyz</ClientId><IsDurable>false</IsDurable><IsShared>true</IsShared></ClientAffineProperties>" +
$"<UnknownElement3>prop3</UnknownElement3>" +
$"<UnknownElement4>prop4</UnknownElement4>" +
$"</SubscriptionDescription>" +
$"</content>" +
$"</entry>";
MockResponse response = new MockResponse(200);
response.SetContent(subscriptionDescriptionXml);
SubscriptionProperties subscriptionDesc = await SubscriptionPropertiesExtensions.ParseResponseAsync("abcd", response, new ClientDiagnostics(new ServiceBusAdministrationClientOptions()));
Assert.NotNull(subscriptionDesc.UnknownProperties);
XDocument doc = SubscriptionPropertiesExtensions.Serialize(subscriptionDesc);
XName subscriptionDescriptionElementName = XName.Get("SubscriptionDescription", AdministrationClientConstants.ServiceBusNamespace);
XElement expectedSubscriptionDecriptionElement = XElement.Parse(subscriptionDescriptionXml).Descendants(subscriptionDescriptionElementName).FirstOrDefault();
XElement serializedSubscriptionDescritionElement = doc.Descendants(subscriptionDescriptionElementName).FirstOrDefault();
XNode expectedChildNode = expectedSubscriptionDecriptionElement.FirstNode;
XNode actualChildNode = serializedSubscriptionDescritionElement.FirstNode;
while (expectedChildNode != null)
{
Assert.NotNull(actualChildNode);
Assert.True(XNode.DeepEquals(expectedChildNode, actualChildNode), $"SubscriptionDescrition parsing and serialization combo didn't work as expected. {expectedChildNode.ToString()}");
expectedChildNode = expectedChildNode.NextNode;
actualChildNode = actualChildNode.NextNode;
}
}
public void CanCreateSubscriptionPropertiesFromOptions()
{
var options = new CreateSubscriptionOptions("topic", "subscription")
{
LockDuration = TimeSpan.FromSeconds(60),
RequiresSession = true,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(120),
AutoDeleteOnIdle = TimeSpan.FromMinutes(10),
DeadLetteringOnMessageExpiration = true,
MaxDeliveryCount = 5,
EnableBatchedOperations = true,
Status = EntityStatus.Disabled,
ForwardDeadLetteredMessagesTo = "dlqForward",
ForwardTo = "forward",
UserMetadata = "metadata"
};
var properties = new SubscriptionProperties(options);
Assert.AreEqual(options, new CreateSubscriptionOptions(properties));
}
public async Task BasicRuleCrudOperations()
{
var topicName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var client = CreateClient();
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", Recording.Now.UtcDateTime);
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",
Subject = "label",
MessageId = "messageId",
ReplyTo = "replyTo",
ReplyToSessionId = "replyToSessionId",
SessionId = "sessionId",
To = "to"
};
correlationRuleFilter.ApplicationProperties.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(ServiceBusFailureReason.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() + Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var client = CreateClient();
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)
};
Response <SubscriptionProperties> createdSubscriptionResponse = await client.CreateSubscriptionAsync(options);
Response rawResponse = createdSubscriptionResponse.GetRawResponse();
Assert.NotNull(rawResponse.ClientRequestId);
Assert.IsTrue(rawResponse.ContentStream.CanRead);
Assert.AreEqual(0, rawResponse.ContentStream.Position);
SubscriptionProperties createdSubscription = createdSubscriptionResponse.Value;
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 (Page <SubscriptionProperties> subscriptionPage in client.GetSubscriptionsAsync(topicName).AsPages())
{
Assert.NotNull(subscriptionPage.GetRawResponse().ClientRequestId);
Assert.IsTrue(subscriptionPage.GetRawResponse().ContentStream.CanRead);
Assert.AreEqual(0, subscriptionPage.GetRawResponse().ContentStream.Position);
subscriptionList.AddRange(subscriptionPage.Values);
}
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(ServiceBusFailureReason.MessagingEntityNotFound));
await client.DeleteTopicAsync(options.TopicName);
exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.False(exists);
}
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);
}
public ServiceBusPurger(ServiceBusHelper2 serviceBusHelper, SubscriptionProperties subscriptionProperties)
{
this.serviceBusHelper = serviceBusHelper;
this.subscriptionProperties = subscriptionProperties;
}
private async Task UpdateSubscriptionAsync(SubscriptionProperties existingSubscriptionProperties)
{
var newSubscriptionProperties = CreateNewSubscriptionProperties(existingSubscriptionProperties);
await _serviceBusAdminClient.UpdateSubscriptionAsync(newSubscriptionProperties);
}
private bool SubscriptionSessionSettingsChanged(SubscriptionProperties subscriptionProperties) => subscriptionProperties.RequiresSession != _createSubscriptionOptions.RequiresSession;
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
#region Creating Objects
QueueProperties queue = await ServiceBusObjects.GetQueueAsync(ConnectionString, QueueName);
if (queue == null)
{
queue = await ServiceBusObjects.CreateQueueAsync(ConnectionString, QueueName);
}
QueueProperties sessionQueue = await ServiceBusObjects.GetQueueAsync(ConnectionString, SessionQueueName);
if (sessionQueue == null)
{
sessionQueue = await ServiceBusObjects.CreateQueueAsync(ConnectionString, SessionQueueName, true);
}
TopicProperties topic = await ServiceBusObjects.GetTopicAsync(TopicName, ConnectionString);
if (topic == null)
{
topic = await ServiceBusObjects.CreateTopicAsync(TopicName, ConnectionString);
}
SubscriptionProperties subscription = await ServiceBusObjects.GetSubscriptionAsync(TopicName, ConnectionString, SubscriptionName);
if (subscription == null)
{
subscription = await ServiceBusObjects.CreateSubscriptionAsync(TopicName, ConnectionString, SubscriptionName);
}
#endregion
#region Sending and Receiving Messages
int count = 0;
//sending messages
await SendAndReceiveMessage.SendMessageAsync(ConnectionString, QueueName, $"Message {count++}");
await SendAndReceiveMessage.SendMessageBatchAsync(ConnectionString, QueueName, new System.Collections.Generic.List <string> {
$"Message {count++}", $"Message {count++}", $"Message {count++}", $"Message {count++}"
});
await SendAndReceiveMessage.SendMessageSafeBatchAsync(ConnectionString, QueueName, new System.Collections.Generic.List <string> {
$"Message {count++}", $"Message {count++}", $"Message {count++}", $"Message {count++}"
});
long firstScheduledMessageNumber = await SendAndReceiveMessage.SendScheduledMessageAsync(ConnectionString, QueueName, $"Message {count++}", new DateTimeOffset(DateTime.Now.AddMinutes(10)));
long secondScheduledMessageNumber = await SendAndReceiveMessage.SendScheduledMessageAsync(ConnectionString, QueueName, $"Message {count++}", new DateTimeOffset(DateTime.Now.AddMinutes(10)));
await SendAndReceiveMessage.CancelScheduledMessageAsync(ConnectionString, QueueName, firstScheduledMessageNumber);
long deferredMessageNumber = await SendAndReceiveMessage.DeferMessageAsync(ConnectionString, QueueName);
Console.WriteLine((await SendAndReceiveMessage.GetDeferredMessageAsync(ConnectionString, QueueName, deferredMessageNumber)).Body);
await SendAndReceiveMessage.DeadLetterMessageAsync(ConnectionString, QueueName);
Console.WriteLine((await SendAndReceiveMessage.GetDeadLetterMessageAsync(ConnectionString, QueueName)).Body);
Console.WriteLine((await SendAndReceiveMessage.GetMessageAsync(ConnectionString, QueueName)).Body);
await SendAndReceiveMessage.CompleteOrAbandonMessageAsync(ConnectionString, QueueName, false);
await SendAndReceiveMessage.CompleteOrAbandonMessageAsync(ConnectionString, QueueName, true);
#endregion
#region Sending and Receiving Session Messages
await SendAndReceiveMessage.SendSessionMessageAsync(ConnectionString, SessionQueueName, $"Message {count++}", "session id 1");
Console.WriteLine((await SendAndReceiveMessage.GetMessageFromSessionAsync(ConnectionString, SessionQueueName, "session id 1")).Body);
#endregion
#region Messages Processor
await Processor.RunProcessor(ConnectionString, QueueName, new TimeSpan(0, 0, 10));
#endregion
#region Session Processor
await SessionProcessor.RunSessionProcessor(ConnectionString, SessionQueueName, new TimeSpan(0, 0, 10));
#endregion
}
public async Task GetSubscriptionRuntimeInfoTest()
{
var topicName = nameof(GetSubscriptionRuntimeInfoTest).ToLower() + Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var client = CreateClient();
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);
}
private bool SubscriptionOptionsAreCorrect(SubscriptionProperties subscriptionProperties) => _createSubscriptionOptions == new CreateSubscriptionOptions(subscriptionProperties);
public static async Task <SubscriptionProperties> UpdateSubscriptionAsync(string connectionString, SubscriptionProperties subscription)
{
var client = new ServiceBusAdministrationClient(connectionString);
subscription.UserMetadata = "other metadata";
return(await client.UpdateSubscriptionAsync(subscription));
}
