public static void ConfigureSqsTransport(this TransportExtensions <SqsTransport> transportConfiguration, string queueNamePrefix = null)
{
transportConfiguration.ClientFactory(() => ClientFactory.CreateSqsClient());
transportConfiguration.ClientFactory(() => ClientFactory.CreateSnsClient());
if (queueNamePrefix != null)
{
transportConfiguration.QueueNamePrefix(queueNamePrefix);
}
var s3BucketName = EnvironmentHelper.GetEnvironmentVariable(S3BucketEnvironmentVariableName);
if (!string.IsNullOrEmpty(S3BucketName))
{
transportConfiguration.S3(S3BucketName, "test");
}
}
public async Task Determines_there_should_be_a_queue_with_same_name_as_endpointname()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(new Conventions());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
settings.SetDefault("NServiceBus.SharedQueue", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = await DetermineResourcesToCreate(settings);
Assert.AreEqual(1, definition.Entities.Count(ei => ei.Path == "sales" && ei.Type == EntityType.Queue && ei.Namespace.ConnectionString == Connectionstring));
}
public void SetUp()
{
settings = new SettingsHolder();
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.NamespacePartitioning().AddNamespace(PrimaryName, PrimaryConnectionString);
extensions.NamespacePartitioning().AddNamespace(SecondaryName, SecondaryConnectionString);
namespacePartitioningStrategy = new RoundRobinNamespacePartitioning(settings);
// apply entity maximum lengths for addressing logic
settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.QueuePathMaximumLength, 260);
settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.TopicPathMaximumLength, 260);
settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.SubscriptionNameMaximumLength, 50);
settings.SetDefault(WellKnownConfigurationKeys.Topology.Addressing.Sanitization.RuleNameMaximumLength, 50);
}
#pragma warning disable 618
ITopologySectionManager SetupForwardingTopology(TransportPartsContainer container, string enpointname)
{
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname);
extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
return(container.Resolve <ITopologySectionManager>());
}
static void ConfigureConnection(TransportExtensions <SqlServerTransport> transport, TransportSettings transportSettings)
{
var builder = new DbConnectionStringBuilder
{
ConnectionString = transportSettings.ConnectionString
};
if (builder.TryGetValue(queueSchemaName, out var customSchema))
{
builder.Remove(queueSchemaName);
transport.DefaultSchema((string)customSchema);
}
transport.ConnectionString(builder.ConnectionString);
}
public TransportConfigurationResult Configure(SettingsHolder settings, TransportTransactionMode transactionMode)
{
var sqsTransport = new SqsTransport();
var sqsConfig = new TransportExtensions <SqsTransport>(settings);
sqsConfig.Region("ap-southeast-2")
.QueueNamePrefix("TransportTest-")
.S3BucketForLargeMessages("sqstransportmessages1337", "test")
.NativeDeferral();
return(new TransportConfigurationResult
{
TransportInfrastructure = sqsTransport.Initialize(settings, ""),
PurgeInputQueueOnStartup = true
});
}
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 static TransportExtensions <SqsTransport> ConfigureSqsTransport(this TransportExtensions <SqsTransport> transportConfiguration, string queueNamePrefix)
{
transportConfiguration
.ClientFactory(CreateSQSClient)
.QueueNamePrefix(queueNamePrefix)
.PreTruncateQueueNamesForAcceptanceTests();
var s3BucketName = EnvironmentHelper.GetEnvironmentVariable(S3BucketEnvironmentVariableName);
if (!string.IsNullOrEmpty(s3BucketName))
{
var s3Configuration = transportConfiguration.S3(s3BucketName, "test");
s3Configuration.ClientFactory(CreateS3Client);
}
return(transportConfiguration);
}
public EndpointConfigurationBuilder(string endpointName, string transportConnectionString)
{
_endpointConfiguration = new EndpointConfiguration(endpointName);
// setup general
_endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
_endpointConfiguration.EnableInstallers();
// setup auditing
_endpointConfiguration.SendFailedMessagesTo("error");
_endpointConfiguration.AuditProcessedMessagesTo("audit");
// setup transport
_transportExtensions = _endpointConfiguration.UseTransport <RabbitMQTransport>();
_transportExtensions.UseConventionalRoutingTopology();
_transportExtensions.ConnectionString(transportConnectionString);
}
public void Determines_there_should_be_a_topic_with_same_name_as_endpointname_followed_by_dot_events()
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
settings.Set <Conventions>(new Conventions());
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = DetermineResourcesToCreate(settings, container);
Assert.AreEqual(1, definition.Entities.Count(ei => ei.Path == "sales.events" && ei.Type == EntityType.Topic && ei.Namespace.ConnectionString == Connectionstring));
}
public async Task Should_fail_sanitization_for_invalid_endpoint_name(string reasonToFail, string endpointName)
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
settings.SetDefault("NServiceBus.SharedQueue", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTransportInfrastructure(settings);
await topology.Start();
var sectionManager = topology.topologyManager;
Assert.Throws <Exception>(() => sectionManager.DetermineQueuesToCreate(new QueueBindings(), endpointName), "Was expected to fail: " + reasonToFail);
}
public static void ConfigureASQ(this TransportExtensions <AzureStorageQueueTransport> extensions)
{
var connectionString = EnvironmentHelper.GetEnvironmentVariable("AzureStorageQueues.ConnectionString");
extensions.ConnectionString(connectionString);
var settings = extensions.GetSettings();
var serializer = Tuple.Create(new NewtonsoftSerializer() as SerializationDefinition, new SettingsHolder());
settings.Set("MainSerializer", serializer);
bool isMessageType(Type t) => t == typeof(MessageWrapper);
var ctor = typeof(MessageMetadataRegistry).GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(Func <Type, bool>) }, null);
settings.Set <MessageMetadataRegistry>(ctor.Invoke(new object[] { (Func <Type, bool>)isMessageType }));
}
public async Task Should_upload_large_isolated_operations_request_to_s3()
{
var settings = new SettingsHolder();
var transportExtensions = new TransportExtensions <SqsTransport>(settings);
transportExtensions.S3("someBucket", "somePrefix");
var mockS3Client = new MockS3Client();
var mockSqsClient = new MockSqsClient();
var transportConfiguration = new TransportConfiguration(settings);
var dispatcher = new MessageDispatcher(transportConfiguration, mockS3Client, mockSqsClient, null, new QueueCache(mockSqsClient, transportConfiguration), null);
var transportOperations = new TransportOperations(
new TransportOperation(
new OutgoingMessage(Guid.NewGuid().ToString(), new Dictionary <string, string>(), Encoding.Default.GetBytes(new string('x', 256 * 1024))),
new UnicastAddressTag("address1"),
DispatchConsistency.Isolated),
new TransportOperation(
new OutgoingMessage(Guid.NewGuid().ToString(), new Dictionary <string, string>(), Encoding.Default.GetBytes(new string('x', 256 * 1024))),
new UnicastAddressTag("address2"),
DispatchConsistency.Isolated),
new TransportOperation( /* Crazy long message id will cause the message to go over limits because attributes count as well */
new OutgoingMessage(new string('x', 256 * 1024), new Dictionary <string, string>(), Encoding.Default.GetBytes("{}")),
new UnicastAddressTag("address2"),
DispatchConsistency.Isolated));
var transportTransaction = new TransportTransaction();
var context = new ContextBag();
await dispatcher.Dispatch(transportOperations, transportTransaction, context);
Assert.AreEqual(3, mockSqsClient.RequestsSent.Count);
Assert.AreEqual(3, mockS3Client.PutObjectRequestsSent.Count);
var firstUpload = mockS3Client.PutObjectRequestsSent.ElementAt(0);
var secondUpload = mockS3Client.PutObjectRequestsSent.ElementAt(1);
var thirdUpload = mockS3Client.PutObjectRequestsSent.ElementAt(2);
Assert.AreEqual("someBucket", firstUpload.BucketName);
Assert.AreEqual("someBucket", secondUpload.BucketName);
Assert.AreEqual("someBucket", thirdUpload.BucketName);
StringAssert.Contains($@"""Body"":"""",""S3BodyKey"":""{firstUpload.Key}", mockSqsClient.RequestsSent.ElementAt(0).MessageBody);
StringAssert.Contains($@"""Body"":"""",""S3BodyKey"":""{secondUpload.Key}", mockSqsClient.RequestsSent.ElementAt(1).MessageBody);
StringAssert.Contains($@"""Body"":"""",""S3BodyKey"":""{thirdUpload.Key}", mockSqsClient.RequestsSent.ElementAt(2).MessageBody);
}
public async Task Applies_user_defined_connectivity_settings()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.MessageSenders()
.RetryPolicy(RetryPolicy.NoRetry);
var factory = new InterceptedMessagingFactory();
var creator = new MessageSenderCreator(new InterceptedMessagingFactoryFactory(factory), settings);
var sender = await creator.Create("myqueue", null, AzureServiceBusConnectionString.Value);
Assert.IsInstanceOf <NoRetry>(sender.RetryPolicy);
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services
.AddMvcCore()
.AddCors()
.AddJsonFormatters()
.AddApiExplorer()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services
.AddSignalR();
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
services.AddSingleton <IEquipmentRepository, EquipmentRepository>();
services.AddScoped <EquipmentFilter>();
services.AddSingleton(serviceProvider => _endpoint);
var endpointConfiguration = new EndpointConfiguration("Bondora.ConstructionEquipmentRental.Service");
// It's used for development, for real case we should use any real transport (RabbitMQ and so on).
TransportExtensions <LearningTransport> transport = endpointConfiguration.UseTransport <LearningTransport>();
UpdateableServiceProvider container = null;
endpointConfiguration.UseContainer <ServicesBuilder>(customizations =>
{
customizations.ExistingServices(services);
customizations.ServiceProviderFactory(serviceCollection =>
{
container = new UpdateableServiceProvider(serviceCollection);
return(container);
});
});
RoutingSettings <LearningTransport> routing = transport.Routing();
routing.RouteToEndpoint(
assembly: typeof(GetInvoiceCommand).Assembly,
destination: "Bondora.ConstructionEquipmentRental.Billing");
_endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
return(container);
}
private static void ConfigureMessageRouting(TransportExtensions <SqsTransport> transport)
{
var routing = transport.Routing();
routing.RouteToEndpoint(
messageType: typeof(ProcessPayment)
, destination: "Example.PaymentSaga"
);
routing.RouteToEndpoint(
messageType: typeof(MakePayment)
, destination: "Example.PaymentProcessorWorker"
);
routing.RegisterPublisher(
eventType: typeof(ICompletedMakePayment),
publisherEndpoint: "Example.PaymentProcessorWorker");
}
public async Task Determines_the_namespace_from_partitioning_strategy()
{
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(new Conventions());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", "sales");
settings.SetDefault("NServiceBus.SharedQueue", "sales");
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var definition = await DetermineResourcesToCreate(settings);
var namespaceInfo = new RuntimeNamespaceInfo(Name, Connectionstring);
Assert.IsTrue(definition.Namespaces.Any(nsi => nsi == namespaceInfo));
}
public static void ApplyConnectionString(this TransportExtensions <RabbitMQTransport> transport, string connectionString)
{
var builder = new DbConnectionStringBuilder {
ConnectionString = connectionString
};
if (builder.GetBooleanValue("DisableRemoteCertificateValidation"))
{
transport.DisableRemoteCertificateValidation();
}
if (builder.GetBooleanValue("UseExternalAuthMechanism"))
{
transport.UseExternalAuthMechanism();
}
transport.ConnectionString(connectionString);
}
public async Task Should_set_MaxSizeInMegabytes_on_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Topics().MaxSizeInMegabytes(SizeInMegabytes.Size4096);
var creator = new AzureServiceBusTopicCreator(settings);
const string topicPath = "mytopic10";
await namespaceManager.DeleteTopic(topicPath);
await creator.Create(topicPath, namespaceManager);
var foundTopic = await namespaceManager.GetTopic(topicPath);
Assert.AreEqual(4096, foundTopic.MaxSizeInMegabytes);
}
public async Task Should_set_SupportOrdering_on_created_entity()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Topics().SupportOrdering(true);
var creator = new AzureServiceBusTopicCreator(settings);
const string topicPath = "mytopic12";
await namespaceManager.DeleteTopic(topicPath);
await creator.Create(topicPath, namespaceManager);
var foundTopic = await namespaceManager.GetTopic(topicPath);
Assert.IsTrue(foundTopic.SupportOrdering);
}
void SubscribeRouting(TransportExtensions <MsmqTransport> transportExtensions)
{
#region Routing-RegisterPublisher
var routing = transportExtensions.Routing();
routing.RegisterPublisher(
assembly: typeof(OrderAccepted).Assembly,
publisherEndpoint: "Sales");
routing.RegisterPublisher(
assembly: typeof(OrderAccepted).Assembly,
@namespace: "PriorityMessages",
publisherEndpoint: "Preferred");
routing.RegisterPublisher(
eventType: typeof(OrderSent),
publisherEndpoint: "Sending");
#endregion
}
ITopologySectionManager SetupEndpointOrientedTopologyWithFailoverNamespace(TransportPartsContainer container, string enpointname)
{
var settings = new SettingsHolder();
settings.Set <Conventions>(new Conventions());
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", enpointname);
extensions.NamespacePartitioning().AddNamespace("namespace1", AzureServiceBusConnectionString.Value);
extensions.NamespacePartitioning().AddNamespace("namespace2", AzureServiceBusConnectionString.Fallback);
extensions.NamespacePartitioning().UseStrategy <FailOverNamespacePartitioning>();
var topology = new EndpointOrientedTopology(container);
topology.Initialize(settings);
return(container.Resolve <ITopologySectionManager>());
}
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 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");
}
static void Configure(TransportExtensions <TestTransport> transportConfig, string brokerId)
{
var testRunId = TestContext.CurrentContext.Test.ID;
string tempDir;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
//can't use bin dir since that will be too long on the build agents
tempDir = @"c:\temp";
}
else
{
tempDir = Path.GetTempPath();
}
var storageDir = Path.Combine(tempDir, testRunId, brokerId);
transportConfig.StorageDirectory(storageDir);
}
public async Task Should_properly_set_EnableDeadLetteringOnMessageExpiration_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.UseForwardingTopology().Subscriptions().EnableDeadLetteringOnMessageExpiration(true);
var creator = new AzureServiceBusForwardingSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
const string subscriptionName = "endpoint7";
await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager, forwardToQueue);
var foundDescription = await namespaceManager.GetSubscription(topicPath, subscriptionName);
Assert.IsTrue(foundDescription.EnableDeadLetteringOnMessageExpiration);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public async Task Should_properly_set_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.Subscriptions().EnableBatchedOperations(false);
var creator = new AzureServiceBusSubscriptionCreator(settings.Get <TopologySettings>().SubscriptionSettings);
const string subscriptionName = "sub5";
await creator.Create(topicPath, subscriptionName, metadata, sqlFilter, namespaceManager);
var foundDescription = await namespaceManager.GetSubscription(topicPath, subscriptionName);
Assert.IsFalse(foundDescription.EnableBatchedOperations);
await namespaceManager.DeleteSubscription(new SubscriptionDescription(topicPath, subscriptionName));
}
public void Should_fail_sanitization_for_invalid_endpoint_name(string reasonToFail, string endpointName)
{
var container = new TransportPartsContainer();
var settings = new SettingsHolder();
container.Register(typeof(SettingsHolder), () => settings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
settings.SetDefault("NServiceBus.Routing.EndpointName", endpointName);
extensions.NamespacePartitioning().AddNamespace(Name, Connectionstring);
var topology = new ForwardingTopology(container);
topology.Initialize(settings);
var sectionManager = container.Resolve <ITopologySectionManager>();
Assert.Throws <Exception>(() => sectionManager.DetermineResourcesToCreate(new QueueBindings()), "Was expected to fail: " + reasonToFail);
}
