public async Task Should_properly_set_use_subscription_description_defaults_if_user_does_not_provide_topic_description_values()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
var creator = new AzureServiceBusForwardingSubscriptionCreator(new TopologySubscriptionSettings());
const string subscriptionName = "endpoint1";
var subscriptionDescription = await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager, forwardToQueue);
Assert.IsTrue(await namespaceManager.SubscriptionExists(topicPath, subscriptionName));
Assert.AreEqual(TimeSpan.MaxValue, subscriptionDescription.AutoDeleteOnIdle);
Assert.AreEqual(TimeSpan.MaxValue, subscriptionDescription.DefaultMessageTimeToLive);
Assert.AreEqual(TimeSpan.FromMilliseconds(30000), subscriptionDescription.LockDuration);
Assert.True(subscriptionDescription.EnableBatchedOperations);
Assert.IsFalse(subscriptionDescription.EnableDeadLetteringOnFilterEvaluationExceptions);
Assert.IsFalse(subscriptionDescription.EnableDeadLetteringOnMessageExpiration);
Assert.IsFalse(subscriptionDescription.RequiresSession);
Assert.AreEqual(AzureServiceBusForwardingSubscriptionCreator.DefaultMaxDeliveryCountForNoImmediateRetries, subscriptionDescription.MaxDeliveryCount);
Assert.IsNull(subscriptionDescription.ForwardDeadLetteredMessagesTo);
Assert.That(subscriptionDescription.ForwardTo, Does.EndWith(forwardToQueue));
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public async Task Should_properly_set_DefaultMessageTimeToLive_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var timeToLive = TimeSpan.FromDays(10);
extensions.Subscriptions().DefaultMessageTimeToLive(timeToLive);
var creator = new AzureServiceBusSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
const string subscriptionName = "sub4";
await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager);
var foundDescription = await namespaceManager.GetSubscription(topicPath, subscriptionName);
Assert.AreEqual(timeToLive, foundDescription.DefaultMessageTimeToLive);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public async Task Should_be_idempotent_when_creating_a_subscription()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.UseForwardingTopology().Subscriptions().DescriptionCustomizer(description =>
{
description.MaxDeliveryCount = 100;
description.EnableDeadLetteringOnMessageExpiration = true;
});
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
await creator.Create(topicPath, "someendpoint", metadata, sqlFilter, namespaceManager, forwardToQueue);
await creator.Create(topicPath, "someendpoint", metadata, sqlFilter, namespaceManager, forwardToQueue);
var rules = await namespaceManager.GetRules(new SubscriptionDescription(topicPath, "someendpoint"));
Assert.AreEqual(1, rules.Count());
}
public async Task Should_be_able_to_update_an_existing_subscription_with_new_property_values_without_failing_on_readonly_properties()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
await namespaceManager.CreateSubscription(new SubscriptionDescription(topicPath, "existingendpoint2")
{
EnableDeadLetteringOnFilterEvaluationExceptions = true,
RequiresSession = true
}, "1=1");
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.UseForwardingTopology().Subscriptions().DescriptionCustomizer(description =>
{
description.EnableDeadLetteringOnFilterEvaluationExceptions = false;
description.RequiresSession = false;
});
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
Assert.ThrowsAsync <ArgumentException>(async() => await creator.Create(topicPath, "existingendpoint2", metadata, sqlFilter, namespaceManager, forwardToQueue));
}
public async Task Should_be_able_to_update_an_existing_subscription_with_new_property_values()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
await namespaceManager.CreateSubscription(new SubscriptionDescription(topicPath, "existingendpoint1"), sqlFilter);
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.UseForwardingTopology().Subscriptions().DescriptionCustomizer(description =>
{
description.LockDuration = TimeSpan.FromMinutes(5);
description.EnableDeadLetteringOnMessageExpiration = true;
});
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
await creator.Create(topicPath, "existingendpoint1", metadata, sqlFilter, namespaceManager, forwardToQueue);
var subscriptionDescription = await namespaceManager.GetSubscription(topicPath, "existingendpoint1");
Assert.AreEqual(TimeSpan.FromMinutes(5), subscriptionDescription.LockDuration);
Assert.IsTrue(subscriptionDescription.EnableDeadLetteringOnMessageExpiration);
}
public async Task Should_properly_set_LockDuration_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var lockDuration = TimeSpan.FromMinutes(2);
extensions.UseForwardingTopology().Subscriptions().LockDuration(lockDuration);
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
const string subscriptionName = "endpoint8";
await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager, forwardToQueue);
var foundDescription = await namespaceManager.GetSubscription(topicPath, subscriptionName);
Assert.AreEqual(lockDuration, foundDescription.LockDuration);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public void TopicSetup()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
if (!namespaceManager.TopicExists(topicPath).GetAwaiter().GetResult())
{
namespaceManager.CreateTopic(new TopicDescription(topicPath)).GetAwaiter().GetResult();
}
if (!namespaceManager.QueueExists(forwardToQueue).GetAwaiter().GetResult())
{
namespaceManager.CreateQueue(new QueueDescription(forwardToQueue)).GetAwaiter().GetResult();
}
namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Fallback));
if (!namespaceManager.TopicExists(topicPath).GetAwaiter().GetResult())
{
namespaceManager.CreateTopic(new TopicDescription(topicPath)).GetAwaiter().GetResult();
}
if (!namespaceManager.QueueExists(forwardToQueue).GetAwaiter().GetResult())
{
namespaceManager.CreateQueue(new QueueDescription(forwardToQueue)).GetAwaiter().GetResult();
}
}
public async Task Should_properly_set_ForwardTo_on_the_created_entity_with_hierarchy()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
var queueCreator = new AzureServiceBusQueueCreator(new TopologyQueueSettings(), DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()));
var queueToForwardTo = await queueCreator.Create("forwardto", namespaceManager);
var creator = new AzureServiceBusSubscriptionCreator(new TopologySubscriptionSettings());
const string subscriptionName = "sub17";
await creator.Create(hierarchyTopicPath, subscriptionName, metadata, sqlFilter, namespaceManager, queueToForwardTo.Path);
// create again without forward to
await creator.Create(hierarchyTopicPath, subscriptionName, metadata, sqlFilter, namespaceManager);
var foundDescription = await namespaceManager.GetSubscription(hierarchyTopicPath, subscriptionName);
Assert.IsNull(foundDescription.ForwardTo);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(hierarchyTopicPath, subscriptionName));
await namespaceManager.DeleteQueue(queueToForwardTo.Path);
}
public void TopicSetup()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value), AzureServiceBusConnectionString.Value);
if (!namespaceManager.TopicExists(topicPath).Result)
{
namespaceManager.CreateTopic(new TopicDescription(topicPath)).GetAwaiter().GetResult();
}
if (!namespaceManager.TopicExists(hierarchyTopicPath).Result)
{
namespaceManager.CreateTopic(new TopicDescription(hierarchyTopicPath)).GetAwaiter().GetResult();
}
namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Fallback), AzureServiceBusConnectionString.Fallback);
if (!namespaceManager.TopicExists(topicPath).Result)
{
namespaceManager.CreateTopic(new TopicDescription(topicPath)).GetAwaiter().GetResult();
}
if (!namespaceManager.TopicExists(hierarchyTopicPath).Result)
{
namespaceManager.CreateTopic(new TopicDescription(hierarchyTopicPath)).GetAwaiter().GetResult();
}
}
public async Task Should_not_create_create_a_duplicate_subscription__issue_811()
{
var nativeManager = NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value);
var namespaceManager = new NamespaceManagerAdapterInternal(nativeManager);
var topicForTest = $"{topicPath}_issue811";
try
{
if (!await nativeManager.TopicExistsAsync(topicForTest))
{
await nativeManager.CreateTopicAsync(new TopicDescription(topicForTest));
}
var subscriptionName = nameof(SomeEvent);
await namespaceManager.CreateSubscription(new SubscriptionDescription(topicForTest, subscriptionName), new SqlSubscriptionFilter_UsedPriorToVersion9(typeof(SomeEvent)).Serialize());
var creator = new AzureServiceBusSubscriptionCreatorV6(new TopologySubscriptionSettings());
var metadata = new SubscriptionMetadataInternal
{
SubscriptionNameBasedOnEventWithNamespace = typeof(SomeEvent).FullName,
Description = Guid.NewGuid().ToString()
};
var properSqlFilter = new SqlSubscriptionFilter(typeof(SomeEvent)).Serialize();
await creator.Create(topicForTest, subscriptionName, metadata, properSqlFilter, namespaceManager);
var foundSubcriptions = await nativeManager.GetSubscriptionsAsync(topicForTest);
Assert.AreEqual(1, foundSubcriptions.Count());
}
finally
{
await nativeManager.DeleteTopicAsync(topicForTest);
}
}
public async Task Should_properly_set_use_subscription_description_provided_by_user()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
const string subscriptionName = "endpoint2";
var userCustomizationsWhereInvoked = false;
extensions.Subscriptions().DescriptionCustomizer(_ =>
{
userCustomizationsWhereInvoked = true;
});
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager, forwardToQueue);
Assert.IsTrue(await namespaceManager.SubscriptionExists(topicPath, subscriptionName));
Assert.IsTrue(userCustomizationsWhereInvoked);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public async Task Should_create_subscription_on_multiple_namespaces()
{
const string subscriber = "MultipleNamespaceSubscriber";
var namespaceManager1 = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var namespaceManager2 = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Fallback));
var creator = new AzureServiceBusForwardingSubscriptionCreator(new TopologySubscriptionSettings
{
DescriptionCustomizer = description =>
{
description.MaxDeliveryCount = 100;
description.EnableDeadLetteringOnMessageExpiration = true;
}
});
await creator.Create(topicPath, subscriber, metadata, sqlFilter, namespaceManager1, forwardToQueue);
await creator.Create(topicPath, subscriber, metadata, sqlFilter, namespaceManager2, forwardToQueue);
Assert.IsTrue(await namespaceManager1.SubscriptionExists(topicPath, subscriber), "Subscription on Value namespace was not created.");
Assert.IsTrue(await namespaceManager2.SubscriptionExists(topicPath, subscriber), "Subscription on Fallback namespace was not created.");
}
public async Task Should_create_subscription_with_sql_filter()
{
const string subscriber = "subscriber";
const string filter = @"[NServiceBus.EnclosedMessageTypes] LIKE 'Test.SomeEvent%'"
+ " OR [NServiceBus.EnclosedMessageTypes] LIKE '%Test.SomeEvent%'"
+ " OR [NServiceBus.EnclosedMessageTypes] LIKE '%Test.SomeEvent'"
+ " OR [NServiceBus.EnclosedMessageTypes] = 'Test.SomeEvent'";
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var creator = new AzureServiceBusForwardingSubscriptionCreator(new TopologySubscriptionSettings());
var subscriptionDescription = await creator.Create(topicPath, subscriber, metadata, filter, namespaceManager, forwardToQueue);
var rules = await namespaceManager.GetRules(subscriptionDescription);
var foundFilter = rules.First().Filter as SqlFilter;
Assert.IsTrue(rules.Count() == 1, "Subscription should only have 1 rule");
Assert.AreEqual(filter, foundFilter.SqlExpression, "Rule was expected to have a specific SQL filter, but it didn't");
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriber));
}
public async Task Properly_sets_EnablePartitioning_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
//make sure any previously created queues with this name are removed as the EnablePartitioning cannot be updated
await namespaceManager.DeleteQueue("myqueue");
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().EnablePartitioning(true);
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(real.EnablePartitioning);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public void TopicCleanUp()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
namespaceManager.DeleteTopic(topicPath).Wait();
}
