[release/8.0] Add multiple keyed services tests (#3919)

tests/Aspire.Azure.AI.OpenAI.Tests/AspireAzureAIOpenAIExtensionsTests.cs

@@ -86,4 +86,29 @@ public void ReadsFromConnectionStringsFormats(string connectionString)
         Assert.NotNull(client);
     }
 
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:openai1", ConnectionString),
+            new KeyValuePair<string, string?>("ConnectionStrings:openai2", ConnectionString + "2"),
+            new KeyValuePair<string, string?>("ConnectionStrings:openai3", ConnectionString + "3")
+        ]);
+
+        builder.AddAzureOpenAIClient("openai1");
+        builder.AddKeyedAzureOpenAIClient("openai2");
+        builder.AddKeyedAzureOpenAIClient("openai3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<OpenAIClient>();
+        var client2 = host.Services.GetRequiredKeyedService<OpenAIClient>("openai2");
+        var client3 = host.Services.GetRequiredKeyedService<OpenAIClient>("openai3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+    }
 }

tests/Aspire.Azure.Data.Tables.Tests/AspireTablesExtensionsTests.cs

@@ -124,4 +124,34 @@ public void ServiceUriWorksInConnectionStrings(bool useKeyed)
 
         Assert.Equal("aspirestoragetests", client.AccountName);
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:tables1", ConnectionString),
+            new KeyValuePair<string, string?>("ConnectionStrings:tables2", "AccountName=account2;AccountKey=fake"),
+            new KeyValuePair<string, string?>("ConnectionStrings:tables3", "AccountName=account3;AccountKey=fake")
+        ]);
+
+        builder.AddAzureTableClient("tables1");
+        builder.AddKeyedAzureTableClient("tables2");
+        builder.AddKeyedAzureTableClient("tables3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<TableServiceClient>();
+        var client2 = host.Services.GetRequiredKeyedService<TableServiceClient>("tables2");
+        var client3 = host.Services.GetRequiredKeyedService<TableServiceClient>("tables3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal("aspirestoragetests", client1.AccountName);
+        Assert.Equal("account2", client2.AccountName);
+        Assert.Equal("account3", client3.AccountName);
+    }
 }

tests/Aspire.Azure.Messaging.EventHubs.Tests/AspireEventHubsExtensionsTests.cs

@@ -247,23 +247,23 @@ public void ConnectionNameWinsOverConfigSection(bool useKeyed, int clientIndex)
 
     private static void RetrieveAndAssert(bool useKeyed, int clientIndex, IHost host)
     {
-        var client = RetrieveClient(useKeyed, clientIndex, host);
+        var client = RetrieveClient(useKeyed ? "eh" : null, clientIndex, host);
 
-        AssertFullyQualifiedNamespace(client);
+        AssertFullyQualifiedNamespace(FullyQualifiedNamespace, client);
     }
 
-    private static object RetrieveClient(bool useKeyed, int clientIndex, IHost host)
+    private static object RetrieveClient(object? key, int clientIndex, IHost host)
     {
-        var client = useKeyed ?
-            host.Services.GetRequiredKeyedService(s_clientTypes[clientIndex], "eh") :
+        var client = key is not null ?
+            host.Services.GetRequiredKeyedService(s_clientTypes[clientIndex], key) :
             host.Services.GetRequiredService(s_clientTypes[clientIndex]);
 
         return client;
     }
 
