Name

ApplicationModel\Resource.cs (1)

32Name = name;

ApplicationModel\ParameterResource.cs (1)

64public string ValueExpression => $"{{{Name}.value}}";

ApplicationModel\Resource.cs (1)

37return $@"Type = {GetType().Name}, Name = ""{Name}"", Annotations = {Annotations.Count}";

ApplicationModel\ResourceWithConnectionStringSurrogate.cs (1)

17string IManifestExpressionProvider.ValueExpression => $"{{{Name}.connectionString}}";

ParameterResourceBuilderExtensions.cs (1)

164var name = resource.Name;

Publishing\ManifestPublishingContext.cs (1)

220Writer.WriteString("value", $"{{{parameter.Name}.inputs.value}}");

AzureProvisioningResourceExtensions.cs (1)

98parameterName ??= Infrastructure.NormalizeBicepIdentifier(parameterResource.Name);

AzureAppConfigurationExtensions.cs (1)

39Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureContainerAppsInfrastructure.cs (2)

717if (!KeyVaultRefs.TryGetValue(secretOutputReference.Resource.Name, out var kv)) 724KeyVaultRefs[secretOutputReference.Resource.Name] = kv;

AzureOpenAIExtensions.cs (2)

38CustomSubDomainName = ToLower(Take(Concat(infrastructure.AspireResource.Name, GetUniqueString(GetResourceGroup().Id)), 24)), 43Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureCosmosDBExtensions.cs (1)

344Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureEventHubConsumerGroupResource.cs (2)

53var consumerGroup = new global::Azure.Provisioning.EventHubs.EventHubsConsumerGroup(Infrastructure.NormalizeBicepIdentifier(Name)); 66writer.WriteString(nameof(Name), ConsumerGroupName);

AzureEventHubResource.cs (2)

64var hub = new global::Azure.Provisioning.EventHubs.EventHub(Infrastructure.NormalizeBicepIdentifier(Name)); 84writer.WriteString(nameof(Name), hub.HubName);

AzureEventHubsExtensions.cs (1)

56Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureFunctionsProjectResourceExtensions.cs (1)

44.FirstOrDefault(r => r.Name == storageResourceName);

src\Shared\LaunchProfiles\LaunchProfileExtensions.cs (1)

28return projectMetadata.GetLaunchSettings(projectResource.Name);

AzureKeyVaultResourceExtensions.cs (1)

48Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzurePostgresExtensions.cs (2)

338Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } } 480builder.ApplicationBuilder, $"{builder.Resource.Name}-username", secret: false, generatedUserName);

AzureRedisExtensions.cs (1)

221Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureServiceBusExtensions.cs (1)

56Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureServiceBusQueueResource.cs (2)

107var queue = new global::Azure.Provisioning.ServiceBus.ServiceBusQueue(Infrastructure.NormalizeBicepIdentifier(Name)); 158writer.WriteString(nameof(Name), queue.QueueName);

AzureServiceBusRule.cs (1)

119writer.WriteString(nameof(AzureServiceBusQueueResource.Name), rule.Name);

AzureServiceBusSubscriptionResource.cs (2)

101var subscription = new global::Azure.Provisioning.ServiceBus.ServiceBusSubscription(Infrastructure.NormalizeBicepIdentifier(Name)); 149writer.WriteString(nameof(Name), subscription.SubscriptionName);

AzureServiceBusTopicResource.cs (3)

77var topic = new global::Azure.Provisioning.ServiceBus.ServiceBusTopic(Infrastructure.NormalizeBicepIdentifier(Name)); 107if (topic.Name != null) 109writer.WriteString(nameof(Name), topic.TopicName);

AzureSignalRExtensions.cs (1)

64Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureSqlExtensions.cs (2)

164var sqlContainer = builder.ApplicationBuilder.AddSqlServer(azureResource.Name); 233Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureSqlServerResource.cs (1)

31: base(innerResource.Name, configureInfrastructure)

AzureStorageExtensions.cs (1)

59Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

AzureBicepResourceTests.cs (16)

AzureCosmosDBEmulatorFunctionalTests.cs (4)

