public async Task ClientCanConnectUsingSasCredential() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false)) { var options = new ServiceBusClientOptions(); var audience = ServiceBusConnection.BuildConnectionResource(options.TransportType, TestEnvironment.FullyQualifiedNamespace, scope.QueueName); var connectionString = TestEnvironment.BuildConnectionStringWithSharedAccessSignature(scope.QueueName, audience); var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); var credential = new AzureSasCredential(parsed.SharedAccessSignature); await using (var client = new ServiceBusClient(TestEnvironment.FullyQualifiedNamespace, credential, options)) { Assert.That(async() => { ServiceBusReceiver receiver = null; try { receiver = client.CreateReceiver(scope.QueueName); } finally { await(receiver?.DisposeAsync() ?? new ValueTask()); } }, Throws.Nothing); } } }
public void ToConnectionStringAllowsSharedAccessSignatureAuthorization() { var fakeConnection = "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessSignature=[not_real]"; var properties = ServiceBusConnectionStringProperties.Parse(fakeConnection); Assert.That(() => properties.ToConnectionString(), Throws.Nothing, "Validation should accept the shared access signature authorization."); }
private async Task ServiceBusMessagePump_PublishServiceBusMessage_MessageSuccessfullyProcessed(Encoding messageEncoding, string connectionStringKey) { // Arrange var operationId = Guid.NewGuid().ToString(); var transactionId = Guid.NewGuid().ToString(); var connectionString = Configuration.GetValue <string>(connectionStringKey); ServiceBusConnectionStringProperties serviceBusConnectionString = ServiceBusConnectionStringProperties.Parse(connectionString); await using (var client = new ServiceBusClient(connectionString)) await using (ServiceBusSender messageSender = client.CreateSender(serviceBusConnectionString.EntityPath)) { var order = OrderGenerator.Generate(); var orderMessage = order.AsServiceBusMessage(operationId, transactionId, encoding: messageEncoding); // Act await messageSender.SendMessageAsync(orderMessage); // Assert var receivedEvent = _serviceBusEventConsumerHost.GetReceivedEvent(operationId); Assert.NotEmpty(receivedEvent); var deserializedEventGridMessage = EventParser.Parse(receivedEvent); Assert.NotNull(deserializedEventGridMessage); var orderCreatedEvent = Assert.Single(deserializedEventGridMessage.Events); Assert.NotNull(orderCreatedEvent); var orderCreatedEventData = orderCreatedEvent.GetPayload <OrderCreatedEventData>(); Assert.NotNull(orderCreatedEventData); Assert.NotNull(orderCreatedEventData.CorrelationInfo); Assert.Equal(order.Id, orderCreatedEventData.Id); Assert.Equal(order.Amount, orderCreatedEventData.Amount); Assert.Equal(order.ArticleNumber, orderCreatedEventData.ArticleNumber); Assert.Equal(transactionId, orderCreatedEventData.CorrelationInfo.TransactionId); Assert.Equal(operationId, orderCreatedEventData.CorrelationInfo.OperationId); Assert.NotEmpty(orderCreatedEventData.CorrelationInfo.CycleId); } }
/// <summary> /// Tries receiving a single dead lettered message on the Azure Service Bus dead letter queue. /// </summary> /// <param name="connectionString">The connection string to connect to the Azure Service Bus.</param> public async Task AssertDeadLetterMessageAsync(string connectionString) { var properties = ServiceBusConnectionStringProperties.Parse(connectionString); var options = new ServiceBusReceiverOptions { SubQueue = SubQueue.DeadLetter }; await using (var client = new ServiceBusClient(connectionString)) await using (var receiver = client.CreateReceiver(properties.EntityPath, options)) { RetryPolicy <ServiceBusReceivedMessage> retryPolicy = Policy.HandleResult <ServiceBusReceivedMessage>(result => result is null) .WaitAndRetryForeverAsync(index => TimeSpan.FromSeconds(1)); await Policy.TimeoutAsync(TimeSpan.FromMinutes(2)) .WrapAsync(retryPolicy) .ExecuteAsync(async() => { ServiceBusReceivedMessage message = await receiver.ReceiveMessageAsync(); if (message != null) { _logger.LogInformation("Received dead lettered message in test suite"); await receiver.CompleteMessageAsync(message); } else { _logger.LogInformation("No dead lettered message received in test suite, retrying..."); } return(message); }); } }
public async Task ServiceBusQueueMessagePumpUsingManagedIdentity_PublishServiceBusMessage_MessageSuccessfullyProcessed() { // Arrange var config = TestConfig.Create(); string connectionString = config.GetServiceBusConnectionString(ServiceBusEntityType.Queue); ServiceBusConnectionStringProperties properties = ServiceBusConnectionStringProperties.Parse(connectionString); ServicePrincipal servicePrincipal = config.GetServiceBusServicePrincipal(); string tenantId = config.GetTenantId(); using (TemporaryEnvironmentVariable.Create(EnvironmentVariables.AzureTenantId, tenantId)) using (TemporaryEnvironmentVariable.Create(EnvironmentVariables.AzureServicePrincipalClientId, servicePrincipal.ClientId)) using (TemporaryEnvironmentVariable.Create(EnvironmentVariables.AzureServicePrincipalClientSecret, servicePrincipal.ClientSecret)) { var options = new WorkerOptions(); options.AddEventGridPublisher(config) .AddServiceBusQueueMessagePumpUsingManagedIdentity( queueName: properties.EntityPath, serviceBusNamespace: properties.FullyQualifiedNamespace, clientId: servicePrincipal.ClientId, configureMessagePump: opt => opt.AutoComplete = true) .WithServiceBusMessageHandler <OrdersAzureServiceBusMessageHandler, Order>(); // Act await using (var worker = await Worker.StartNewAsync(options)) await using (var service = await TestMessagePumpService.StartNewAsync(config, _logger)) { // Assert await service.SimulateMessageProcessingAsync(connectionString); } } }
public AzureServiceBusTestEnvironment(IMessageSink messageSink) { var solutionRoot = SolutionPaths.Root; var terraformResourceDirectory = Path.Combine(solutionRoot, "build", "terraform", "azure", "service_bus"); var credentials = AzureCredentials.Instance; // don't try to run terraform if not authenticated. if (credentials is Unauthenticated) { return; } _terraform = new TerraformResources(terraformResourceDirectory, credentials, messageSink); var resourceGroupName = AzureResources.CreateResourceGroupName("service-bus-test"); _variables = new Dictionary <string, string> { ["resource_group"] = resourceGroupName, ["servicebus_namespace"] = "dotnet-" + Guid.NewGuid() }; _terraform.Init(); _terraform.Apply(_variables); ServiceBusConnectionString = _terraform.Output("connection_string"); ServiceBusConnectionStringProperties = ServiceBusConnectionStringProperties.Parse(ServiceBusConnectionString); }
public MessagingConfiguration(IOptions <MessageSources> messageSources, MessageHandlerRegistry registry, IServiceScopeFactory scopeFactory, LogCorrelationHandler logCorrelationHandler) { ServiceBusClient CreateClient(MessageSource s) { if (!string.IsNullOrEmpty(s.ConnectionString)) { return(new ServiceBusClient(s.ConnectionString)); } if (s.CredentialType == nameof(AzureCliCredential)) { return(new ServiceBusClient(s.Namespace, new AzureCliCredential())); } if (s.CredentialType == nameof(DefaultAzureCredential)) { return(new ServiceBusClient(s.Namespace, new DefaultAzureCredential())); } throw new InvalidOperationException("Could not create ServiceBusClient"); } string GetEntityName(MessageSource s) => string.IsNullOrEmpty(s.EntityName) ? ServiceBusConnectionStringProperties.Parse(s.ConnectionString).EntityPath : s.EntityName; (ServiceBusClient, ServiceBusProcessor) CreateSubscriptionClient(Subscription s) { var client = CreateClient(s); return(client, client.CreateProcessor(GetEntityName(s), s.Name, new ServiceBusProcessorOptions { AutoCompleteMessages = false, MaxConcurrentCalls = s.MaxConcurrentCalls })); } (ServiceBusClient, ServiceBusProcessor) CreateQueueClient(Queue q) { var client = CreateClient(q); return(client, client.CreateProcessor(GetEntityName(q), new ServiceBusProcessorOptions { AutoCompleteMessages = false, MaxConcurrentCalls = q.MaxConcurrentCalls })); } Dispatchers = messageSources .Value .Subscriptions .Select(subscription => new MessageDispatcher(scopeFactory, CreateSubscriptionClient(subscription), registry, logCorrelationHandler)) .Concat( messageSources .Value .Queues .Select(queue => new MessageDispatcher(scopeFactory, CreateQueueClient(queue), registry, logCorrelationHandler)) ) .ToList(); }
public async Task ServiceBusTopicMessagePumpWithNamespaceScopedConnectionString_PublishesServiceBusMessage_MessageSuccessfullyProcessed() { // Arrange var config = TestConfig.Create(); string topicConnectionString = config.GetServiceBusConnectionString(ServiceBusEntityType.Topic); var properties = ServiceBusConnectionStringProperties.Parse(topicConnectionString); string namespaceConnectionString = properties.GetNamespaceConnectionString(); var options = new WorkerOptions(); options.AddEventGridPublisher(config) .AddServiceBusTopicMessagePump( topicName: properties.EntityPath, subscriptionName: "Test-Receive-All-Topic-Only", getConnectionStringFromConfigurationFunc: configuration => namespaceConnectionString, configureMessagePump: opt => opt.AutoComplete = true) .WithServiceBusMessageHandler <OrdersAzureServiceBusMessageHandler, Order>(); // Act await using (var worker = await Worker.StartNewAsync(options)) await using (var service = await TestMessagePumpService.StartNewAsync(config, _logger)) { // Assert await service.SimulateMessageProcessingAsync(topicConnectionString); } }
private string DetermineEntityPath(string connectionString = null) { if (_tokenCredential is null && !string.IsNullOrWhiteSpace(connectionString)) { var properties = ServiceBusConnectionStringProperties.Parse(connectionString); if (string.IsNullOrWhiteSpace(properties.EntityPath)) { // Connection string doesn't include the entity so we're using the message pump settings if (string.IsNullOrWhiteSpace(EntityName)) { throw new ArgumentException("No Azure Service Bus entity name was specified while the connection string is scoped to the namespace"); } return(EntityName); } return(properties.EntityPath); } if (string.IsNullOrWhiteSpace(EntityName)) { throw new ArgumentException("No Azure Service Bus entity name was specified while the managed identity authentication requires this"); } return(EntityName); }
public MessagePublisher(string connectionString) { if (string.IsNullOrWhiteSpace(connectionString) || !connectionString.ToLower().Contains("entitypath")) { throw new ArgumentNullException($"ConnectionString must be supplied with EnitityPath"); } _entityPath = ServiceBusConnectionStringProperties.Parse(connectionString).EntityPath; _client = new ServiceBusClient(connectionString); }
/// <summary> /// Ensures that a Service Bus namespace is available. If the <see cref="ServiceBusConnectionString"/> override was set for the environment, /// that namespace will be respected. Otherwise, a new Service Bus namespace will be created on Azure for this test run. /// </summary> /// /// <returns>The active Service Bus namespace for this test run.</returns> /// private NamespaceProperties ParseServiceBusNamespace(string serviceBusConnectionString) { var parsed = ServiceBusConnectionStringProperties.Parse(serviceBusConnectionString); return(new NamespaceProperties ( parsed.Endpoint.Host.Substring(0, parsed.Endpoint.Host.IndexOf('.')), serviceBusConnectionString.Replace($";EntityPath={parsed.EntityPath}", string.Empty), false )); }
private ServiceBusAdministrationClient CreateSharedKeyTokenClient() { var properties = ServiceBusConnectionStringProperties.Parse(GetConnectionString()); var credential = new AzureNamedKeyCredential(properties.SharedAccessKeyName, properties.SharedAccessKey); return(InstrumentClient( new ServiceBusAdministrationClient( TestEnvironment.FullyQualifiedNamespace, credential, InstrumentClientOptions(new ServiceBusAdministrationClientOptions())))); }
/// <summary> /// Sends an Azure Service Bus message to the message pump. /// </summary> /// <param name="connectionString">The connection string to connect to the service bus.</param> /// <param name="message">The message to send.</param> public async Task SendMessageToServiceBusAsync(string connectionString, ServiceBusMessage message) { Guard.NotNullOrWhitespace(connectionString, nameof(connectionString)); ServiceBusConnectionStringProperties serviceBusConnectionString = ServiceBusConnectionStringProperties.Parse(connectionString); await using (var client = new ServiceBusClient(connectionString)) await using (ServiceBusSender messageSender = client.CreateSender(serviceBusConnectionString.EntityPath)) { await messageSender.SendMessageAsync(message); } }
private ServiceBusAdministrationClient CreateSasTokenClient() { var properties = ServiceBusConnectionStringProperties.Parse(GetConnectionString()); var resource = ServiceBusAdministrationClient.BuildAudienceResource(TestEnvironment.FullyQualifiedNamespace); var signature = new SharedAccessSignature(resource, properties.SharedAccessKeyName, properties.SharedAccessKey); var credential = new AzureSasCredential(signature.Value); return(InstrumentClient( new ServiceBusAdministrationClient( TestEnvironment.FullyQualifiedNamespace, credential, InstrumentClientOptions(new ServiceBusAdministrationClientOptions())))); }
public void ParseIgnoresUnknownTokens() { var endpoint = "test.endpoint.com"; var eventHub = "some-path"; var sasKey = "sasKey"; var sasKeyName = "sasName"; var connectionString = $"Endpoint=sb://{ endpoint };SharedAccessKeyName={ sasKeyName };Unknown=INVALID;SharedAccessKey={ sasKey };EntityPath={ eventHub };Trailing=WHOAREYOU"; var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); Assert.That(parsed.Endpoint?.Host, Is.EqualTo(endpoint).Using((IComparer <string>)StringComparer.OrdinalIgnoreCase), "The endpoint host should match."); Assert.That(parsed.SharedAccessKeyName, Is.EqualTo(sasKeyName), "The SAS key name should match."); Assert.That(parsed.SharedAccessKey, Is.EqualTo(sasKey), "The SAS key value should match."); Assert.That(parsed.EntityPath, Is.EqualTo(eventHub), "The Service Bus path should match."); }
public async Task SendWithNamedKeyCredential() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var properties = ServiceBusConnectionStringProperties.Parse(TestEnvironment.ServiceBusConnectionString); var credential = new AzureNamedKeyCredential(properties.SharedAccessKeyName, properties.SharedAccessKey); await using var client = new ServiceBusClient(TestEnvironment.FullyQualifiedNamespace, credential, new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets }); var sender = client.CreateSender(scope.QueueName); await sender.SendMessageAsync(ServiceBusTestUtilities.GetMessage()); } }
private static ServiceBusReceiver CreateServiceBusReceiver( ServiceBusClient client, string connectionString, string subscriptionName) { var properties = ServiceBusConnectionStringProperties.Parse(connectionString); if (subscriptionName is null) { return(client.CreateReceiver(properties.EntityPath)); } return(client.CreateReceiver(properties.EntityPath, subscriptionName)); }
public void ParseCorrectlyParsesANamespaceConnectionString() { var endpoint = "test.endpoint.com"; var sasKey = "sasKey"; var sasKeyName = "sasName"; var sharedAccessSignature = "fakeSAS"; var connectionString = $"Endpoint=sb://{ endpoint };SharedAccessKeyName={ sasKeyName };SharedAccessKey={ sasKey };SharedAccessSignature={ sharedAccessSignature }"; var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); Assert.That(parsed.Endpoint?.Host, Is.EqualTo(endpoint).Using((IComparer <string>)StringComparer.OrdinalIgnoreCase), "The endpoint host should match."); Assert.That(parsed.SharedAccessKeyName, Is.EqualTo(sasKeyName), "The SAS key name should match."); Assert.That(parsed.SharedAccessKey, Is.EqualTo(sasKey), "The SAS key value should match."); Assert.That(parsed.SharedAccessSignature, Is.EqualTo(sharedAccessSignature), "The precomputed SAS should match."); Assert.That(parsed.EntityPath, Is.Null, "The Service Bus path was not included in the connection string"); }
public void ParseDoesNotForceTokenOrdering(string connectionString, string endpoint, string eventHub, string sasKeyName, string sasKey, string shardAccessSignature) { var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); Assert.That(parsed.Endpoint?.Host, Is.EqualTo(endpoint).Using((IComparer <string>)StringComparer.OrdinalIgnoreCase), "The endpoint host should match."); Assert.That(parsed.SharedAccessKeyName, Is.EqualTo(sasKeyName), "The SAS key name should match."); Assert.That(parsed.SharedAccessKey, Is.EqualTo(sasKey), "The SAS key value should match."); Assert.That(parsed.SharedAccessSignature, Is.EqualTo(shardAccessSignature), "The precomputed SAS should match."); Assert.That(parsed.EntityPath, Is.EqualTo(eventHub), "The Service Bus path should match."); }
/// <summary> /// Simulate the message processing of the message pump using the Service Bus. /// </summary> public async Task SimulateMessageProcessingAsync() { if (_serviceBusEventConsumerHost is null) { throw new InvalidOperationException( "Cannot simulate the message pump because the service is not yet started; please start this service before simulating"); } var operationId = Guid.NewGuid().ToString(); var transactionId = Guid.NewGuid().ToString(); string connectionString = _configuration.GetServiceBusConnectionString(_entity); var connectionStringProperties = ServiceBusConnectionStringProperties.Parse(connectionString); await using (var client = new ServiceBusClient(connectionString)) await using (ServiceBusSender messageSender = client.CreateSender(connectionStringProperties.EntityPath)) { try { Order order = GenerateOrder(); ServiceBusMessage orderMessage = order.AsServiceBusMessage(operationId, transactionId); await messageSender.SendMessageAsync(orderMessage); string receivedEvent = _serviceBusEventConsumerHost.GetReceivedEvent(operationId); Assert.NotEmpty(receivedEvent); EventBatch <Event> eventBatch = EventParser.Parse(receivedEvent); Assert.NotNull(eventBatch); Event orderCreatedEvent = Assert.Single(eventBatch.Events); Assert.NotNull(orderCreatedEvent); var orderCreatedEventData = orderCreatedEvent.GetPayload <OrderCreatedEventData>(); Assert.NotNull(orderCreatedEventData); Assert.NotNull(orderCreatedEventData.CorrelationInfo); Assert.Equal(order.Id, orderCreatedEventData.Id); Assert.Equal(order.Amount, orderCreatedEventData.Amount); Assert.Equal(order.ArticleNumber, orderCreatedEventData.ArticleNumber); Assert.Equal(transactionId, orderCreatedEventData.CorrelationInfo.TransactionId); Assert.Equal(operationId, orderCreatedEventData.CorrelationInfo.OperationId); Assert.NotEmpty(orderCreatedEventData.CorrelationInfo.CycleId); } finally { await messageSender.CloseAsync(); } } }
public void ParseDoesAcceptsHostNamesAndUrisForTheEndpoint(string endpointValue) { var connectionString = $"Endpoint={ endpointValue };EntityPath=dummy"; var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); if (!Uri.TryCreate(endpointValue, UriKind.Absolute, out var valueUri)) { valueUri = new Uri($"fake://{ endpointValue }"); } Assert.That(parsed.Endpoint.Port, Is.EqualTo(-1), "The default port should be used."); Assert.That(parsed.Endpoint.Host, Does.Not.Contain(" "), "The host name should not contain any spaces."); Assert.That(parsed.Endpoint.Host, Does.Not.Contain(":"), "The host name should not contain any port separators (:)."); Assert.That(parsed.Endpoint.Host, Does.Not.Contain(valueUri.Port), "The host name should not contain the port."); Assert.That(parsed.Endpoint.Host, Is.EqualTo(valueUri.Host), "The host name should have been normalized."); Assert.That(parsed.Endpoint.ToString(), Does.StartWith(GetServiceBusEndpointScheme()), "The parser's endpoint scheme should have been used."); }
public void ToConnectionStringProducesTheConnectionStringForSharedAccessSignatures() { var properties = new ServiceBusConnectionStringProperties { Endpoint = new Uri("sb://place.endpoint.ext"), EntityPath = "HubName", SharedAccessSignature = "FaKe#$1324@@" }; var connectionString = properties.ToConnectionString(); Assert.That(connectionString, Is.Not.Null, "The connection string should not be null."); Assert.That(connectionString.Length, Is.GreaterThan(0), "The connection string should have content."); var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); Assert.That(parsed, Is.Not.Null, "The connection string should be parsable."); Assert.That(PropertiesAreEquivalent(properties, parsed), Is.True, "The connection string should parse into the source properties."); }
/// <summary> /// Ensures that a Service Bus namespace is available. If the <see cref="OverrideServiceBusConnectionString"/> override was set for the environment, /// that namespace will be respected. Otherwise, a new Service Bus namespace will be created on Azure for this test run. /// </summary> /// /// <returns>The active Service Bus namespace for this test run.</returns> /// private NamespaceProperties EnsureServiceBusNamespace() { if (!string.IsNullOrEmpty(OverrideServiceBusConnectionString)) { var parsed = ServiceBusConnectionStringProperties.Parse(OverrideServiceBusConnectionString); return(new NamespaceProperties ( parsed.Endpoint.Host.Substring(0, parsed.Endpoint.Host.IndexOf('.')), OverrideServiceBusConnectionString.Replace($";EntityPath={ parsed.EntityPath }", string.Empty), false )); } return(Task .Run(async() => await ServiceBusScope.CreateNamespaceAsync().ConfigureAwait(false)) .ConfigureAwait(false) .GetAwaiter() .GetResult()); }
public async Task ServiceBusQueueMessagePumpWithNamespaceScopedConnectionString_PublishesServiceBusMessage_MessageSuccessfullyProcessed() { // Arrange var config = TestConfig.Create(); string entityConnectionString = config.GetServiceBusConnectionString(ServiceBusEntityType.Queue); var properties = ServiceBusConnectionStringProperties.Parse(entityConnectionString); string namespaceConnectionString = properties.GetNamespaceConnectionString(); var options = new WorkerOptions(); options.AddEventGridPublisher(config) .AddServiceBusQueueMessagePump(properties.EntityPath, configuration => namespaceConnectionString, opt => opt.AutoComplete = true) .WithServiceBusMessageHandler <OrdersAzureServiceBusMessageHandler, Order>(); // Act await using (var worker = await Worker.StartNewAsync(options)) await using (var service = await TestMessagePumpService.StartNewAsync(config, _logger)) { // Assert await service.SimulateMessageProcessingAsync(entityConnectionString); } }
public void ToConnectionStringNormalizesTheEndpointScheme(string scheme) { var properties = new ServiceBusConnectionStringProperties { Endpoint = new Uri(string.Concat(scheme, "myhub.servicebus.windows.net")), EntityPath = "HubName", SharedAccessKey = "FaKe#$1324@@", SharedAccessKeyName = "RootSharedAccessManagementKey" }; var connectionString = properties.ToConnectionString(); Assert.That(connectionString, Is.Not.Null, "The connection string should not be null."); Assert.That(connectionString.Length, Is.GreaterThan(0), "The connection string should have content."); var parsed = ServiceBusConnectionStringProperties.Parse(connectionString); Assert.That(parsed, Is.Not.Null, "The connection string should be parsable."); Assert.That(parsed.Endpoint.Host, Is.EqualTo(properties.Endpoint.Host), "The host name of the endpoints should match."); var expectedScheme = new Uri(string.Concat(GetServiceBusEndpointScheme(), "fake.fake.com")).Scheme; Assert.That(parsed.Endpoint.Scheme, Is.EqualTo(expectedScheme), "The endpoint scheme should have been overridden."); }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusTestEnvironment"/> class. /// </summary> /// public ServiceBusTestEnvironment() : base("servicebus") { ActiveServiceBusNamespace = new Lazy <NamespaceProperties>(EnsureServiceBusNamespace, LazyThreadSafetyMode.ExecutionAndPublication); ParsedConnectionString = new Lazy <ServiceBusConnectionStringProperties>(() => ServiceBusConnectionStringProperties.Parse(ServiceBusConnectionString), LazyThreadSafetyMode.ExecutionAndPublication); }
public void ParseToConnectionStringsArguments(string connectionString) { ExactTypeConstraint typeConstraint = connectionString is null ? Throws.ArgumentNullException : Throws.ArgumentException; Assert.That(() => ServiceBusConnectionStringProperties.Parse(connectionString), typeConstraint); }
public void ParseDoesNotAllowAnInvalidEndpointFormat(string endpointValue) { var connectionString = $"Endpoint={endpointValue }"; Assert.That(() => ServiceBusConnectionStringProperties.Parse(connectionString), Throws.InstanceOf <FormatException>()); }
public void ParseConsidersMissingValuesAsMalformed(string connectionString) { Assert.That(() => ServiceBusConnectionStringProperties.Parse(connectionString), Throws.InstanceOf <FormatException>()); }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusTestEnvironment"/> class. /// </summary> /// public ServiceBusTestEnvironment() { ActiveServiceBusNamespace = new Lazy <NamespaceProperties>(() => EnsureServiceBusNamespace(OverrideServiceBusConnectionString), LazyThreadSafetyMode.ExecutionAndPublication); SecondaryServiceBusNamespace = new Lazy <NamespaceProperties>(() => EnsureServiceBusNamespace(OverrideSecondaryServiceBusConnectionString), LazyThreadSafetyMode.ExecutionAndPublication); ParsedConnectionString = new Lazy <ServiceBusConnectionStringProperties>(() => ServiceBusConnectionStringProperties.Parse(ServiceBusConnectionString), LazyThreadSafetyMode.ExecutionAndPublication); }