-    private static void AssertFullyQualifiedNamespace(object client)
+    private static void AssertFullyQualifiedNamespace(string expectedNamespace, object client)
     {
-        Assert.Equal(FullyQualifiedNamespace, client switch
+        Assert.Equal(expectedNamespace, client switch
         {
             EventHubProducerClient producer => producer.FullyQualifiedNamespace,
             EventHubConsumerClient consumer => consumer.FullyQualifiedNamespace,
@@ -324,6 +324,50 @@ public void NamespaceWorksInConnectionStrings(bool useKeyed, int clientIndex)
         RetrieveAndAssert(useKeyed, clientIndex, host);
     }
 
+    [Theory]
+    [InlineData(EventHubProducerClientIndex)]
+    [InlineData(EventHubConsumerClientIndex)]
+    [InlineData(EventProcessorClientIndex)]
+    [InlineData(PartitionReceiverIndex)]
+    public void CanAddMultipleKeyedServices(int clientIndex)
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:eh1", EhConnectionString),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:BlobContainerName", "checkpoints"),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:PartitionId", "foo"),
+
+            new KeyValuePair<string, string?>("ConnectionStrings:eh2", EhConnectionString.Replace("aspireeventhubstests", "aspireeventhubstests2")),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:eh2:BlobContainerName", "checkpoints"),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:eh2:PartitionId", "foo"),
+
+            new KeyValuePair<string, string?>("ConnectionStrings:eh3", EhConnectionString.Replace("aspireeventhubstests", "aspireeventhubstests3")),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:eh3:BlobContainerName", "checkpoints"),
+            new KeyValuePair<string, string?>($"Aspire:Azure:Messaging:EventHubs:{s_clientTypes[clientIndex].Name}:eh3:PartitionId", "foo"),
+        ]);
+
+        ConfigureBlobServiceClient(useKeyed: false, builder.Services);
+
+        s_clientAdders[clientIndex](builder, "eh1", null);
+        s_keyedClientAdders[clientIndex](builder, "eh2", null);
+        s_keyedClientAdders[clientIndex](builder, "eh3", null);
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = RetrieveClient(key: null, clientIndex, host);
+        var client2 = RetrieveClient(key: "eh2", clientIndex, host);
+        var client3 = RetrieveClient(key: "eh3", clientIndex, host);
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //AssertFullyQualifiedNamespace("aspireeventhubstests.servicebus.windows.net", client1);
+        AssertFullyQualifiedNamespace("aspireeventhubstests2.servicebus.windows.net", client2);
+        AssertFullyQualifiedNamespace("aspireeventhubstests3.servicebus.windows.net", client3);
+    }
+
     public static string CreateConfigKey(string prefix, string? key, string suffix)
         => string.IsNullOrEmpty(key) ? $"{prefix}:{suffix}" : $"{prefix}:{key}:{suffix}";
 }

tests/Aspire.Azure.Messaging.ServiceBus.Tests/AspireServiceBusExtensionsTests.cs

@@ -124,4 +124,34 @@ public void NamespaceWorksInConnectionStrings(bool useKeyed)
 
         Assert.Equal(ConformanceTests.FullyQualifiedNamespace, client.FullyQualifiedNamespace);
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:sb1", ConnectionString),
+            new KeyValuePair<string, string?>("ConnectionStrings:sb2", "Endpoint=sb://aspireservicebustests2.servicebus.windows.net/;SharedAccessKeyName=fake;SharedAccessKey=fake"),
+            new KeyValuePair<string, string?>("ConnectionStrings:sb3", "Endpoint=sb://aspireservicebustests3.servicebus.windows.net/;SharedAccessKeyName=fake;SharedAccessKey=fake")
+        ]);
+
+        builder.AddAzureServiceBusClient("sb1");
+        builder.AddKeyedAzureServiceBusClient("sb2");
+        builder.AddKeyedAzureServiceBusClient("sb3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<ServiceBusClient>();
+        var client2 = host.Services.GetRequiredKeyedService<ServiceBusClient>("sb2");
+        var client3 = host.Services.GetRequiredKeyedService<ServiceBusClient>("sb3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal(ConformanceTests.FullyQualifiedNamespace, client1.FullyQualifiedNamespace);
+        Assert.Equal("aspireservicebustests2.servicebus.windows.net", client2.FullyQualifiedNamespace);
+        Assert.Equal("aspireservicebustests3.servicebus.windows.net", client3.FullyQualifiedNamespace);
+    }
 }

tests/Aspire.Azure.Search.Documents.Tests/AspireAzureSearchExtensionsTests.cs