95await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 98hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await cosmos.Resource.ConnectionStringExpression.GetValueAsync(default); 99hb.AddAzureCosmosClient(db.Resource.Name); 100hb.AddCosmosDbContext<EFCoreCosmosDbContext>(db.Resource.Name, databaseName);

AzureEventHubsExtensionsTests.cs (4)

51await rns.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 53await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 57await rns.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 59await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

AzureFunctionsTests.cs (7)

107Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, storageResources.Name); 108Assert.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, storageResources.Name); 126r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)); 128Assert.Equal("my-own-storage", storageResource.Name); 147r => r.Name.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName)); 160Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, resource.Name); 161Assert.StartsWith(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, resource.Name);

AzurePostgresExtensionsTests.cs (2)

154"administratorLogin": "{{{userName?.Resource.Name ?? "postgres-data-username"}}.value}", 155"administratorLoginPassword": "{{{password?.Resource.Name ?? "postgres-data-password"}}.value}",

AzureServiceBusExtensionsTests.cs (6)

203await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 205await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 209await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 211await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 242await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 243await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token);

AzureSignalREmulatorFunctionalTest.cs (4)

62await app.ResourceNotifications.WaitForResourceAsync(signalR.Resource.Name, KnownResourceStates.Running, cts.Token); 63await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 67await app.ResourceNotifications.WaitForResourceHealthyAsync(signalR.Resource.Name, cts.Token); 69await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

AzureStorageEmulatorFunctionalTests.cs (6)

50await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 52await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 56await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token); 57await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token); 58await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token); 60await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

AzureWebPubSubExtensionsTests.cs (6)

37Assert.Equal(hubName, hub.Resource.Name); 69Assert.Equal("wps1", wps.Resource.Name); 144Assert.Equal("wps1", wps.Resource.Name); 219Assert.Equal("wps1", wps.Resource.Name); 295Assert.Equal("wps1", wps.Resource.Name); 402Assert.Equal("wps1", wps.Resource.Name);

ExistingAzureResourceExtensionsTests.cs (10)

39Assert.Equal("name", existingNameParameter.Name); 41Assert.Equal("resourceGroup", existingResourceGroupParameter.Name); 60Assert.Equal("name1", existingNameParameter.Name); 62Assert.Equal("resourceGroup1", existingResourceGroupParameter.Name); 78Assert.Equal("name", existingNameParameter.Name); 80Assert.Equal("resourceGroup", existingResourceGroupParameter.Name); 99Assert.Equal("name1", existingNameParameter.Name); 101Assert.Equal("resourceGroup1", existingResourceGroupParameter.Name); 137Assert.Equal("name", existingNameParameter.Name); 139Assert.Equal("resourceGroup", existingResourceGroupParameter.Name);

AzureWebPubSubExtensions.cs (1)

61Tags = { { "aspire-resource-name", infrastructure.AspireResource.Name } }

DaprDistributedApplicationLifecycleHook.cs (11)

385string componentDirectory = Path.Combine(_onDemandResourcesRootPath, component.Name); 389string componentPath = Path.Combine(componentDirectory, $"{component.Name}.yaml"); 403onDemandResourcesPaths.Add(component.Name, componentPath); 418_logger.LogInformation("Using default Dapr pub-sub for component '{ComponentName}'.", component.Name); 421string newContent = defaultContent.Replace("name: pubsub", $"name: {component.Name}"); 427_logger.LogInformation("Using in-memory Dapr pub-sub for component '{ComponentName}'.", component.Name); 441_logger.LogInformation("Using default Dapr state store for component '{ComponentName}'.", component.Name); 444string newContent = defaultContent.Replace("name: statestore", $"name: {component.Name}"); 450_logger.LogInformation("Using in-memory Dapr state store for component '{ComponentName}'.", component.Name); 465name: {component.Name} 480name: {component.Name}

ElasticsearchBuilderExtensions.cs (1)

65throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{elasticsearch.Name}' resource but the connection string was null.");

AddElasticsearchTests.cs (2)

27Assert.Equal("elasticsearch", containerResource.Name); 88Assert.Equal("elasticsearch", containerResource.Name);

