public async Task Should_not_update_properties_of_an_existing_system_queue()
{
var queuePath = "errorQ";
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue(queuePath).ConfigureAwait(false);
if (!await namespaceManager.QueueExists(queuePath).ConfigureAwait(false))
{
await namespaceManager.CreateQueue(new QueueDescription(queuePath)).ConfigureAwait(false);
}
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(WellKnownConfigurationKeys.Core.RecoverabilityNumberOfImmediateRetries, 2);
var queueBindings = new QueueBindings();
queueBindings.BindSending(queuePath);
settings.Set <QueueBindings>(queueBindings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().LockDuration(TimeSpan.FromMinutes(4));
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create(queuePath, namespaceManager);
var real = await namespaceManager.GetQueue(queuePath);
Assert.That(real.LockDuration, Is.EqualTo(TimeSpan.FromSeconds(60)));
//cleanup
await namespaceManager.DeleteQueue(queuePath);
}
public async Task Properly_sets_ForwardDeadLetteredMessagesTo_on_the_created_entity_that_qualifies_condition()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().ForwardDeadLetteredMessagesTo(name => name == "myqueue", "myotherqueue");
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myotherqueue", namespaceManager);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
var forwardReal = await namespaceManager.GetQueue("myotherqueue");
Assert.IsTrue(real.ForwardDeadLetteredMessagesTo.EndsWith("myotherqueue"));
Assert.IsTrue(string.IsNullOrEmpty(forwardReal.ForwardDeadLetteredMessagesTo));
//cleanup
await namespaceManager.DeleteQueue("myqueue");
await namespaceManager.DeleteQueue("myotherqueue");
}
public async Task Should_be_able_to_update_an_existing_queue_with_new_property_values()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue("existingqueue").ConfigureAwait(false);
await namespaceManager.CreateQueue(new QueueDescription("existingqueue"));
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().DescriptionCustomizer(qd =>
{
qd.AutoDeleteOnIdle = TimeSpan.FromMinutes(100);
qd.EnableExpress = true;
});
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create("existingqueue", namespaceManager);
var queueDescription = await namespaceManager.GetQueue("existingqueue");
Assert.AreEqual(TimeSpan.FromMinutes(100), queueDescription.AutoDeleteOnIdle);
//cleanup
await namespaceManager.DeleteQueue("existingqueue");
}
public async Task Should_be_able_to_update_an_existing_queue_with_new_property_values()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue("existingqueue").ConfigureAwait(false);
await namespaceManager.CreateQueue(new QueueDescription("existingqueue"));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().DescriptionFactory((queuePath, readOnlySettings) => new QueueDescription(queuePath)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(100),
EnableExpress = true
});
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("existingqueue", namespaceManager);
var queueDescription = await namespaceManager.GetQueue("existingqueue");
Assert.AreEqual(TimeSpan.FromMinutes(100), queueDescription.AutoDeleteOnIdle);
//cleanup
await namespaceManager.DeleteQueue("existingqueue");
}
public async Task Properly_sets_ForwardDeadLetteredMessagesTo_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
// forwarding queue needs to exist before you can use it as a forwarding target
// needs to be created with different settings as it cannot forward to itself obviously
var originalsettings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var originalcreator = new AzureServiceBusQueueCreator(originalsettings);
await originalcreator.Create("myotherqueue", namespaceManager);
// actual test
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().ForwardDeadLetteredMessagesTo("myotherqueue");
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(real.ForwardDeadLetteredMessagesTo.EndsWith("myotherqueue"));
//cleanup
await namespaceManager.DeleteQueue("myqueue");
await namespaceManager.DeleteQueue("myotherqueue");
}
public async Task Should_not_update_properties_of_an_existing_system_queue()
{
var queuePath = "errorQ";
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue(queuePath).ConfigureAwait(false);
if (!await namespaceManager.QueueExists(queuePath).ConfigureAwait(false))
{
await namespaceManager.CreateQueue(new QueueDescription(queuePath)).ConfigureAwait(false);
}
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
settings.Set(WellKnownConfigurationKeys.Core.RecoverabilityNumberOfImmediateRetries, 2);
var queueBindings = new QueueBindings();
queueBindings.BindSending(queuePath);
settings.Set <QueueBindings>(queueBindings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().MaxDeliveryCount(2);
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create(queuePath, namespaceManager);
var real = await namespaceManager.GetQueue(queuePath);
Assert.That(real.MaxDeliveryCount, Is.EqualTo(10));
//cleanup
await namespaceManager.DeleteQueue(queuePath);
}
public void Should_be_able_to_extend_queue_settings()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var queueSettings = extensions.Queues();
Assert.IsInstanceOf <AzureServiceBusQueueSettings>(queueSettings);
}
public void Should_be_able_to_set_ForwardDeadLetteredMessagesTo()
{
var setting = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(setting);
var queueSettings = extensions.Queues().ForwardDeadLetteredMessagesTo("deadletteredmessages");
Assert.AreEqual("deadletteredmessages", queueSettings.GetSettings().Get <string>(WellKnownConfigurationKeys.Topology.Resources.Queues.ForwardDeadLetteredMessagesTo));
}
public void Should_be_able_to_set_RequiresDuplicateDetection()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var queueSettings = extensions.Queues().RequiresDuplicateDetection(true);
Assert.True(queueSettings.GetSettings().Get <bool>(WellKnownConfigurationKeys.Topology.Resources.Queues.RequiresDuplicateDetection));
}
public void Should_be_able_to_set_EnablePartitioning()
{
var setting = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(setting);
var queueSettings = extensions.Queues().EnablePartitioning(true);
Assert.IsTrue(queueSettings.GetSettings().Get <bool>(WellKnownConfigurationKeys.Topology.Resources.Queues.EnablePartitioning));
}
public void Should_be_able_to_set_MaxSizeInMegabytes()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
const long maxTopicSizeInMB = 2048;
var queueSettings = extensions.Queues().MaxSizeInMegabytes(SizeInMegabytes.Size2048);
Assert.AreEqual(maxTopicSizeInMB, queueSettings.GetSettings().Get <long>(WellKnownConfigurationKeys.Topology.Resources.Queues.MaxSizeInMegabytes));
}
public void Should_be_able_to_set_DefaultMessageTimeToLive()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var expiryTimespan = TimeSpan.FromDays(1);
var queueSettings = extensions.Queues().DefaultMessageTimeToLive(expiryTimespan);
Assert.AreEqual(expiryTimespan, queueSettings.GetSettings().Get <TimeSpan>(WellKnownConfigurationKeys.Topology.Resources.Queues.DefaultMessageTimeToLive));
}
public void Should_be_able_to_set_MaxDeliveryCount()
{
var setting = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(setting);
const int selectedMaxDeliveryCount = 6;
var queueSettings = extensions.Queues().MaxDeliveryCount(selectedMaxDeliveryCount);
Assert.AreEqual(selectedMaxDeliveryCount, queueSettings.GetSettings().Get <int>(WellKnownConfigurationKeys.Topology.Resources.Queues.MaxDeliveryCount));
}
public void Should_be_able_to_set_DuplicateDetectionHistoryTimeWindow()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var dedupTimespan = TimeSpan.FromMinutes(20);
var queueSettings = extensions.Queues().DuplicateDetectionHistoryTimeWindow(dedupTimespan);
Assert.AreEqual(dedupTimespan, queueSettings.GetSettings().Get <TimeSpan>(WellKnownConfigurationKeys.Topology.Resources.Queues.DuplicateDetectionHistoryTimeWindow));
}
public void Should_be_able_to_set_AutoDeleteOnIdle()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var idlePeriod = TimeSpan.FromDays(10);
var queueSettings = extensions.Queues().AutoDeleteOnIdle(idlePeriod);
Assert.AreEqual(idlePeriod, queueSettings.GetSettings().Get <TimeSpan>(WellKnownConfigurationKeys.Topology.Resources.Queues.AutoDeleteOnIdle));
}
public void Should_be_able_to_set_LockDuration()
{
var setting = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(setting);
var lockDuration = TimeSpan.FromDays(1);
var queueSettings = extensions.Queues().LockDuration(lockDuration);
Assert.AreEqual(lockDuration, queueSettings.GetSettings().Get <TimeSpan>(WellKnownConfigurationKeys.Topology.Resources.Queues.LockDuration));
}
public void Should_be_able_to_set_queue_description_factory_method()
{
var settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
Func <string, ReadOnlySettings, QueueDescription> registeredFactory = (name, s) => new QueueDescription(name);
var connectivitySettings = extensions.Queues().DescriptionFactory(registeredFactory);
Assert.AreEqual(registeredFactory, connectivitySettings.GetSettings().Get <Func <string, ReadOnlySettings, QueueDescription> >(WellKnownConfigurationKeys.Topology.Resources.Queues.DescriptionFactory));
}
public void Should_be_able_to_set_EnableExpress_conditionally()
{
var setting = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(setting);
Func <string, bool> condition = name => name != "expressqueue";
var queueSettings = extensions.Queues().EnableExpress(condition, true);
Assert.IsTrue(queueSettings.GetSettings().Get <bool>(WellKnownConfigurationKeys.Topology.Resources.Queues.EnableExpress));
Assert.AreEqual(condition, queueSettings.GetSettings().Get <Func <string, bool> >(WellKnownConfigurationKeys.Topology.Resources.Queues.EnableExpressCondition));
}
public static void ConfigureTransport(this TransportExtensions <AzureServiceBusTransport> transport, TransportSettings transportSettings)
{
transport.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
transport.ConnectionString(transportSettings.ConnectionString);
transport.MessageReceivers().PrefetchCount(0);
transport.Queues().LockDuration(TimeSpan.FromMinutes(5));
transport.Subscriptions().LockDuration(TimeSpan.FromMinutes(5));
transport.MessagingFactories().NumberOfMessagingFactoriesPerNamespace(2);
transport.NumberOfClientsPerEntity(Math.Min(Environment.ProcessorCount, transportSettings.MaxConcurrency));
}
#pragma warning disable 618
public static void ConfigureTransport(this TransportExtensions <AzureServiceBusTransport> transport, TransportSettings transportSettings, TransportTransactionMode transactionMode)
#pragma warning restore 618
{
//If the custom part stays in the connection string and is at the end, the sdk will treat is as part of the SharedAccessKey
var connectionString = ConnectionStringPartRemover.Remove(transportSettings.ConnectionString, QueueLengthProvider.QueueLengthQueryIntervalPartName);
transport.ConnectionString(connectionString);
transport.Transactions(transactionMode);
transport.Queues().LockDuration(TimeSpan.FromMinutes(5));
transport.Subscriptions().LockDuration(TimeSpan.FromMinutes(5));
transport.MessagingFactories().NumberOfMessagingFactoriesPerNamespace(2);
transport.NumberOfClientsPerEntity(Math.Min(Environment.ProcessorCount, transportSettings.MaxConcurrency));
}
public async Task Should_be_able_to_update_an_existing_queue_with_new_property_values_without_failing_on_readonly_properties()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue("existingqueue").ConfigureAwait(false);
await namespaceManager.CreateQueue(new QueueDescription("existingqueue")
{
LockDuration = TimeSpan.FromSeconds(50),
MaxSizeInMegabytes = SizeInMegabytes.Size2048,
RequiresDuplicateDetection = true,
EnablePartitioning = true,
RequiresSession = true
});
var queueDescription = await namespaceManager.GetQueue("existingqueue");
// partitioned topics will have a size that is 16x the requested max
Assert.AreEqual(2048 * 16, queueDescription.MaxSizeInMegabytes);
Assert.AreEqual(TimeSpan.FromSeconds(50), queueDescription.LockDuration);
Assert.IsTrue(queueDescription.EnablePartitioning);
Assert.IsTrue(queueDescription.RequiresDuplicateDetection);
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().DescriptionFactory((queuePath, readOnlySettings) => new QueueDescription(queuePath)
{
LockDuration = TimeSpan.FromSeconds(70),
MaxSizeInMegabytes = SizeInMegabytes.Size3072,
RequiresDuplicateDetection = false,
EnablePartitioning = false,
RequiresSession = false,
});
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("existingqueue", namespaceManager);
queueDescription = await namespaceManager.GetQueue("existingqueue");
Assert.AreEqual(3072 * 16, queueDescription.MaxSizeInMegabytes);
Assert.AreEqual(TimeSpan.FromSeconds(70), queueDescription.LockDuration);
Assert.IsTrue(queueDescription.EnablePartitioning);
Assert.IsTrue(queueDescription.RequiresDuplicateDetection);
//cleanup
await namespaceManager.DeleteQueue("existingqueue");
}
public async Task Properly_sets_EnableExpress_on_the_created_entity_that_qualifies_condition()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().EnableExpress(name => name == "myqueue", true);
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(real.EnableExpress, "Queue should be marked as express, but it wasn't.");
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Properly_sets_SupportOrdering_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().SupportOrdering(true);
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(real.SupportOrdering);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Properly_sets_DefaultMessageTimeToLive_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().DefaultMessageTimeToLive(TimeSpan.FromDays(1));
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.AreEqual(TimeSpan.FromDays(1), real.DefaultMessageTimeToLive);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Uses_queue_description_when_provided_by_user()
{
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var descriptionToUse = new QueueDescription("myqueue");
extensions.Queues().DescriptionFactory((name, s) => descriptionToUse);
var creator = new AzureServiceBusQueueCreator(settings);
var description = await creator.Create("myqueue", namespaceManager);
Assert.IsTrue(await namespaceManager.QueueExists("myqueue"));
Assert.AreEqual(descriptionToUse, description);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Uses_queue_description_when_provided_by_user()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var userQueueDescriptionFactoryWasInvoked = false;
extensions.Queues().DescriptionCustomizer(qd => userQueueDescriptionFactoryWasInvoked = true);
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create("myqueue", namespaceManager);
Assert.IsTrue(await namespaceManager.QueueExists("myqueue"));
Assert.IsTrue(userQueueDescriptionFactoryWasInvoked);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Properly_sets_LockDuration_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().LockDuration(TimeSpan.FromMinutes(5));
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.AreEqual(TimeSpan.FromMinutes(5), real.LockDuration);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Properly_sets_EnableBatchedOperations_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);
extensions.Queues().EnableBatchedOperations(false);
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsFalse(real.EnableBatchedOperations);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Properly_sets_EnablePartitioning_on_the_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(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 = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().EnablePartitioning(true);
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create("myqueue", namespaceManager);
var real = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(real.EnablePartitioning);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public void Should_be_able_to_set_AutoDeleteOnIdle()
{
var idlePeriod = TimeSpan.FromDays(10);
extensions.Queues().AutoDeleteOnIdle(idlePeriod);
Assert.AreEqual(idlePeriod, settings.Get <TopologySettings>().QueueSettings.AutoDeleteOnIdle);
}