@@ -68,4 +68,34 @@ public void ConnectionStringCanBeSetInCode(bool useKeyed)
         Assert.NotNull(client);
         Assert.Equal(new Uri(SearchEndpoint), client.Endpoint);
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:search1", ConnectionString),
+            new KeyValuePair<string, string?>("ConnectionStrings:search2", "Endpoint=https://aspireazuresearchtests2.search.windows.net/;Key=fake"),
+            new KeyValuePair<string, string?>("ConnectionStrings:search3", "Endpoint=https://aspireazuresearchtests3.search.windows.net/;Key=fake")
+        ]);
+
+        builder.AddAzureSearchClient("search1");
+        builder.AddKeyedAzureSearchClient("search2");
+        builder.AddKeyedAzureSearchClient("search3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<SearchIndexClient>();
+        var client2 = host.Services.GetRequiredKeyedService<SearchIndexClient>("search2");
+        var client3 = host.Services.GetRequiredKeyedService<SearchIndexClient>("search3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal(new Uri(SearchEndpoint), client1.Endpoint);
+        Assert.Equal(new Uri("https://aspireazuresearchtests2.search.windows.net/"), client2.Endpoint);
+        Assert.Equal(new Uri("https://aspireazuresearchtests3.search.windows.net/"), client3.Endpoint);
+    }
 }

tests/Aspire.Azure.Security.KeyVault.Tests/AspireKeyVaultExtensionsTests.cs

@@ -171,4 +171,34 @@ private static MockResponse CreateResponse(string content)
 
         return response;
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:secrets1", ConformanceTests.VaultUri),
+            new KeyValuePair<string, string?>("ConnectionStrings:secrets2", "https://aspiretests2.vault.azure.net/"),
+            new KeyValuePair<string, string?>("ConnectionStrings:secrets3", "https://aspiretests3.vault.azure.net/")
+        ]);
+
+        builder.AddAzureKeyVaultClient("secrets1");
+        builder.AddKeyedAzureKeyVaultClient("secrets2");
+        builder.AddKeyedAzureKeyVaultClient("secrets3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<SecretClient>();
+        var client2 = host.Services.GetRequiredKeyedService<SecretClient>("secrets2");
+        var client3 = host.Services.GetRequiredKeyedService<SecretClient>("secrets3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal(new Uri(ConformanceTests.VaultUri), client1.VaultUri);
+        Assert.Equal(new Uri("https://aspiretests2.vault.azure.net/"), client2.VaultUri);
+        Assert.Equal(new Uri("https://aspiretests3.vault.azure.net/"), client3.VaultUri);
+    }
 }

tests/Aspire.Azure.Storage.Blobs.Tests/AspireBlobStorageExtensionsTests.cs

@@ -124,4 +124,34 @@ public void ServiceUriWorksInConnectionStrings(bool useKeyed)
 
         Assert.Equal("aspirestoragetests", client.AccountName);
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:blob1", ConformanceTests.ServiceUri),
+            new KeyValuePair<string, string?>("ConnectionStrings:blob2", "https://aspirestoragetests2.blob.core.windows.net/"),
+            new KeyValuePair<string, string?>("ConnectionStrings:blob3", "https://aspirestoragetests3.blob.core.windows.net/")
+        ]);
+
+        builder.AddAzureBlobClient("blob1");
+        builder.AddKeyedAzureBlobClient("blob2");
+        builder.AddKeyedAzureBlobClient("blob3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<BlobServiceClient>();
+        var client2 = host.Services.GetRequiredKeyedService<BlobServiceClient>("blob2");
+        var client3 = host.Services.GetRequiredKeyedService<BlobServiceClient>("blob3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal("aspirestoragetests", client1.AccountName);
+        Assert.Equal("aspirestoragetests2", client2.AccountName);
+        Assert.Equal("aspirestoragetests3", client3.AccountName);
+    }
 }

tests/Aspire.Azure.Storage.Queues.Tests/AspireQueueStorageExtensionsTests.cs