ElasticsearchFunctionalTests.cs (13)

46await rns.WaitForResourceHealthyAsync(elasticsearch.Resource.Name, cts.Token); 50hb.Configuration[$"ConnectionStrings:{elasticsearch.Resource.Name}"] = await elasticsearch.Resource.ConnectionStringExpression.GetValueAsync(default); 52hb.AddElasticsearchClient(elasticsearch.Resource.Name); 110await app.ResourceNotifications.WaitForResourceHealthyAsync(elasticsearch1.Resource.Name, cts.Token); 116hb.Configuration[$"ConnectionStrings:{elasticsearch1.Resource.Name}"] = await elasticsearch1.Resource.ConnectionStringExpression.GetValueAsync(default); 118hb.AddElasticsearchClient(elasticsearch1.Resource.Name); 167await app.ResourceNotifications.WaitForResourceHealthyAsync(elasticsearch2.Resource.Name, cts.Token); 173hb.Configuration[$"ConnectionStrings:{elasticsearch2.Resource.Name}"] = await elasticsearch2.Resource.ConnectionStringExpression.GetValueAsync(default); 175hb.AddElasticsearchClient(elasticsearch2.Resource.Name); 257await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 259await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 263await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 265await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

AddGarnetTests.cs (2)

25Assert.Equal("myGarnet", containerResource.Name); 53Assert.Equal("myGarnet", containerResource.Name);

GarnetFunctionalTests.cs (8)

42await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 44await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 48await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 50await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 76hb.Configuration[$"ConnectionStrings:{garnet.Resource.Name}"] = await garnet.Resource.ConnectionStringExpression.GetValueAsync(default); 78hb.AddRedisClient(garnet.Resource.Name); 155hb.Configuration[$"ConnectionStrings:{garnet1.Resource.Name}"] = $"{await garnet1.Resource.ConnectionStringExpression.GetValueAsync(default)}"; 206hb.Configuration[$"ConnectionStrings:{garnet2.Resource.Name}"] = $"{await garnet2.Resource.ConnectionStringExpression.GetValueAsync(default)}";

AddKafkaTests.cs (1)

26Assert.Equal("kafka", containerResource.Name);

KafkaFunctionalTests.cs (7)

43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 74hb.Configuration[$"ConnectionStrings:{kafka.Resource.Name}"] = await kafka.Resource.ConnectionStringExpression.GetValueAsync(default); 167hb.Configuration[$"ConnectionStrings:{kafka1.Resource.Name}"] = await kafka1.Resource.ConnectionStringExpression.GetValueAsync(default); 219hb.Configuration[$"ConnectionStrings:{kafka2.Resource.Name}"] = await kafka2.Resource.ConnectionStringExpression.GetValueAsync(default);

KeycloakResourceBuilderTests.cs (1)

27Assert.Equal(resourceName, containerResource.Name);

MilvusBuilderExtensions.cs (2)

134containerName ??= $"{builder.Resource.Name}-attu"; 193context.EnvironmentVariables.Add("MILVUS_URL", $"{resource.PrimaryEndpoint.Scheme}://{resource.Name}:{resource.PrimaryEndpoint.TargetPort}");

AddMilvusTests.cs (1)

188Assert.Equal("my-milvus", milvusResource.Name);

MilvusFunctionalTests.cs (9)

32await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus.Resource.Name); 36hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 38hb.AddMilvusClient(db.Resource.Name); 104await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus1.Resource.Name); 110hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 112hb.AddMilvusClient(db1.Resource.Name); 151await app.WaitForTextAsync("Milvus Proxy successfully initialized and ready to serve", milvus2.Resource.Name); 157hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 159hb.AddMilvusClient(db2.Resource.Name);

MongoDBBuilderExtensions.cs (1)

119throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{mongoDBDatabase.Name}' resource but the connection string was null.");

AddMongoDBTests.cs (2)

27Assert.Equal("mongodb", containerResource.Name); 55Assert.Equal("mongodb", containerResource.Name);

MongoDbFunctionalTests.cs (12)

