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 NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value)); var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings); await creator.Create("myotherqueue", namespaceManager); extensions.Queues().ForwardDeadLetteredMessagesTo(name => name == "myqueue", "myotherqueue"); 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 Properly_sets_ForwardDeadLetteredMessagesTo_on_the_created_entity() { var namespaceManager = new NamespaceManagerAdapterInternal(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 = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()); var originalcreator = new AzureServiceBusQueueCreator(new TopologyQueueSettings(), originalsettings); await originalcreator.Create("myotherqueue", namespaceManager); // actual test var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); extensions.Queues().ForwardDeadLetteredMessagesTo("myotherqueue"); var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, 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_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_without_failing_on_readonly_properties() { var namespaceManager = new NamespaceManagerAdapterInternal(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 = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()); var extensions = new TransportExtensions <AzureServiceBusTransport>(settings); extensions.Queues().DescriptionCustomizer(qd => { qd.LockDuration = TimeSpan.FromSeconds(70); qd.MaxSizeInMegabytes = SizeInMegabytes.Size3072; qd.RequiresDuplicateDetection = false; qd.EnablePartitioning = false; qd.RequiresSession = false; }); var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, 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 void TopicCleanUp() { var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value)); namespaceManager.DeleteTopic(topicPath).GetAwaiter().GetResult(); namespaceManager.DeleteQueue(forwardToQueue).GetAwaiter().GetResult(); namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value)); namespaceManager.DeleteTopic(topicPath).GetAwaiter().GetResult(); namespaceManager.DeleteQueue(forwardToQueue).GetAwaiter().GetResult(); }
public async Task Should_fail_over_to_available_namespace() { var namespaceManager1 = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(targetConnectionString), targetConnectionString); await namespaceManager1.DeleteQueue(Conventions.EndpointNamingConvention(typeof(TargetEndpoint))); var contextWithOnlyNamespace1Available = await Scenario.Define <Context>() .WithEndpoint <SourceEndpoint>(b => { b.When(async(bus, c) => { await bus.Send(new MyRequest()); await bus.Send(new MyRequest()); await bus.Send(new MyRequest()); }); }) .WithEndpoint <TargetEndpoint>(b => b.CustomConfig(c => c.ConfigureAzureServiceBus().ConnectionString(connectionString))) .Done(c => c.RequestsReceived == 3 && c.NamespaceNames.Count == 3) .Run(); var namespaceManager2 = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(connectionString), targetConnectionString); await namespaceManager2.DeleteQueue(Conventions.EndpointNamingConvention(typeof(TargetEndpoint))); var contextWithOnlyNamespace2Available = await Scenario.Define <Context>() .WithEndpoint <SourceEndpoint>(b => { b.When(async(bus, c) => { await bus.Send(new MyRequest()); await bus.Send(new MyRequest()); await bus.Send(new MyRequest()); }); }) .WithEndpoint <TargetEndpoint>(b => b.CustomConfig(c => c.ConfigureAzureServiceBus().ConnectionString(targetConnectionString))) .Done(c => c.RequestsReceived == 3 && c.NamespaceNames.Count == 3) .Run(); CollectionAssert.AreEquivalent(new[] { $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace1", $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace1", $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace1", }, contextWithOnlyNamespace1Available.NamespaceNames); CollectionAssert.AreEquivalent(new[] { $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace2", $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace2", $"{Conventions.EndpointNamingConvention(typeof(TargetEndpoint))}@namespace2", }, contextWithOnlyNamespace2Available.NamespaceNames); }
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 async Task Should_set_MaxDeliveryCount_to_maximum() { var namespaceManager = new NamespaceManagerAdapterInternal(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value)); var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer()); var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings); await creator.Create("myqueue", namespaceManager); var real = await namespaceManager.GetQueue("myqueue"); Assert.That(real.MaxDeliveryCount, Is.EqualTo(AzureServiceBusQueueCreator.DefaultMaxDeliveryCountForNoImmediateRetries)); //cleanup await namespaceManager.DeleteQueue("myqueue"); }
public async Task Should_set_forwarding_to_an_explicitly_provided_forwardto() { 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 = "sub15"; await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager, queueToForwardTo.Path); var foundDescription = await namespaceManager.GetSubscription(topicPath, subscriptionName); Assert.That(foundDescription.ForwardTo.EndsWith(queueToForwardTo.Path)); await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName)); await namespaceManager.DeleteQueue(queueToForwardTo.Path); }
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 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_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 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); }