@@ -124,4 +124,34 @@ public void ServiceUriWorksInConnectionStrings(bool useKeyed)
 
         Assert.Equal("aspirestoragetests", client.AccountName);
     }
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:queue1", ConformanceTests.ServiceUri),
+            new KeyValuePair<string, string?>("ConnectionStrings:queue2", "https://aspirestoragetests2.queue.core.windows.net"),
+            new KeyValuePair<string, string?>("ConnectionStrings:queue3", "https://aspirestoragetests3.queue.core.windows.net")
+        ]);
+
+        builder.AddAzureQueueClient("queue1");
+        builder.AddKeyedAzureQueueClient("queue2");
+        builder.AddKeyedAzureQueueClient("queue3");
+
+        using var host = builder.Build();
+
+        // Unkeyed services don't work with keyed services. See https://github.com/dotnet/aspire/issues/3890
+        //var client1 = host.Services.GetRequiredService<QueueServiceClient>();
+        var client2 = host.Services.GetRequiredKeyedService<QueueServiceClient>("queue2");
+        var client3 = host.Services.GetRequiredKeyedService<QueueServiceClient>("queue3");
+
+        //Assert.NotSame(client1, client2);
+        //Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+
+        //Assert.Equal("aspirestoragetests", client1.AccountName);
+        Assert.Equal("aspirestoragetests2", client2.AccountName);
+        Assert.Equal("aspirestoragetests3", client3.AccountName);
+    }
 }

tests/Aspire.Confluent.Kafka.Tests/ConsumerConformanceTests.cs

@@ -6,6 +6,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Xunit;
 
 namespace Aspire.Confluent.Kafka.Tests;
 public class ConsumerConformanceTests : ConformanceTests<IConsumer<string, string>, KafkaConsumerSettings>
@@ -81,4 +82,34 @@ protected override (string json, string error)[] InvalidJsonToErrorMessage => ne
             ("""{"Aspire": { "Confluent":{ "Kafka": { "Consumer": { "DisableMetrics": 0}}}}}""", "Value is \"integer\" but should be \"boolean\""),
             ("""{"Aspire": { "Confluent":{ "Kafka": { "Consumer": { "DisableHealthChecks": 0}}}}}""", "Value is \"integer\" but should be \"boolean\"")
         };
+
+    [Fact]
+    public void CanAddMultipleKeyedServices()
+    {
+        var builder = Host.CreateEmptyApplicationBuilder(null);
+        builder.Configuration.AddInMemoryCollection([
+            new KeyValuePair<string, string?>("ConnectionStrings:messaging1", "localhost:9091"),
+            new KeyValuePair<string, string?>("Aspire:Confluent:Kafka:Consumer:Config:GroupId", "messaging1"),
+
+            new KeyValuePair<string, string?>("ConnectionStrings:messaging2", "localhost:9092"),
+            new KeyValuePair<string, string?>("Aspire:Confluent:Kafka:Consumer:messaging2:Config:GroupId", "messaging2"),
+
+            new KeyValuePair<string, string?>("ConnectionStrings:messaging3", "localhost:9093"),
+            new KeyValuePair<string, string?>("Aspire:Confluent:Kafka:Consumer:messaging3:Config:GroupId", "messaging3"),
+        ]);
+
+        builder.AddKafkaConsumer<string, string>("messaging1");
+        builder.AddKeyedKafkaConsumer<string, string>("messaging2");
+        builder.AddKeyedKafkaConsumer<string, string>("messaging3");
+
+        using var host = builder.Build();
+
+        var client1 = host.Services.GetRequiredService<IConsumer<string, string>>();
+        var client2 = host.Services.GetRequiredKeyedService<IConsumer<string, string>>("messaging2");
+        var client3 = host.Services.GetRequiredKeyedService<IConsumer<string, string>>("messaging3");
+
+        Assert.NotSame(client1, client2);
+        Assert.NotSame(client1, client3);
+        Assert.NotSame(client2, client3);
+    }
 }