54await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 56await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 60await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 62await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 87hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 89hb.AddMongoDBClient(db.Resource.Name); 148hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 150hb.AddMongoDBClient(db1.Resource.Name); 194hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 196hb.AddMongoDBClient(db2.Resource.Name); 315hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 317hb.AddMongoDBClient(db.Resource.Name);

MySqlBuilderExtensions.cs (3)

46throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{resource.Name}' resource but the connection string was null."); 103containerName ??= $"{builder.Resource.Name}-phpmyadmin"; 159writer.WriteLine($"$cfg['Servers'][$i]['verbose'] = '{mySqlInstance.Name}';");

AddMySqlTests.cs (5)

47Assert.Equal("mysql", containerResource.Name); 229Assert.Single(builder.Resources.OfType<ContainerResource>().Where(resource => resource.Name is "mySql-phpmyadmin")); 248Assert.Equal($"{mysql.Resource.Name}:{mysql.Resource.PrimaryEndpoint.TargetPort}", config["PMA_HOST"]); 289string pattern1 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql1.Resource.Name}:{mysql1.Resource.PrimaryEndpoint.TargetPort}';"; 290string pattern2 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql2.Resource.Name}:{mysql2.Resource.PrimaryEndpoint.TargetPort}';";

MySqlFunctionalTests.cs (14)

50await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 52await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 56await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 58await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 91[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default) 94hb.AddMySqlDataSource(db.Resource.Name); 164[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default) 167hb.AddMySqlDataSource(db1.Resource.Name); 233[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default) 236hb.AddMySqlDataSource(db2.Resource.Name); 339[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default) 342hb.AddMySqlDataSource(db.Resource.Name); 409[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default) 412hb.AddMySqlDbContext<TestDbContext>(db.Resource.Name);

AddNatsTests.cs (2)

97Assert.Equal("nats", containerResource.Name); 139Assert.Equal("nats", containerResource.Name);

NatsFunctionalTests.cs (14)

37await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 41hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = await nats.Resource.ConnectionStringExpression.GetValueAsync(default); 82await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 87hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = connectionString; 124await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name); 133hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = modifiedConnectionString; 185await app.WaitForTextAsync("Listening for client connections", nats1.Resource.Name); 190hb.Configuration[$"ConnectionStrings:{nats1.Resource.Name}"] = await nats1.Resource.ConnectionStringExpression.GetValueAsync(default); 233await app.WaitForTextAsync("Listening for client connections", nats2.Resource.Name); 238hb.Configuration[$"ConnectionStrings:{nats2.Resource.Name}"] = await nats2.Resource.ConnectionStringExpression.GetValueAsync(default); 343await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 345await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 349await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 351await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

OracleDatabaseBuilderExtensions.cs (1)

42throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{oracleDatabaseServer.Name}' resource but the connection string was null.");

OracleFunctionalTests.cs (12)

52hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 54hb.AddOracleDatabaseDbContext<TestDbContext>(db.Resource.Name); 135hb.Configuration[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default); 137hb.AddOracleDatabaseDbContext<TestDbContext>(db1.Resource.Name); 195hb.Configuration[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default); 197hb.AddOracleDatabaseDbContext<TestDbContext>(db2.Resource.Name); 309hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default); 311hb.AddOracleDatabaseDbContext<TestDbContext>(db.Resource.Name); 372await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 374await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 378await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 380await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

PostgresBuilderExtensions.cs (4)

60throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{postgresServer.Name}' resource but the connection string was null."); 145containerName ??= $"{builder.Resource.Name}-pgadmin"; 184writer.WriteString("Name", postgresInstance.Name); 279containerName ??= $"{builder.Resource.Name}-pgweb";

AddPostgresTests.cs (3)

474Assert.Equal(pg1.Resource.Name, servers.GetProperty("1").GetProperty("Name").GetString()); 484Assert.Equal(pg2.Resource.Name, servers.GetProperty("2").GetProperty("Name").GetString()); 612host = "{postgresDatabase.Parent.Name}"

PostgresFunctionalTests.cs (18)

54await app.ResourceNotifications.WaitForResourceAsync(postgres.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 57await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 63await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 66await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 88await app.WaitForTextAsync("Listening at", resourceName: adminBuilder.Resource.Name); 90var client = app.CreateHttpClient(adminBuilder.Resource.Name, "http"); 121[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default) 124hb.AddNpgsqlDataSource(db.Resource.Name); 165var client = app.CreateHttpClient(pgWebBuilder.Resource.Name, "http"); 167await app.ResourceNotifications.WaitForResourceHealthyAsync(pgWebBuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 232await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 240[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default) 243hb.AddNpgsqlDataSource(db1.Resource.Name); 294await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 302[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default) 305hb.AddNpgsqlDataSource(db2.Resource.Name); 394[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default) 397hb.AddNpgsqlDataSource(db.Resource.Name);

AddPythonAppTests.cs (2)

148Assert.Equal("pythonProject", pythonProjectResource.Name); 223Assert.Equal("pythonProject", pythonProjectResource.Name);

QdrantBuilderExtensions.cs (3)

55?? throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{qdrant.Name}' resource but the connection string was null."); 137context.EnvironmentVariables[$"ConnectionStrings__{qdrantResource.Resource.Name}"] = qdrantResource.Resource.ConnectionStringExpression; 140context.EnvironmentVariables[$"ConnectionStrings__{qdrantResource.Resource.Name}_{QdrantServerResource.HttpEndpointName}"] = qdrantResource.Resource.HttpConnectionStringExpression;

AddQdrantTests.cs (1)

287Assert.Equal("my-qdrant", qdrantResource.Name);

QdrantFunctionalTests.cs (10)

46[$"ConnectionStrings:{qdrant.Resource.Name}"] = await qdrant.Resource.ConnectionStringExpression.GetValueAsync(default) 49hb.AddQdrantClient(qdrant.Resource.Name); 130[$"ConnectionStrings:{qdrant1.Resource.Name}"] = await qdrant1.Resource.ConnectionStringExpression.GetValueAsync(default) 133hb.AddQdrantClient(qdrant1.Resource.Name); 175[$"ConnectionStrings:{qdrant2.Resource.Name}"] = await qdrant2.Resource.ConnectionStringExpression.GetValueAsync(default) 178hb.AddQdrantClient(qdrant2.Resource.Name); 245await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 247await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 251await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, (re => re.Snapshot.HealthStatus == HealthStatus.Healthy), cts.Token); 253await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

RabbitMQBuilderExtensions.cs (3)

51throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{rabbitMq.Name}' resource but the connection string was null."); 204throw new DistributedApplicationException($"Cannot configure the RabbitMQ resource '{builder.Resource.Name}' to enable the management plugin as it uses an unrecognized container image registry, name, or tag."); 258var nodeName = $"{builder.Resource.Name}@localhost";

AddRabbitMQTests.cs (1)

54Assert.Equal("rabbit", containerResource.Name);

RabbitMQFunctionalTests.cs (10)

44await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 46await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 50await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 52await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 72hb.Configuration[$"ConnectionStrings:{rabbitMQ.Resource.Name}"] = await rabbitMQ.Resource.ConnectionStringExpression.GetValueAsync(default); 73hb.AddRabbitMQClient(rabbitMQ.Resource.Name); 132hb.Configuration[$"ConnectionStrings:{rabbitMQ1.Resource.Name}"] = await rabbitMQ1.Resource.ConnectionStringExpression.GetValueAsync(default); 134hb.AddRabbitMQClient(rabbitMQ1.Resource.Name); 189hb.Configuration[$"ConnectionStrings:{rabbitMQ2.Resource.Name}"] = await rabbitMQ2.Resource.ConnectionStringExpression.GetValueAsync(default); 191hb.AddRabbitMQClient(rabbitMQ2.Resource.Name);

AddRedisTests.cs (4)

34Assert.Equal("myRedis", containerResource.Name); 62Assert.Equal("myRedis", containerResource.Name); 225Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0", config["REDIS_HOSTS"]); 249Assert.Equal($"myredis1:{redis1.Resource.Name}:6379:0,myredis2:myredis2:6379:0", config["REDIS_HOSTS"]);

RedisFunctionalTests.cs (33)

49await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 55await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 57await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 78await app.WaitForTextAsync("Redis Connection", resourceName: commanderBuilder.Resource.Name); 80var client = app.CreateHttpClient(commanderBuilder.Resource.Name, "http"); 83var path = $"/apiv2/server/R:{redis.Resource.Name}:{endpoint.TargetPort}:0/info"; 104[$"ConnectionStrings:{redis.Resource.Name}"] = await redis.Resource.GetConnectionStringAsync() 107hb.AddRedisClient(redis.Resource.Name); 169using var client1 = app1.CreateHttpClient($"{redis1.Resource.Name}-insight", "http"); 174Assert.Equal($"{redis1.Resource.Name}", firstRunDatabases[0].Name); 206using var client2 = app2.CreateHttpClient($"{redisInsightBuilder.Resource.Name}", "http"); 211Assert.Equal($"{redis2.Resource.Name}", secondRunDatabases[0].Name); 222var latestEvent = await app2.ResourceNotifications.WaitForResourceHealthyAsync(redisInsightBuilder.Resource.Name, cts.Token); 258var client = app.CreateHttpClient(redisInsightBuilder.Resource.Name, "http"); 269Assert.Equal(redis1.Resource.Name, db.Name); 270Assert.Equal(redis1.Resource.Name, db.Host); 277Assert.Equal(redis2.Resource.Name, db.Name); 278Assert.Equal(redis2.Resource.Name, db.Host); 316[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 319hb.AddRedisClient(redis1.Resource.Name); 352[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 355hb.AddRedisClient(redis2.Resource.Name); 402[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 405hb.AddRedisClient(redis1.Resource.Name); 437[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 440hb.AddRedisClient(redis2.Resource.Name); 486[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true" 489hb.AddRedisClient(redis1.Resource.Name); 516[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync() 519hb.AddRedisClient(redis2.Resource.Name); 590var httpClient = app.CreateHttpClient(redisInsightBuilder1.Resource.Name, "http"); 633var httpClient = app.CreateHttpClient(redisInsightBuilder2.Resource.Name, "http");

SqlServerBuilderExtensions.cs (1)

44throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{sqlServer.Name}' resource but the connection string was null.");

AddSqlServerTests.cs (1)

47Assert.Equal("sqlserver", containerResource.Name);

SqlServerFunctionalTests.cs (13)

44await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 50await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 52await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 79hb.Configuration[$"ConnectionStrings:{tempDb.Resource.Name}"] = await tempDb.Resource.ConnectionStringExpression.GetValueAsync(default); 81hb.AddSqlServerDbContext<TestDbContext>(tempDb.Resource.Name); 82hb.AddSqlServerClient(tempDb.Resource.Name); 177await app1.ResourceNotifications.WaitForResourceHealthyAsync(masterdb1.Resource.Name, cts.Token); 185[$"ConnectionStrings:{masterdb1.Resource.Name}"] = await masterdb1.Resource.ConnectionStringExpression.GetValueAsync(default), 188hb1.AddSqlServerClient(masterdb1.Resource.Name); 260await app2.ResourceNotifications.WaitForResourceHealthyAsync(masterdb2.Resource.Name, cts.Token); 268[$"ConnectionStrings:{masterdb2.Resource.Name}"] = await masterdb2.Resource.ConnectionStringExpression.GetValueAsync(default), 271hb2.AddSqlServerClient(masterdb2.Resource.Name);

TestingBuilderTests.cs (1)

150Assert.Contains(appModel.GetProjectResources(), p => p.Name == "myworker1");

TestingFactoryTests.cs (1)

48Assert.Contains(appModel.GetProjectResources(), p => p.Name == "myworker1");

AddParameterTests.cs (9)

Dashboard\DashboardResourceTests.cs (4)

52Assert.Equal("aspire-dashboard", dashboard.Name); 178Assert.Equal("aspire-dashboard", dashboard.Name); 465Assert.Equal("aspire-dashboard", dashboard.Name); 520Assert.Equal("aspire-dashboard", dashboard.Name);

DistributedApplicationTests.cs (7)

286using var clientA = app.CreateHttpClient(testProgram.ServiceABuilder.Resource.Name, "http"); 287using var clientC = app.CreateHttpClient(testProgram.ServiceCBuilder.Resource.Name, "http"); 294var uri = app.GetEndpoint(testProgram.ServiceBBuilder.Resource.Name, "http"); 862var httpEndPoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "http"); 880var httpsEndpoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "https"); 928using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http"); 978using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");

HealthCheckTests.cs (4)

88await rns.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 90await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 94await rns.WaitForResourceHealthyAsync(resource.Resource.Name).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout); 96await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.DefaultOrchestratorTestLongTimeout);

Orchestrator\ApplicationOrchestratorTests.cs (6)

58await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parentResource.Resource, parentResource.Resource.Name)); 117await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parent.Resource, parent.Resource.Name)); 177await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, firstParent.Resource, firstParent.Resource.Name)); 178await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, secondParent.Resource, secondParent.Resource.Name)); 225await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, projectA.Resource, projectA.Resource.Name)); 226await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, projectB.Resource, projectB.Resource.Name));

ProjectResourceTests.cs (2)

73Assert.Equal("projectName", resource.Name); 187Assert.Equal("projectName", resource.Name);

PublishAsDockerfileTests.cs (5)

27Assert.Equal("frontend", containerResource.Name); 73Assert.Equal("frontend", containerResource.Name); 122Assert.Equal("frontend", containerResource.Name); 171Assert.Equal("frontend", containerResource.Name); 230Assert.Equal("project", containerResource.Name);

SlimTestProgramTests.cs (3)

34using var clientA = app.CreateHttpClientWithResilience(testProgram.ServiceABuilder.Resource.Name, "http"); 37using var clientB = app.CreateHttpClientWithResilience(testProgram.ServiceBBuilder.Resource.Name, "http"); 40using var clientC = app.CreateHttpClientWithResilience(testProgram.ServiceCBuilder.Resource.Name, "http");

TestProgramFixture.cs (3)

69using var clientA = App.CreateHttpClientWithResilience(TestProgram.ServiceABuilder.Resource.Name, "http"); 73using var clientB = App.CreateHttpClientWithResilience(TestProgram.ServiceBBuilder.Resource.Name, "http"); 77using var clientC = App.CreateHttpClientWithResilience(TestProgram.ServiceCBuilder.Resource.Name, "http");

WaitForTests.cs (3)

33await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 35await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);

WithEndpointTests.cs (1)

217Assert.Equal("foo", resource.Name);

AddValkeyTests.cs (2)

25Assert.Equal("myValkey", containerResource.Name); 53Assert.Equal("myValkey", containerResource.Name);

ValkeyFunctionalTests.cs (10)

36[$"ConnectionStrings:{valkey.Resource.Name}"] = await valkey.Resource.ConnectionStringExpression.GetValueAsync(default) 39hb.AddRedisClient(valkey.Resource.Name); 97[$"ConnectionStrings:{valkey1.Resource.Name}"] = $"{await valkey1.Resource.ConnectionStringExpression.GetValueAsync(default)},allowAdmin=true" 100hb.AddRedisClient(valkey1.Resource.Name); 148[$"ConnectionStrings:{valkey2.Resource.Name}"] = await valkey2.Resource.ConnectionStringExpression.GetValueAsync(default) 151hb.AddRedisClient(valkey2.Resource.Name); 219await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 221await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 225await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 227await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);

Infrastructure\DistributedApplicationExtensions.cs (3)

31builder.Configuration[$"Parameters:{parameter.Name}"] = parameter.Secret 216using (var checkHttpClient = app.CreateHttpClient(project.Name)) 244using var applyMigrationsHttpClient = app.CreateHttpClient(project.Name, useHttpClientFactory: false);

Program.cs (2)

11.WithArgs(kafka.Resource.Name); 15.WithArgs(kafka.Resource.Name);

TestProgram.cs (1)

163root[project.Name] = projectJson;