1 implementation of Resource
Aspire.Hosting (1)
1903 references to Resource
Aspire.Hosting (129)
ApplicationModel\ResourceExtensions.cs (4)
304(DistributedApplicationOperation.Run, IResourceBuilder<IResource> rb) when rb.Resource is IValueProvider provider => await GetValue(key: null, provider, logger, resource.IsContainer(), containerHostName, cancellationToken).ConfigureAwait(false),
306(DistributedApplicationOperation.Publish, IResourceBuilder<IResource> rb) when rb.Resource is IManifestExpressionProvider provider => new(provider.ValueExpression, false),
363(DistributedApplicationOperation.Run, IResourceBuilder<IResource> rb) when rb.Resource is IValueProvider provider => await GetValue(key, provider, logger, resource.IsContainer(), containerHostName, cancellationToken).ConfigureAwait(false),
365(DistributedApplicationOperation.Publish, IResourceBuilder<IResource> rb) when rb.Resource is IManifestExpressionProvider provider => new(provider.ValueExpression, false),
ResourceBuilderExtensions.cs (74)
172builder.WithReferenceRelationship(externalService.Resource);
174if (externalService.Resource.Uri is not null)
176builder.WithEnvironment(name, externalService.Resource.Uri.ToString());
178else if (externalService.Resource.UrlParameter is not null)
183if (!context.ExecutionContext.IsPublishMode && !ExternalServiceResource.UrlIsValidForExternalService(externalService.Resource.UrlParameter.Value, out var _, out var message))
185throw new DistributedApplicationException($"The URL parameter '{externalService.Resource.UrlParameter.Name}' for the external service '{externalService.Resource.Name}' is invalid: {message}");
187context.EnvironmentVariables[name] = externalService.Resource.UrlParameter;
208builder.WithReferenceRelationship(parameter.Resource);
212context.EnvironmentVariables[name] = parameter.Resource;
234builder.WithReferenceRelationship(resource.Resource);
238context.EnvironmentVariables[envVarName] = new ConnectionStringReference(resource.Resource, optional: false);
448var resource = source.Resource;
475ApplyEndpoints(builder, source.Resource);
522builder.WithReferenceRelationship(externalService.Resource);
524if (externalService.Resource.Uri is { } uri)
526var envVarName = $"services__{externalService.Resource.Name}__{uri.Scheme}__0";
529else if (externalService.Resource.UrlParameter is not null)
537envVarName = $"services__{externalService.Resource.Name}__default__0";
539else if (ExternalServiceResource.UrlIsValidForExternalService(externalService.Resource.UrlParameter.Value, out var uri, out var message))
541envVarName = $"services__{externalService.Resource.Name}__{uri.Scheme}__0";
545throw new DistributedApplicationException($"The URL parameter '{externalService.Resource.UrlParameter.Name}' for the external service '{externalService.Resource.Name}' is invalid: {message}");
547context.EnvironmentVariables[envVarName] = externalService.Resource.UrlParameter;
579var endpointReferenceAnnotation = builder.Resource.Annotations
643var endpoint = builder.Resource.Annotations
657builder.Resource.Annotations.Add(endpoint);
697if (builder.Resource.Annotations.OfType<EndpointAnnotation>().Any(sb => string.Equals(sb.Name, annotation.Name, StringComparisons.EndpointAnnotationName)))
703if (env is not null && builder.Resource is IResourceWithEndpoints resourceWithEndpoints and IResourceWithEnvironment)
788if (!builder.Resource.TryGetAnnotationsOfType<EndpointAnnotation>(out var endpoints))
816return builder.Resource.GetEndpoint(name);
1033context.Logger.LogWarning("Could not execute callback to customize endpoint URL as no endpoint with name '{EndpointName}' could be found on resource '{ResourceName}'.", endpointName, builder.Resource.Name);
1080context.Logger.LogWarning("Could not execute callback to add an endpoint URL as no endpoint with name '{EndpointName}' could be found on resource '{ResourceName}'.", endpointName, builder.Resource.Name);
1179if (builder.Resource as IResource == dependency.Resource)
1181throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for itself.");
1184if (builder.Resource is IResourceWithParent resourceWithParent && resourceWithParent.Parent == dependency.Resource)
1186throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for its parent '{dependency.Resource.Name}'.");
1189if (dependency.Resource is IResourceWithParent dependencyResourceWithParent)
1201if (dependency.Resource is ConnectionStringResource cs)
1212builder.WithRelationship(dependency.Resource, KnownRelationshipTypes.WaitFor);
1215return builder.WithAnnotation(new WaitAnnotation(dependency.Resource, WaitType.WaitUntilHealthy) { WaitBehavior = waitBehavior });
1275if (builder.Resource as IResource == dependency.Resource)
1277throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for itself.");
1280if (builder.Resource is IResourceWithParent resourceWithParent && resourceWithParent.Parent == dependency.Resource)
1282throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for its parent '{dependency.Resource.Name}'.");
1285builder.WithRelationship(dependency.Resource, KnownRelationshipTypes.WaitFor);
1287return builder.WithAnnotation(new WaitAnnotation(dependency.Resource, WaitType.WaitForCompletion, exitCode));
1331if (builder.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var annotations) && annotations.Any(a => a.Key == key))
1333throw new DistributedApplicationException($"Resource '{builder.Resource.Name}' already has a health check with key '{key}'.");
1415?? throw new DistributedApplicationException($"Could not create HTTP health check for resource '{builder.Resource.Name}' as the endpoint selector returned null.");
1419throw new DistributedApplicationException($"Could not create HTTP health check for resource '{builder.Resource.Name}' as the endpoint with name '{endpoint.EndpointName}' and scheme '{endpoint.Scheme}' is not an HTTP endpoint.");
1431throw new DistributedApplicationException($"The endpoint '{endpointName}' does not exist on the resource '{builder.Resource.Name}'.");
1445var healthCheckKey = $"{builder.Resource.Name}_{endpointName}_{path}_{statusCode}_check";
1535var existingAnnotation = builder.Resource.Annotations.OfType<ResourceCommandAnnotation>().SingleOrDefault(a => a.Name == name);
1538builder.Resource.Annotations.Remove(existingAnnotation);
1600var existingAnnotation = builder.Resource.Annotations.OfType<ResourceCommandAnnotation>().SingleOrDefault(a => a.Name == name);
1603builder.Resource.Annotations.Remove(existingAnnotation);
1767?? throw new DistributedApplicationException($"Could not create HTTP command for resource '{builder.Resource.Name}' as the endpoint selector returned null.");
1771throw new DistributedApplicationException($"Could not create HTTP command for resource '{builder.Resource.Name}' as the endpoint with name '{endpoint.EndpointName}' and scheme '{endpoint.Scheme}' is not an HTTP endpoint.");
1869var endpoints = builder.Resource.GetEndpoints();
1879throw new DistributedApplicationException($"Could not create {errorDisplayNoun} for resource '{builder.Resource.Name}' as the endpoint with name '{matchingEndpoint.EndpointName}' and scheme '{matchingEndpoint.Scheme}' is not an HTTP endpoint.");
1887throw new DistributedApplicationException($"Could not create {errorDisplayNoun} for resource '{builder.Resource.Name}' as no endpoint was found matching one of the specified names: {endpointNamesString}");
1895var endpoints = builder.Resource.GetEndpoints();
1907throw new DistributedApplicationException($"Could not create HTTP command for resource '{builder.Resource.Name}' as it has no HTTP endpoints.");
2004AddReference(resourceBuilder.Resource);
2035return builder.WithAnnotation(new ResourceRelationshipAnnotation(resourceBuilder.Resource, KnownRelationshipTypes.Reference));
2065return builder.WithParentRelationship(parent.Resource);
2114builder.WithAnnotation(new ComputeEnvironmentAnnotation(computeEnvironmentResource.Resource));
Aspire.Hosting.Azure (28)
Aspire.Hosting.Azure.AIFoundry (7)
Aspire.Hosting.Azure.AppConfiguration (1)
Aspire.Hosting.Azure.AppContainers (3)
Aspire.Hosting.Azure.ApplicationInsights (1)
Aspire.Hosting.Azure.CognitiveServices (5)
Aspire.Hosting.Azure.ContainerRegistry (2)
Aspire.Hosting.Azure.CosmosDB (19)
Aspire.Hosting.Azure.EventHubs (14)
Aspire.Hosting.Azure.Functions (9)
Aspire.Hosting.Azure.KeyVault (12)
AzureKeyVaultResourceExtensions.cs (11)
170return builder.Resource.GetSecret(secretName);
185return builder.AddSecret(secretName, secretName, parameterResource.Resource);
202var secret = new AzureKeyVaultSecretResource(secretName, secretName, builder.Resource, parameterResource);
203builder.Resource.Secrets.Add(secret);
222var secret = new AzureKeyVaultSecretResource(secretName, secretName, builder.Resource, value);
223builder.Resource.Secrets.Add(secret);
241return builder.AddSecret(name, secretName, parameterResource.Resource);
259var secret = new AzureKeyVaultSecretResource(name, secretName, builder.Resource, parameterResource);
260builder.Resource.Secrets.Add(secret);
280var secret = new AzureKeyVaultSecretResource(name, secretName, builder.Resource, value);
281builder.Resource.Secrets.Add(secret);
Aspire.Hosting.Azure.PostgreSQL (22)
Aspire.Hosting.Azure.Redis (11)
Aspire.Hosting.Azure.Search (1)
Aspire.Hosting.Azure.ServiceBus (19)
AzureServiceBusExtensions.cs (18)
146var queue = new AzureServiceBusQueueResource(name, queueName, builder.Resource);
147builder.Resource.Queues.Add(queue);
163configure(builder.Resource);
223var topic = new AzureServiceBusTopicResource(name, topicName, builder.Resource);
224builder.Resource.Topics.Add(topic);
240configure(builder.Resource);
260if (builder.Resource.Topics.FirstOrDefault(x => x.Name == topicName) is { } existingResource)
289var subscription = new AzureServiceBusSubscriptionResource(name, subscriptionName, builder.Resource);
290builder.Resource.Subscriptions.Add(subscription);
306configure(builder.Resource);
340if (builder.Resource.IsEmulator)
353var passwordParameter = ParameterResourceBuilderExtensions.CreateDefaultPasswordParameter(builder.ApplicationBuilder, $"{builder.Resource.Name}-sql-pwd", minLower: 1, minUpper: 1, minNumeric: 1);
367.AddContainer($"{builder.Resource.Name}-sqledge",
381var sqlEndpoint = sqlEdgeResource.Resource.GetEndpoint("tcp");
390var surrogate = new AzureServiceBusEmulatorResource(builder.Resource);
411var customConfigFile = builder.Resource.Annotations.OfType<ConfigFileAnnotation>().FirstOrDefault();
424var tempConfig = JsonNode.Parse(CreateEmulatorConfigJson(builder.Resource));
432var configJsonAnnotations = builder.Resource.Annotations.OfType<ConfigJsonAnnotation>();
Aspire.Hosting.Azure.SignalR (2)
Aspire.Hosting.Azure.Sql (11)
Aspire.Hosting.Azure.Storage (12)
Aspire.Hosting.Azure.Tests (558)
AzureApplicationInsightsExtensionsTests.cs (19)
19appInsights.Resource.Outputs["appInsightsConnectionString"] = "myinstrumentationkey";
21var connectionStringResource = (IResourceWithConnectionString)appInsights.Resource;
23Assert.Equal("appInsights", appInsights.Resource.Name);
25Assert.Equal("{appInsights.outputs.appInsightsConnectionString}", appInsights.Resource.ConnectionStringExpression.ValueExpression);
27var (appInsightsManifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
40appInsights.Resource.Outputs["appInsightsConnectionString"] = "myinstrumentationkey";
42var connectionStringResource = (IResourceWithConnectionString)appInsights.Resource;
44Assert.Equal("appInsights", appInsights.Resource.Name);
46Assert.Equal("{appInsights.outputs.appInsightsConnectionString}", appInsights.Resource.ConnectionStringExpression.ValueExpression);
48var appInsightsManifest = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
69appInsights.Resource.Outputs["appInsightsConnectionString"] = "myinstrumentationkey";
71var connectionStringResource = (IResourceWithConnectionString)appInsights.Resource;
73Assert.Equal("appInsights", appInsights.Resource.Name);
75Assert.Equal("{appInsights.outputs.appInsightsConnectionString}", appInsights.Resource.ConnectionStringExpression.ValueExpression);
77var (appInsightsManifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
90appInsights.Resource.Outputs["appInsightsConnectionString"] = "myinstrumentationkey";
95var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(serviceA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
112var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
127var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
AzureCosmosDBEmulatorFunctionalTests.cs (21)
47await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
53await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
93await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
96hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await cosmos.Resource.ConnectionStringExpression.GetValueAsync(default);
97hb.AddAzureCosmosClient(db.Resource.Name);
98hb.AddCosmosDbContext<EFCoreCosmosDbContext>(db.Resource.Name, databaseName);
173await rns.WaitForResourceHealthyAsync(cosmos1.Resource.Name, cts.Token);
181[$"ConnectionStrings:{cosmos1.Resource.Name}"] = await cosmos1.Resource.ConnectionStringExpression.GetValueAsync(default)
184hb.AddAzureCosmosClient(cosmos1.Resource.Name);
221await rns.WaitForResourceHealthyAsync(cosmos2.Resource.Name, cts.Token);
229[$"ConnectionStrings:{cosmos2.Resource.Name}"] = await cosmos2.Resource.ConnectionStringExpression.GetValueAsync(default)
232hb.AddAzureCosmosClient(cosmos2.Resource.Name);
290await rns.WaitForResourceHealthyAsync(cosmos.Resource.Name, cts.Token);
293hb.Configuration[$"ConnectionStrings:{cosmos.Resource.Name}"] = await cosmos.Resource.ConnectionStringExpression.GetValueAsync(default);
294hb.AddAzureCosmosClient(cosmos.Resource.Name);
AzureCosmosDBExtensionsTests.cs (39)
32var endpointAnnotation = cosmos.Resource.Annotations.OfType<EndpointAnnotation>().FirstOrDefault();
53var containerImageAnnotation = cosmos.Resource.Annotations.OfType<ContainerImageAnnotation>().FirstOrDefault();
70var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(cosmos.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
103Assert.Equal("{cosmos.outputs.connectionString}", cosmos.Resource.ConnectionStringExpression.ValueExpression);
106Assert.Equal("AccountEndpoint={cosmos.outputs.connectionString};Database=db1", db1.Resource.ConnectionStringExpression.ValueExpression);
107Assert.Equal("AccountEndpoint={cosmos.outputs.connectionString};Database=db1;Container=container1", container1.Resource.ConnectionStringExpression.ValueExpression);
133Assert.DoesNotContain(";Database=db1", cosmos.Resource.ConnectionStringExpression.ValueExpression);
134Assert.DoesNotContain(";Database=db1;Container=container1", cosmos.Resource.ConnectionStringExpression.ValueExpression);
135Assert.Contains(";Database=db1", db1.Resource.ConnectionStringExpression.ValueExpression);
136Assert.Contains(";Database=db1;Container=container1", container1.Resource.ConnectionStringExpression.ValueExpression);
138Assert.Contains(";Database=db", db2.Resource.ConnectionStringExpression.ValueExpression);
139Assert.Contains(";Database=db;Container=container", container2.Resource.ConnectionStringExpression.ValueExpression);
152((IResourceWithAzureFunctionsConfig)cosmos.Resource).ApplyAzureFunctionsConfiguration(target, "cosmos");
159((IResourceWithAzureFunctionsConfig)db1.Resource).ApplyAzureFunctionsConfiguration(target, "db1");
168((IResourceWithAzureFunctionsConfig)container1.Resource).ApplyAzureFunctionsConfiguration(target, "container1");
203var manifest = await GetManifestWithBicep(model, cosmos.Resource);
254Assert.Equal("{cosmos-kv.secrets.connectionstrings--cosmos}", cosmos.Resource.ConnectionStringExpression.ValueExpression);
255Assert.Equal("{cosmos-kv.secrets.connectionstrings--db1}", database.Resource.ConnectionStringExpression.ValueExpression);
256Assert.Equal("{cosmos-kv.secrets.connectionstrings--container1}", container.Resource.ConnectionStringExpression.ValueExpression);
258var manifest = await GetManifestWithBicep(cosmos.Resource);
273Assert.True(cosmos.Resource.IsContainer());
275var csExpr = cosmos.Resource.ConnectionStringExpression;
281Assert.Equal(cs, await ((IResourceWithConnectionString)cosmos.Resource).GetConnectionStringAsync());
354var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
365var connectionStringResource = (IResourceWithConnectionString)cosmos.Resource;
367Assert.Equal("cosmos", cosmos.Resource.Name);
385cosmos.Resource.Outputs["connectionString"] = "mycosmosconnectionstring";
387var manifest = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
408var connectionStringResource = (IResourceWithConnectionString)cosmos.Resource;
410Assert.Equal("cosmos", cosmos.Resource.Name);
448kv.Resource.SecretResolver = (secretRef, _) =>
458var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
469var connectionStringResource = (IResourceWithConnectionString)cosmos.Resource;
471Assert.Equal("cosmos", cosmos.Resource.Name);
489cosmos.Resource.Outputs["connectionString"] = "mycosmosconnectionstring";
491var manifest = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
510var connectionStringResource = (IResourceWithConnectionString)cosmos.Resource;
512Assert.Equal("cosmos", cosmos.Resource.Name);
523var manifest = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
AzureEventHubsExtensionsTests.cs (29)
46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
47await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
51await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
76await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token);
82hb.Configuration["ConnectionStrings:hub"] = await eventHub.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
88hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
89hb.AddAzureEventHubProducerClient("eventhubns", settings => settings.EventHubName = eventHub.Resource.HubName);
90hb.AddAzureEventHubConsumerClient("eventhubns", settings => settings.EventHubName = eventHub.Resource.HubName);
128await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token);
134hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
135hb.AddAzureEventHubProducerClient("eventhubns", settings => settings.EventHubName = eventHub.Resource.HubName);
136hb.AddAzureEventHubConsumerClient("eventhubns", settings => settings.EventHubName = eventHub.Resource.HubName);
140hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None) + $";EntityPath={hubName};";
166var volumeAnnotation = eventHubs.Resource.Annotations.OfType<ContainerMountAnnotation>().Single(a => !a.Target.Contains("Config.json"));
185var volumeAnnotation = eventHubs.Resource.Annotations.OfType<ContainerMountAnnotation>().Single(a => !a.Target.Contains("Config.json"));
204var volumeAnnotation = eventHubs.Resource.Annotations.OfType<ContainerMountAnnotation>().Single(a => !a.Target.Contains("Config.json"));
223var volumeAnnotation = eventHubs.Resource.Annotations.OfType<ContainerMountAnnotation>().Single(a => !a.Target.Contains("Config.json"));
242var endpoints = eventHubs.Resource.Annotations.OfType<EndpointAnnotation>().ToList();
270var containerImageAnnotation = eventHubs.Resource.Annotations.OfType<ContainerImageAnnotation>().FirstOrDefault();
290var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(model, eventHubs.Resource);
323var manifest = await AzureManifestUtils.GetManifestWithBicep(eventHubs.Resource);
521serviceBus.Resource.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var sbLifetimeAnnotation);
546Assert.Equal("{eh.outputs.eventHubsEndpoint}", eventHubs.Resource.ConnectionStringExpression.ValueExpression);
547Assert.Equal("Endpoint={eh.outputs.eventHubsEndpoint};EntityPath=hub1", eventHub.Resource.ConnectionStringExpression.ValueExpression);
548Assert.Equal("Endpoint={eh.outputs.eventHubsEndpoint};EntityPath=hub1;ConsumerGroup=cg1", consumerGroup.Resource.ConnectionStringExpression.ValueExpression);
561((IResourceWithAzureFunctionsConfig)eventHubs.Resource).ApplyAzureFunctionsConfiguration(target, "eh");
571((IResourceWithAzureFunctionsConfig)eventHub.Resource).ApplyAzureFunctionsConfiguration(target, "hub1");
587((IResourceWithAzureFunctionsConfig)consumerGroup.Resource).ApplyAzureFunctionsConfiguration(target, "cg1");
AzureKeyVaultTests.cs (21)
20var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(mykv.Resource);
36var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(model, mykv.Resource);
56kv.Resource.SecretResolver = (s, ct) =>
62var secretReference = kv.Resource.GetSecret("mySecret");
68var runEnv = await containerBuilder.Resource.GetEnvironmentVariableValuesAsync(DistributedApplicationOperation.Run);
69var publishEnv = await containerBuilder.Resource.GetEnvironmentVariableValuesAsync(DistributedApplicationOperation.Publish);
88var secretReference = kv.Resource.GetSecret("mySecret");
89var secretReference2 = kv.Resource.GetSecret("mySecret2");
110var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(module.Resource, skipPreparer: true);
128Assert.Same(kv.Resource, secret.Resource);
142Assert.IsType<AzureKeyVaultSecretResource>(secretResource.Resource);
143Assert.Equal("mySecret", secretResource.Resource.Name);
144Assert.Equal("mySecret", secretResource.Resource.SecretName);
145Assert.Same(kv.Resource, secretResource.Resource.Parent);
146Assert.Single(kv.Resource.Secrets);
147Assert.Same(secretResource.Resource, kv.Resource.Secrets[0]);
159var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(kv.Resource);
174var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(kv.Resource);
194var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(kv.Resource);
AzurePostgresExtensionsTests.cs (25)
39var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(postgres.Resource, skipPreparer: true);
96var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(postgres.Resource);
131Assert.True(postgres.Resource.IsContainer(), "The resource should now be a container resource.");
132Assert.StartsWith("Host=localhost;Port=12455;Username=postgres;Password=", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
134var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
138var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
180var endpoint = Assert.Single(innerPostgres.Resource.Annotations.OfType<EndpointAnnotation>());
189Assert.True(postgres.Resource.IsContainer(), "The resource should now be a container resource.");
190Assert.Equal("Host=localhost;Port=12455;Username=user1;Password=p@ssw0rd1", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
192var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
195var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
229Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
230Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1;Database=db1", await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
231Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1;Database=db2Name", await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
315Assert.True(postgres.Resource.TryGetLastAnnotation<ConnectionStringRedirectAnnotation>(out var connectionStringAnnotation));
319var manifest = await AzureManifestUtils.GetManifestWithBicep(postgres.Resource);
324Assert.Equal("myconnectionstring", await postgres.Resource.GetConnectionStringAsync(default));
358Assert.True(postgres.Resource.TryGetLastAnnotation<ConnectionStringRedirectAnnotation>(out var connectionStringAnnotation));
362var manifest = await AzureManifestUtils.GetManifestWithBicep(postgres.Resource);
367Assert.Equal("myconnectionstring", await postgres.Resource.GetConnectionStringAsync(default));
402var manifest = await AzureManifestUtils.GetManifestWithBicep(postgres.Resource);
408Assert.Equal(expectedConnectionString, await postgres.Resource.GetConnectionStringAsync());
434var manifest = await ManifestUtils.GetManifest(postgres.Resource);
454manifest = await ManifestUtils.GetManifest(postgres.Resource);
473manifest = await ManifestUtils.GetManifest(postgres.Resource);
AzureRedisExtensionsTests.cs (13)
39var (manifest, bicep) = await GetManifestWithBicep(model, redis.Resource);
82var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(redis.Resource);
98redisResource = c.Resource;
103Assert.True(redis.Resource.IsContainer(), "The resource should now be a container resource.");
106Assert.Equal($"localhost:12455,password={redisResource.PasswordParameter.Value}", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
119redisResource = c.Resource;
137Assert.True(redis.Resource.IsContainer(), "The resource should now be a container resource.");
140Assert.Equal($"localhost:12455,password=p@ssw0rd1", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
195Assert.True(redis.Resource.IsContainer());
196Assert.NotNull(redis.Resource.PasswordParameter);
198Assert.Equal($"localhost:12455,password={redis.Resource.PasswordParameter.Value}", await redis.Resource.GetConnectionStringAsync());
200var manifest = await AzureManifestUtils.GetManifestWithBicep(redis.Resource);
AzureServiceBusExtensionsTests.cs (32)
38var manifest = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
63var manifest = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
95await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
97await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
101await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
103await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
129hb.Configuration["ConnectionStrings:servicebusns"] = await serviceBus.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
136await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token);
137await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token);
141await using var sender = serviceBusClient.CreateSender(queueResource.Resource.QueueName);
144await using var receiver = serviceBusClient.CreateReceiver(queueResource.Resource.QueueName);
164serviceBus.Resource.Annotations.OfType<EndpointAnnotation>(),
187var containerImageAnnotation = serviceBus.Resource.Annotations.OfType<ContainerImageAnnotation>().FirstOrDefault();
265var manifest = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
617serviceBus.Resource.TryGetLastAnnotation<ContainerLifetimeAnnotation>(out var sbLifetimeAnnotation);
644Assert.Equal("{sb.outputs.serviceBusEndpoint}", serviceBus.Resource.ConnectionStringExpression.ValueExpression);
645Assert.Equal("Endpoint={sb.outputs.serviceBusEndpoint};EntityPath=queue", queue.Resource.ConnectionStringExpression.ValueExpression);
646Assert.Equal("Endpoint={sb.outputs.serviceBusEndpoint};EntityPath=topic", topic.Resource.ConnectionStringExpression.ValueExpression);
647Assert.Equal("Endpoint={sb.outputs.serviceBusEndpoint};EntityPath=topic/Subscriptions/sub", subscription.Resource.ConnectionStringExpression.ValueExpression);
661((IResourceWithAzureFunctionsConfig)serviceBus.Resource).ApplyAzureFunctionsConfiguration(target, "sb");
667((IResourceWithAzureFunctionsConfig)queue.Resource).ApplyAzureFunctionsConfiguration(target, "queue");
674((IResourceWithAzureFunctionsConfig)topic.Resource).ApplyAzureFunctionsConfiguration(target, "topic");
681((IResourceWithAzureFunctionsConfig)subscription.Resource).ApplyAzureFunctionsConfiguration(target, "sub");
717serviceBus.Resource.Outputs["serviceBusEndpoint"] = "mynamespaceEndpoint";
719var connectionStringResource = (IResourceWithConnectionString)serviceBus.Resource;
721Assert.Equal("sb", serviceBus.Resource.Name);
727var manifest = await GetManifestWithBicep(model, serviceBus.Resource);
810hb.Configuration["ConnectionStrings:servicebusns"] = await serviceBus.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
813await app.ResourceNotifications.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token);
814await app.ResourceNotifications.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token);
821await using var sender = serviceBusClient.CreateSender(queueResource.Resource.QueueName);
824await using var receiver = serviceBusClient.CreateReceiver(queueResource.Resource.QueueName);
AzureSqlExtensionsTests.cs (20)
46var manifest = await AzureManifestUtils.GetManifestWithBicep(sql.Resource, skipPreparer: true);
92Assert.True(sql.Resource.IsContainer(), "The resource should now be a container resource.");
93var serverConnectionString = await sql.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
97var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
101var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
105var db3ConnectionString = await db3.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
149var endpoint = Assert.Single(innerSql.Resource.Annotations.OfType<EndpointAnnotation>());
158Assert.True(sql.Resource.IsContainer(), "The resource should now be a container resource.");
159var serverConnectionString = await sql.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
162var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
165var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
168var db3ConnectionString = await db3.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
248var manifest = await AzureManifestUtils.GetManifestWithBicep(sql.Resource);
250Assert.True(sql.Resource.TryGetLastAnnotation<ConnectionStringRedirectAnnotation>(out var connectionStringAnnotation));
254Assert.Equal("Server=tcp:myserver,1433;Encrypt=True;Authentication=\"Active Directory Default\"", await sql.Resource.GetConnectionStringAsync(default));
255Assert.Equal("Server=tcp:{sql.outputs.sqlServerFqdn},1433;Encrypt=True;Authentication=\"Active Directory Default\"", sql.Resource.ConnectionStringExpression.ValueExpression);
279var manifest = await AzureManifestUtils.GetManifestWithBicep(sql.Resource);
281Assert.True(sql.Resource.TryGetLastAnnotation<ConnectionStringRedirectAnnotation>(out var connectionStringAnnotation));
285Assert.Equal("Server=tcp:myserver,1433;Encrypt=True;Authentication=\"Active Directory Default\"", await sql.Resource.GetConnectionStringAsync(default));
286Assert.Equal("Server=tcp:{sql.outputs.sqlServerFqdn},1433;Encrypt=True;Authentication=\"Active Directory Default\"", sql.Resource.ConnectionStringExpression.ValueExpression);
AzureStorageEmulatorFunctionalTests.cs (14)
48await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token);
50await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
54await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token);
55await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token);
56await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token);
58await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
94await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token);
96await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
100await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cts.Token);
102await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
124hb.Configuration[$"ConnectionStrings:{blobsResourceName}"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
125hb.Configuration[$"ConnectionStrings:{blobContainerName}"] = await container.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
159await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cancellationToken: cts.Token);
162hb.Configuration["ConnectionStrings:BlobConnection"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
AzureStorageExtensionsTests.cs (72)
35var volumeAnnotation = storage.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
61var volumeAnnotation = storage.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
87var volumeAnnotation = storage.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
113var volumeAnnotation = storage.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
132storage.Resource.Annotations.OfType<EndpointAnnotation>(),
146var args = await ArgumentEvaluator.GetArgumentListAsync(storage.Resource);
166var args = await ArgumentEvaluator.GetArgumentListAsync(storage.Resource);
185Assert.True(storage.Resource.IsContainer());
189Assert.Equal(expected, await ((IResourceWithConnectionString)blobs.Resource).ConnectionStringExpression.GetValueAsync(default));
201storage.Resource.Outputs["blobEndpoint"] = blobsConnectionString;
205Assert.Equal(blobsConnectionString, await ((IResourceWithConnectionString)blobs.Resource).ConnectionStringExpression.GetValueAsync(default));
216Assert.Equal("{storage.outputs.blobEndpoint}", blobs.Resource.ConnectionStringExpression.ValueExpression);
233Assert.True(storage.Resource.IsContainer());
238string? blobConnectionString = await ((IResourceWithConnectionString)blobs.Resource).ConnectionStringExpression.GetValueAsync(default);
239string? blobContainerConnectionString = await ((IResourceWithConnectionString)blobContainer.Resource).ConnectionStringExpression.GetValueAsync(default);
255storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
260string? blobsConnectionString = await ((IResourceWithConnectionString)blobs.Resource).ConnectionStringExpression.GetValueAsync(default);
263Assert.Equal(expected, await ((IResourceWithConnectionString)blobContainer.Resource).ConnectionStringExpression.GetValueAsync(default));
275Assert.Equal("Endpoint={storage.outputs.blobEndpoint};ContainerName=myContainer", blobContainer.Resource.ConnectionStringExpression.ValueExpression);
289var manifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
306Assert.True(storage.Resource.IsContainer());
313=> new(storage.Resource, new EndpointAnnotation(ProtocolType.Tcp, name: name, targetPort: port));
319Assert.Equal(blobqs, blob.Resource.ConnectionStringExpression.ValueExpression);
320Assert.Equal(queueqs, queue.Resource.ConnectionStringExpression.ValueExpression);
321Assert.Equal(tableqs, table.Resource.ConnectionStringExpression.ValueExpression);
328Assert.Equal(Resolve(blobqs, "blob", 10000), await ((IResourceWithConnectionString)blob.Resource).GetConnectionStringAsync());
329Assert.Equal(Resolve(queueqs, "queue", 10001), await ((IResourceWithConnectionString)queue.Resource).GetConnectionStringAsync());
330Assert.Equal(Resolve(tableqs, "table", 10002), await ((IResourceWithConnectionString)table.Resource).GetConnectionStringAsync());
349storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
350storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
351storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
354Assert.Equal("storage", storage.Resource.Name);
356var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
374var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
383var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
389var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
398var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
404var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
413var tableManifest = await ManifestUtils.GetManifest(table.Resource);
434storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
435storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
436storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
439Assert.Equal("storage", storage.Resource.Name);
441var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
459var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
468var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
474var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
483var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
489var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
498var tableManifest = await ManifestUtils.GetManifest(table.Resource);
522storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
523storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
524storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
527Assert.Equal("storage", storage.Resource.Name);
531var storageManifest = await GetManifestWithBicep(model, storage.Resource);
597var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
606var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
610var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
619var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
623var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
632var tableManifest = await ManifestUtils.GetManifest(table.Resource);
653storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
654storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
655storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
658Assert.Equal("storage", storage.Resource.Name);
660var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
679var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
688var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
694var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
703var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
709var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
718var tableManifest = await ManifestUtils.GetManifest(table.Resource);
AzureWebPubSubExtensionsTests.cs (41)
35Assert.Equal(hubName, hub.Resource.Name);
36var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
57var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
63Assert.Equal("wps1", wps.Resource.Name);
76Assert.Equal("{wps1.outputs.endpoint}", wps.Resource.ConnectionStringExpression.ValueExpression);
77Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=abc", hub.Resource.ConnectionStringExpression.ValueExpression);
79Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=hij", otherHub.Resource.ConnectionStringExpression.ValueExpression);
102var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
108Assert.Equal("wps1", wps.Resource.Name);
132var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
138Assert.Equal("wps1", wps.Resource.Name);
158wps.Resource.Outputs["endpoint"] = "https://mywebpubsubendpoint";
159var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
164Assert.Equal("wps1", wps.Resource.Name);
193wps.Resource.Outputs["endpoint"] = "https://mywebpubsubendpoint";
208var connectionStringResource = (IResourceWithConnectionString)wps.Resource;
211var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
218Assert.Equal("wps1", wps.Resource.Name);
234Assert.Equal("hub1", hub1.Resource.Name);
235Assert.Equal("resource2", hub2.Resource.Name);
236Assert.Equal("hub3", hub3.Resource.Name);
237Assert.Equal("hub4", hub4.Resource.Name);
239Assert.Equal("hub1", hub1.Resource.HubName);
240Assert.Equal("hub2", hub2.Resource.HubName);
241Assert.Equal("hub3", hub3.Resource.HubName);
242Assert.Equal("hub4", hub4.Resource.HubName);
244Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=hub1", hub1.Resource.ConnectionStringExpression.ValueExpression);
245Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=hub2", hub2.Resource.ConnectionStringExpression.ValueExpression);
246Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=hub3", hub3.Resource.ConnectionStringExpression.ValueExpression);
247Assert.Equal("Endpoint={wps1.outputs.endpoint};Hub=hub4", hub4.Resource.ConnectionStringExpression.ValueExpression);
261Assert.Same(hub1.Resource, hub2.Resource);
262Assert.Equal("resource1", hub1.Resource.Name);
263Assert.Equal("same-hub", hub1.Resource.HubName);
272wps.Resource.Outputs["endpoint"] = "https://mywebpubsubendpoint";
282var connectionStringResource = (IResourceWithConnectionString)wps.Resource;
288var manifest = await GetManifestWithBicep(model, wps.Resource);
292Assert.Equal("wps1", wps.Resource.Name);
332wps.Resource.Outputs["endpoint"] = "https://mywebpubsubendpoint";
345var manifest = await AzureManifestUtils.GetManifestWithBicep(wps.Resource);
348Assert.Equal("wps1", wps.Resource.Name);
BicepUtilitiesTests.cs (46)
23await BicepUtilities.SetParametersAsync(parameters, bicep0.Resource);
55.WithParameter("expr", ReferenceExpression.Create($"{param.Resource}/1"))
59await BicepUtilities.SetParametersAsync(parameters, bicep0.Resource);
73Assert.True(bicep0.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
78Assert.Equal(connectionStringResource.Resource, r.Resource);
83Assert.Equal(param.Resource, r.Resource);
88Assert.Equal(container.Resource, r.Resource);
110await BicepUtilities.SetParametersAsync(parameters0, bicep0.Resource);
111var checkSum0 = BicepUtilities.GetChecksum(bicep0.Resource, parameters0, null);
114await BicepUtilities.SetParametersAsync(parameters1, bicep1.Resource);
115var checkSum1 = BicepUtilities.GetChecksum(bicep1.Resource, parameters1, null);
137await BicepUtilities.SetParametersAsync(parameters0, bicep0.Resource);
138var checkSum0 = BicepUtilities.GetChecksum(bicep0.Resource, parameters0, null);
141await BicepUtilities.SetParametersAsync(parameters1, bicep1.Resource);
142var checkSum1 = BicepUtilities.GetChecksum(bicep1.Resource, parameters1, null);
163await BicepUtilities.SetParametersAsync(parameters0, bicep0.Resource);
164var checkSum0 = BicepUtilities.GetChecksum(bicep0.Resource, parameters0, null);
170var checkSum1 = await BicepUtilities.GetCurrentChecksumAsync(bicep1.Resource, config);
182bicep0.Resource.Scope = new("rg0");
186bicep1.Resource.Scope = new("rg1");
190await BicepUtilities.SetParametersAsync(parameters0, bicep0.Resource);
191await BicepUtilities.SetScopeAsync(scope0, bicep0.Resource);
192var checkSum0 = BicepUtilities.GetChecksum(bicep0.Resource, parameters0, scope0);
196await BicepUtilities.SetParametersAsync(parameters1, bicep1.Resource);
197await BicepUtilities.SetScopeAsync(scope1, bicep1.Resource);
198var checkSum1 = BicepUtilities.GetChecksum(bicep1.Resource, parameters1, scope1);
210bicep0.Resource.Scope = new("rg0");
214bicep1.Resource.Scope = new("rg0");
218await BicepUtilities.SetParametersAsync(parameters0, bicep0.Resource);
219await BicepUtilities.SetScopeAsync(scope0, bicep0.Resource);
220var checkSum0 = BicepUtilities.GetChecksum(bicep0.Resource, parameters0, scope0);
224await BicepUtilities.SetParametersAsync(parameters1, bicep1.Resource);
225await BicepUtilities.SetScopeAsync(scope1, bicep1.Resource);
226var checkSum1 = BicepUtilities.GetChecksum(bicep1.Resource, parameters1, scope1);
236var bicep1 = builder.AddBicepTemplateString("test1", "param name string").Resource;
237var bicep2 = builder.AddBicepTemplateString("test2", "param name string").Resource;
257var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
282var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
310var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
342var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
364var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
386var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
404var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
422var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
437var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
458var bicep = builder.AddBicepTemplateString("test", "param name string").Resource;
ExistingAzureResourceTests.cs (26)
23var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
40var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
57var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
77var (manifest, bicep) = await GetManifestWithBicep(model, serviceBus.Resource);
97var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(serviceBus.Resource);
114var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(storageAccount.Resource);
129var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(storageAccount.Resource);
146var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appConfiguration.Resource);
163var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(eventHubs.Resource);
180var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(keyVault.Resource);
197var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(logAnalytics.Resource);
214var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(postgresSql.Resource);
235var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(postgresSql.Resource);
252var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(search.Resource);
269var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(signalR.Resource);
286var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(webPubSub.Resource);
303var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(sqlServer.Resource);
319var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(sqlServer.Resource);
336var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(redis.Resource);
352var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(redis.Resource);
369var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(appInsights.Resource);
392var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(openAI.Resource);
412var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
433var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(cosmos.Resource);
449var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(acr.Resource);
466var (manifest, bicep) = await AzureManifestUtils.GetManifestWithBicep(acr.Resource);
PublicApiTests\CosmosDBPublicApiTests.cs (10)
22var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
42var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
62var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
82var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
102var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
120var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
136var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
154var parent = new AzureCosmosDBDatabaseResource("database", "cosmos-db", resource.Resource);
200var action = () => new AzureCosmosDBDatabaseResource(name, databaseName, parent.Resource);
218var action = () => new AzureCosmosDBDatabaseResource(name, databaseName, parent.Resource);
ResourceWithAzureFunctionsConfigTests.cs (36)
16var storageResource = builder.AddAzureStorage("storage").Resource;
28var blobResource = storageResource.AddBlobs("blobs").Resource;
40var queueResource = storageResource.AddQueues("queues").Resource;
51var cosmosResource = builder.AddAzureCosmosDB("cosmos").Resource;
63var dbResource = cosmosResource.AddCosmosDatabase("database").Resource;
76var containerResource = dbResource.AddContainer("container", "/id").Resource;
87var eventHubsResource = builder.AddAzureEventHubs("eventhubs").Resource;
98var serviceBusResource = builder.AddAzureServiceBus("servicebus").Resource;
109var storage = builder.AddAzureStorage("storage").RunAsEmulator().Resource;
127var storage = builder.AddAzureStorage("storage").Resource;
148var blobResource = storage.AddBlobs("blobs").Resource;
165var tableResource = storage.AddTables("tables").Resource;
182var queueResource = storage.AddQueues("queues").Resource;
198var cosmosResource = builder.AddAzureCosmosDB("cosmos").RunAsEmulator().Resource;
214var cosmosResource = builder.AddAzureCosmosDB("cosmos").WithAccessKeyAuthentication().Resource;
230var cosmosResource = builder.AddAzureCosmosDB("cosmos").Resource;
247var dbResource = cosmosResource.AddCosmosDatabase("database").Resource;
256Assert.Equal(cosmosResource.Resource.ConnectionStringExpression.ValueExpression, targetReferenceExpression.ValueExpression);
259Assert.Equal(cosmosResource.Resource.ConnectionStringExpression.ValueExpression, targetReferenceExpression.ValueExpression);
272var containerResource = cosmosResource.AddCosmosDatabase("database").AddContainer("container", "/partitionKey").Resource;
281Assert.Equal(targetReferenceExpression.ValueExpression, cosmosResource.Resource.ConnectionStringExpression.ValueExpression);
284Assert.Equal(targetReferenceExpression.ValueExpression, cosmosResource.Resource.ConnectionStringExpression.ValueExpression);
300var dbResource = cosmosResource.AddCosmosDatabase("database").Resource;
309Assert.Equal(targetReferenceExpression.ValueExpression, cosmosResource.Resource.ConnectionStringExpression.ValueExpression);
322var containerResource = cosmosResource.AddCosmosDatabase("database").AddContainer("container", "/partitionKey").Resource;
331Assert.Equal(targetReferenceExpression.ValueExpression, cosmosResource.Resource.ConnectionStringExpression.ValueExpression);
342var eventHubsResource = builder.AddAzureEventHubs("eventhubs").RunAsEmulator().Resource;
362var eventHubsResource = builder.AddAzureEventHubs("eventhubs").Resource;
382var serviceBusResource = builder.AddAzureServiceBus("servicebus").Resource;
399var queueResource = serviceBusResource.AddServiceBusQueue("ordersqueue").Resource;
418var queueResource = serviceBusResource.AddServiceBusQueue("ordersqueue").Resource;
438var topicResource = serviceBusResource.AddServiceBusTopic("notificationstopic").Resource;
457var topicResource = serviceBusResource.AddServiceBusTopic("notificationstopic").Resource;
478var subscriptionResource = topicResource.AddServiceBusSubscription("usersubscription").Resource;
500var subscriptionResource = topicResource.AddServiceBusSubscription("usersubscription").Resource;
515Assert.Equal(serviceBusResource.Resource.ConnectionStringExpression.ValueExpression, connectionStringExpression.ValueExpression);
Aspire.Hosting.Azure.WebPubSub (5)
Aspire.Hosting.Containers.Tests (38)
ContainerResourceBuilderTests.cs (17)
17Assert.Equal("redis-stack", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
25Assert.Equal("redis-stack", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
26Assert.Equal("1.0.0", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
34container.Resource.Annotations.RemoveAt(0);
37Assert.Equal("new-image", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
38Assert.Equal("latest", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
46container.Resource.Annotations.Add(new ContainerImageAnnotation { Image = "another-image" });
49Assert.Equal("new-image", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Last().Image);
50Assert.Equal("latest", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Last().Tag);
58Assert.Equal("7.1", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
66Assert.Equal("myregistry.azurecr.io", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Registry);
74Assert.Equal("42b5c726e719639fcc1e9dbc13dd843f567dcd37911d0e1abb9f47f2cc1c95cd", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().SHA256);
152var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
164var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
177var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
213var annotation = redis.Resource.Annotations.OfType<ContainerImagePullPolicyAnnotation>().Single();
221var containerImage = builder.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
Aspire.Hosting.Docker (9)
Aspire.Hosting.Docker.Tests (4)
Aspire.Hosting.Garnet (1)
Aspire.Hosting.Garnet.Tests (21)
Aspire.Hosting.Kafka.Tests (15)
Aspire.Hosting.Keycloak (2)
Aspire.Hosting.Keycloak.Tests (7)
Aspire.Hosting.Kubernetes (1)
Aspire.Hosting.Kubernetes.Tests (1)
Aspire.Hosting.Milvus (5)
Aspire.Hosting.Milvus.Tests (18)
Aspire.Hosting.MongoDB (6)
Aspire.Hosting.MongoDB.Tests (30)
Aspire.Hosting.MySql (4)
Aspire.Hosting.MySql.Tests (61)
AddMySqlTests.cs (21)
23Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName);
33Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName);
160var mySqlManifest = await ManifestUtils.GetManifest(mysql.Resource);
161var dbManifest = await ManifestUtils.GetManifest(db.Resource);
199var serverManifest = await ManifestUtils.GetManifest(mysql.Resource);
251Assert.Equal($"{mysql.Resource.Name}:{mysql.Resource.PrimaryEndpoint.TargetPort}", config["PMA_HOST"]);
283string pattern1 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql1.Resource.Name}:{mysql1.Resource.PrimaryEndpoint.TargetPort}';";
284string pattern2 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql2.Resource.Name}:{mysql2.Resource.PrimaryEndpoint.TargetPort}';";
324Assert.Equal(["db1", "db2"], mysql1.Resource.Databases.Keys);
325Assert.Equal(["customers1", "customers2"], mysql1.Resource.Databases.Values);
327Assert.Equal("customers1", db1.Resource.DatabaseName);
328Assert.Equal("customers2", db2.Resource.DatabaseName);
330Assert.Equal("{mysql1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
331Assert.Equal("{mysql1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
345Assert.Equal("imports", db1.Resource.DatabaseName);
346Assert.Equal("imports", db2.Resource.DatabaseName);
348Assert.Equal("{mysql1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
349Assert.Equal("{mysql2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
MySqlFunctionalTests.cs (40)
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);
133var password = mysql1.Resource.PasswordParameter.Value;
165[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default)
168hb.AddMySqlDataSource(db1.Resource.Name);
234[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
237hb.AddMySqlDataSource(db2.Resource.Name);
337[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
340hb.AddMySqlDataSource(db.Resource.Name);
423[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
426hb.AddMySqlDataSource(db.Resource.Name);
493[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
496hb.AddMySqlDbContext<TestDbContext>(db.Resource.Name);
650hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
652hb.AddMySqlDataSource(newDb.Resource.Name);
658await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
725hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
727hb.AddMySqlDataSource(newDb.Resource.Name);
733await app.ResourceNotifications.WaitForResourceHealthyAsync(mysql.Resource.Name, cts.Token);
784hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
785hb.AddKeyedMySqlDataSource(db.Resource.Name);
794await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
796var conn = host.Services.GetRequiredKeyedService<MySqlConnection>(db.Resource.Name);
826hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
827hb.AddMySqlDataSource(newDb.Resource.Name);
832await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
Aspire.Hosting.Nats (2)
Aspire.Hosting.Nats.Tests (33)
NatsFunctionalTests.cs (19)
36await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
40hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
81await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
85var connectionString = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
86hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = connectionString;
123await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
127var connectionString = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
132hb.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);
Aspire.Hosting.NodeJs.Tests (5)
Aspire.Hosting.Oracle (3)
Aspire.Hosting.Oracle.Tests (35)
AddOracleTests.cs (13)
22Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", orcl.Resource.PasswordParameter.Default?.GetType().FullName);
32Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", orcl.Resource.PasswordParameter.Default?.GetType().FullName);
200var serverManifest = await ManifestUtils.GetManifest(oracleServer.Resource);
201var dbManifest = await ManifestUtils.GetManifest(db.Resource);
239var serverManifest = await ManifestUtils.GetManifest(oracleServer.Resource);
295Assert.Equal("customers1", db1.Resource.DatabaseName);
296Assert.Equal("customers2", db2.Resource.DatabaseName);
298Assert.Equal("{oracle1.connectionString}/customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
299Assert.Equal("{oracle1.connectionString}/customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
313Assert.Equal("imports", db1.Resource.DatabaseName);
314Assert.Equal("imports", db2.Resource.DatabaseName);
316Assert.Equal("{oracle1.connectionString}/imports", db1.Resource.ConnectionStringExpression.ValueExpression);
317Assert.Equal("{oracle2.connectionString}/imports", db2.Resource.ConnectionStringExpression.ValueExpression);
Aspire.Hosting.Orleans (7)
Aspire.Hosting.PostgreSQL (10)
Aspire.Hosting.PostgreSQL.Tests (75)
AddPostgresTests.cs (27)
22Assert.Single(redis.Resource.Annotations, a => a is HealthCheckAnnotation hca && hca.Key == "postgres_check");
32Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", pg.Resource.PasswordParameter.Default?.GetType().FullName);
42Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", pg.Resource.PasswordParameter.Default?.GetType().FullName);
158var connectionStringResource = postgres.Resource as IResourceWithConnectionString;
162Assert.Equal($"Host=localhost;Port=2000;Username=postgres;Password={postgres.Resource.PasswordParameter.Value}", connectionString);
249var serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
250var dbManifest = await ManifestUtils.GetManifest(db.Resource);
293var serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
319serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
345serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
488Assert.Equal(pg1.Resource.Name, servers.GetProperty("1").GetProperty("Name").GetString());
495Assert.Equal($"echo '{pg1.Resource.PasswordParameter.Value}'", servers.GetProperty("1").GetProperty("PasswordExecCommand").GetString());
498Assert.Equal(pg2.Resource.Name, servers.GetProperty("2").GetProperty("Name").GetString());
505Assert.Equal($"echo '{pg2.Resource.PasswordParameter.Value}'", servers.GetProperty("2").GetProperty("PasswordExecCommand").GetString());
552Assert.Equal(CreatePgWebBookmarkfileContent(db1.Resource), file.Contents);
559Assert.Equal(CreatePgWebBookmarkfileContent(db2.Resource), file.Contents);
596Assert.Equal("customers1", db1.Resource.DatabaseName);
597Assert.Equal("customers2", db2.Resource.DatabaseName);
599Assert.Equal("{postgres1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
600Assert.Equal("{postgres1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
614Assert.Equal("imports", db1.Resource.DatabaseName);
615Assert.Equal("imports", db2.Resource.DatabaseName);
617Assert.Equal("{postgres1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
618Assert.Equal("{postgres2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
661var connectionString = await postgres.Resource.GetConnectionStringAsync();
675var connectionString = await postgres.Resource.GetConnectionStringAsync();
676Assert.Equal($"Host=localhost;Port=2000;Username=user1;Password={postgres.Resource.PasswordParameter.Value}", connectionString);
PostgresFunctionalTests.cs (45)
53await app.ResourceNotifications.WaitForResourceAsync(postgres.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
56await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
62await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
65await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
87await app.WaitForTextAsync("Listening at", resourceName: adminBuilder.Resource.Name);
89var client = app.CreateHttpClient(adminBuilder.Resource.Name, "http");
120[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
123hb.AddNpgsqlDataSource(db.Resource.Name);
129await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token);
166var client = app.CreateHttpClient(pgWebBuilder.Resource.Name, "http");
168await app.ResourceNotifications.WaitForResourceHealthyAsync(pgWebBuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
234await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token);
242[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default)
245hb.AddNpgsqlDataSource(db1.Resource.Name);
296await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token);
304[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default)
307hb.AddNpgsqlDataSource(db2.Resource.Name);
399[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
402hb.AddNpgsqlDataSource(db.Resource.Name);
408await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
485[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
488hb.AddNpgsqlDataSource(db.Resource.Name);
494await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
612hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
614hb.AddNpgsqlDataSource(newDb.Resource.Name);
620await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
653hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
655hb.AddNpgsqlDataSource(newDb.Resource.Name);
661await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
722hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
724hb.AddNpgsqlDataSource(newDb.Resource.Name);
730await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token);
781hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
782hb.AddKeyedNpgsqlDataSource(db.Resource.Name);
791await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
793var conn = host.Services.GetRequiredKeyedService<NpgsqlConnection>(db.Resource.Name);
Aspire.Hosting.Python.Tests (3)
Aspire.Hosting.Qdrant (5)
Aspire.Hosting.Qdrant.Tests (21)
Aspire.Hosting.RabbitMQ (5)
Aspire.Hosting.RabbitMQ.Tests (20)
Aspire.Hosting.Redis (5)
Aspire.Hosting.Redis.Tests (70)
AddRedisTests.cs (26)
20Assert.Single(redis.Resource.Annotations, a => a is HealthCheckAnnotation hca && hca.Key == "redis_check");
136var manifest = await ManifestUtils.GetManifest(redis.Resource);
170var manifest = await ManifestUtils.GetManifest(redis.Resource);
205var manifest = await ManifestUtils.GetManifest(redis.Resource);
240var manifest = await ManifestUtils.GetManifest(redis.Resource);
310Assert.Equal(redis1.Resource.Name, item.Value);
315Assert.Equal($"{redis1.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
320Assert.Equal(redis1.Resource.Name, item.Value);
325Assert.Equal(redis1.Resource.PasswordParameter!.Value, item.Value);
330Assert.Equal(redis2.Resource.Name, item.Value);
335Assert.Equal($"{redis2.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
340Assert.Equal(redis2.Resource.Name, item.Value);
345Assert.Equal(redis2.Resource.PasswordParameter!.Value, item.Value);
350Assert.Equal(redis3.Resource.Name, item.Value);
355Assert.Equal($"{redis3.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
360Assert.Equal(redis3.Resource.Name, item.Value);
500Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{redis.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]);
521Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{password}", config["REDIS_HOSTS"]);
545Assert.Equal($"myredis1:{redis1.Resource.Name}:6379:0:{redis1.Resource.PasswordParameter?.Value},myredis2:myredis2:6379:0:{redis2.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]);
565var volumeAnnotation = redis.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
590var volumeAnnotation = redis.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
660var args = await ArgumentEvaluator.GetArgumentListAsync(builder.Resource);
671Assert.True(redis.Resource.TryGetAnnotationsOfType<CommandLineArgsCallbackAnnotation>(out var argsAnnotations));
RedisFunctionalTests.cs (44)
52await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
54await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
58await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
60await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
81await app.WaitForTextAsync("Redis Connection", resourceName: commanderBuilder.Resource.Name);
83var client = app.CreateHttpClient(commanderBuilder.Resource.Name, "http");
86var path = $"/apiv2/server/R:{redis.Resource.Name}:{endpoint.TargetPort}:0/info";
107[$"ConnectionStrings:{redis.Resource.Name}"] = await redis.Resource.GetConnectionStringAsync()
110hb.AddRedisClient(redis.Resource.Name);
146await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
148var client = app.CreateHttpClient(redisInsightBuilder.Resource.Name, "http");
164Assert.Equal(redis1.Resource.Name, db.Name);
165Assert.Equal(redis1.Resource.Name, db.Host);
166Assert.Equal(redis1.Resource.PrimaryEndpoint.TargetPort, db.Port);
170Assert.Equal(redis2.Resource.Name, db.Name);
171Assert.Equal(redis2.Resource.Name, db.Host);
172Assert.Equal(redis2.Resource.PrimaryEndpoint.TargetPort, db.Port);
176Assert.Equal(redis3.Resource.Name, db.Name);
177Assert.Equal(redis3.Resource.Name, db.Host);
178Assert.Equal(redis3.Resource.PrimaryEndpoint.TargetPort, db.Port);
213[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
216hb.AddRedisClient(redis1.Resource.Name);
249[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
252hb.AddRedisClient(redis2.Resource.Name);
296[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
299hb.AddRedisClient(redis1.Resource.Name);
331[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
334hb.AddRedisClient(redis2.Resource.Name);
380[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
383hb.AddRedisClient(redis1.Resource.Name);
410[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
413hb.AddRedisClient(redis2.Resource.Name);
478await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
482var httpClient = app.CreateHttpClient(redisInsightBuilder1.Resource.Name, "http");
513await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
517var httpClient = app.CreateHttpClient(redisInsightBuilder2.Resource.Name, "http");
616await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token);
Aspire.Hosting.Seq.Tests (12)
Aspire.Hosting.SqlServer (5)
Aspire.Hosting.SqlServer.Tests (47)
AddSqlServerTests.cs (13)
22Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName);
32Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName);
130var serverManifest = await ManifestUtils.GetManifest(sqlServer.Resource);
131var dbManifest = await ManifestUtils.GetManifest(db.Resource);
171var serverManifest = await ManifestUtils.GetManifest(sqlServer.Resource);
228Assert.Equal("customers1", db1.Resource.DatabaseName);
229Assert.Equal("customers2", db2.Resource.DatabaseName);
231Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
232Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
246Assert.Equal("imports", db1.Resource.DatabaseName);
247Assert.Equal("imports", db2.Resource.DatabaseName);
249Assert.Equal("{sqlserver1.connectionString};Initial Catalog=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
250Assert.Equal("{sqlserver2.connectionString};Initial Catalog=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
SqlServerFunctionalTests.cs (34)
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);
81hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
83hb.AddSqlServerDbContext<TestDbContext>(newDb.Resource.Name);
84hb.AddSqlServerClient(newDb.Resource.Name);
142var password = sqlserver1.Resource.PasswordParameter.Value;
179await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token);
187[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default),
190hb1.AddSqlServerClient(db1.Resource.Name);
264await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token);
272[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default),
275hb2.AddSqlServerClient(db2.Resource.Name);
368hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
370hb.AddSqlServerClient(newDb.Resource.Name);
376await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
421hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
423hb.AddSqlServerClient(newDb.Resource.Name);
429await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
493hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
495hb.AddSqlServerClient(newDb.Resource.Name);
501await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token);
553hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
554hb.AddKeyedSqlServerClient(db.Resource.Name);
563await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
565var conn = host.Services.GetRequiredKeyedService<SqlConnection>(db.Resource.Name);
Aspire.Hosting.Testing.Tests (1)
Aspire.Hosting.Tests (399)
DistributedApplicationTests.cs (12)
476using var clientA = app.CreateHttpClient(testProgram.ServiceABuilder.Resource.Name, "http");
477using var clientC = app.CreateHttpClient(testProgram.ServiceCBuilder.Resource.Name, "http");
484var uri = app.GetEndpoint(testProgram.ServiceBBuilder.Resource.Name, "http");
1105await app.WaitForTextAsync("Content root path:", resourceName: testProgram.ServiceABuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutDuration);
1108var httpEndPoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "http");
1126var httpsEndpoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "https");
1174using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");
1182Assert.Equal($"localhost:1234,password={redis.Resource.PasswordParameter?.Value}", env.Value);
1189Assert.Equal($"localhost:6379,password={redisNoPort.Resource.PasswordParameter?.Value}", otherRedisEnv.Value);
1224using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");
1236Assert.Equal($"localhost:1234,password={redis.Resource.PasswordParameter!.Value}", env.Value);
1243Assert.Equal($"localhost:6379,password={redisNoPort.Resource.PasswordParameter!.Value}", otherRedisEnv.Value);
ExpressionResolverTests.cs (5)
98var csRef = new ConnectionStringReference(target.Resource, false);
110var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(source.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
144var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(test.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
163var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(test.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
184var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(dep.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
ExternalServiceTests.cs (25)
20Assert.Equal("nuget", externalService.Resource.Name);
21Assert.Equal("https://nuget.org/", externalService.Resource.Uri?.ToString());
22Assert.Null(externalService.Resource.UrlParameter);
33Assert.Equal("nuget", externalService.Resource.Name);
34Assert.Equal("https://nuget.org/", externalService.Resource.Uri?.ToString());
35Assert.Null(externalService.Resource.UrlParameter);
46Assert.Equal("nuget", externalService.Resource.Name);
47Assert.Null(externalService.Resource.Uri);
48Assert.NotNull(externalService.Resource.UrlParameter);
49Assert.Equal("nuget-url", externalService.Resource.UrlParameter.Name);
96Assert.Equal("nuget", externalService.Resource.Name);
97Assert.Equal(validUrl, externalService.Resource.Uri?.ToString());
110var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
126var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
144var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
166var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Publish, app.Services).DefaultTimeout();
171Assert.Equal(urlParam.Resource.ValueExpression, urlValue);
188await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
204Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
205Assert.NotNull(healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external")));
220Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
221Assert.NotNull(healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external")));
243Assert.True(externalService.Resource.TryGetAnnotationsOfType<ResourceSnapshotAnnotation>(out var snapshotAnnotations));
256Assert.IsAssignableFrom<IResourceWithoutLifetime>(externalService.Resource);
268Assert.True(externalService.Resource.TryGetAnnotationsOfType<ManifestPublishingCallbackAnnotation>(out var manifestAnnotations));
Health\ResourceHealthCheckServiceTests.cs (30)
33await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
41await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
73await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
81await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
116await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
124await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
163await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
172Assert.Equal(resource.Resource, e1.Resource);
178await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
186await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
200Assert.Equal(resource.Resource, e2.Resource);
229await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
233await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout();
270await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
313await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
317await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout();
349await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
355Assert.Equal(resource.Resource, @event.Resource);
380await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
442await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
487await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
527var child = builder.AddResource(new ChildResource("child", parent.Resource))
538await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
546await app.ResourceNotifications.PublishUpdateAsync(child.Resource, s => s with
552Assert.Equal(parentReadyEvent.Resource, parent.Resource);
555Assert.Equal(childReadyEvent.Resource, child.Resource);
582await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
590await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
628await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
636await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
Orchestrator\ApplicationOrchestratorTests.cs (25)
25var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
42if (item.Resource == parentResource.Resource)
46else if (item.Resource == childResource.Resource)
89if (item.Resource == parentResource.Resource)
93else if (item.Resource == childResource.Resource)
135applicationEventing.Subscribe<InitializeResourceEvent>(resource.Resource, (@event, ct) =>
153Assert.Equal(resource.Resource, initEvent.Resource);
187if (item.Resource == parent.Resource)
191else if (item.Resource == child.Resource)
196else if (item.Resource == nestedChild.Resource)
200else if (item.Resource == child2.Resource)
252if (item.Resource == firstParent.Resource)
256else if (item.Resource == secondParent.Resource)
260else if (item.Resource == child.Resource)
303if (item.Resource == projectA.Resource)
307else if (item.Resource == projectB.Resource)
352new ChildResourceWithConnectionString("child", new Dictionary<string, string> { {"Namespace", "ns"} }, parentResource.Resource)
355new ChildResourceWithConnectionString("grand-child", new Dictionary<string, string> { {"Database", "db"} }, childResource.Resource)
372applicationEventing.Subscribe<ConnectionStringAvailableEvent>(parentResource.Resource, (_, _) =>
377applicationEventing.Subscribe<ConnectionStringAvailableEvent>(childResource.Resource, (_, _) =>
382applicationEventing.Subscribe<ConnectionStringAvailableEvent>(grandChildResource.Resource, (_, _) =>
388await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parentResource.Resource, parentResource.Resource.Name));
418if (item.Resource == resource.Resource)
432await applicationEventing.PublishAsync(new ConnectionStringAvailableEvent(resource.Resource, app.Services), CancellationToken.None);
Orchestrator\RelationshipEvaluatorTests.cs (14)
18var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
19var grandChildResource = builder.AddResource(new CustomChildResource("grandchild", childResource.Resource));
20var greatGrandChildResource = builder.AddResource(new CustomChildResource("greatgrandchild", grandChildResource.Resource));
34Assert.Collection(parentChildLookup[parentResource.Resource],
35x => Assert.Equal(childResource.Resource, x),
36x => Assert.Equal(childWithAnnotationsResource.Resource, x));
38Assert.Single(parentChildLookup[childResource.Resource], grandChildResource.Resource);
39Assert.Single(parentChildLookup[grandChildResource.Resource], greatGrandChildResource.Resource);
41Assert.Empty(parentChildLookup[greatGrandChildResource.Resource]);
43Assert.Single(parentChildLookup[childWithAnnotationsResource.Resource], grandChildWithAnnotationsResource.Resource);
45Assert.Empty(parentChildLookup[grandChildWithAnnotationsResource.Resource]);
WaitForTests.cs (60)
32await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
33await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
34await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
65var childResourceBuilder = builder.AddResource(new CustomChildResource("child", parentResourceBuilder.Resource));
107await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
109await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
138await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
140await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
175await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
180await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
216await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
218await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
223await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token);
244dependency.Resource.Name,
268dependency.Resource.Name,
298await app.ResourceNotifications.WaitForResourceHealthyAsync(dependency.Resource.Name)
327await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
329await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
334await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token);
361await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
363await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
368await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
371await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
376await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
408await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
410await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
415await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
418await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
423await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
453await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
458await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
468await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token);
500await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token);
505await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
515await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
555await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token);
560await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
571await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
609await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
614await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
623await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
660await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
663await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test0", s => s with
668await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
671await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test1", s => s with
676await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
713await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
716await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test0", s => s with
721await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
724await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test1", s => s with
729await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
762await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
765await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
770await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
782var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
786Assert.True(containerResource.Resource.TryGetAnnotationsOfType<WaitAnnotation>(out var waitAnnotations));
789a => Assert.Equal(a.Resource, parentResource.Resource),
790a => Assert.Equal(a.Resource, childResource.Resource)
793Assert.True(containerResource.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationshipAnnotations));
796Assert.Equal(childResource.Resource, relationshipAnnotation.Resource);
WithEnvironmentTests.cs (37)
33container.Resource,
55var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
59Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
64Assert.Same(projectA.Resource, r.Resource);
76var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
92var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
108var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
125var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
129Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
134Assert.Same(parameter.Resource, r.Resource);
148var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource,
165projectA.Resource,
190var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
214var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
239.WithEnvironment("HOST", $"{test.Resource};name=1");
241var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource).DefaultTimeout();
242var manifestConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
256Assert.True(containerB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
261Assert.Same(container.Resource, r.Resource);
266Assert.Same(test.Resource, r.Resource);
287Assert.True(containerB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
292Assert.Same(container.Resource, r.Resource);
313var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource).DefaultTimeout();
337var runConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(targetBuilder.Resource, DistributedApplicationOperation.Run).DefaultTimeout();
343var publishConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(targetBuilder.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
348Assert.True(targetBuilder.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
353Assert.Same(sourceBuilder.Resource, r.Resource);
368projectA.Resource,
376projectA.Resource,
389var testValue = new TestValueWithReferences("test-value", resourceA.Resource);
395Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
398Assert.Same(resourceA.Resource, relationship.Resource);
402projectA.Resource,
449projectA.Resource,
457projectA.Resource,
464Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
467Assert.Same(container.Resource, relationship.Resource);
WithHttpCommandTests.cs (19)
89var command = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().FirstOrDefault();
95Assert.Equal($"{resourceBuilder.Resource.Name}-http-http-post-/some-path", command.Name);
122var command = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().FirstOrDefault();
152var commands = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().ToList();
191var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
215var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
238var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
277var result = await app.ResourceCommands.ExecuteCommandAsync(serviceB.Resource, "mycommand");
315resolvedResourceName = resourceBuilder.Resource.GetResolvedResourceNames().Single();
317var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
356resolvedResourceName = resourceBuilder.Resource.GetResolvedResourceNames().Single();
358var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
400await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
404await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Starting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
410await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
414await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
470await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
474await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
481await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
WithReferenceTests.cs (27)
29var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
33Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
38Assert.Same(projectA.Resource, r.Resource);
60var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
85var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
108var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
113Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
118Assert.Same(projectA.Resource, r.Resource);
137var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
142Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
147Assert.Same(projectA.Resource, r.Resource);
163await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
177var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
196var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
215var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
231var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
247var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
266var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
290var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
296Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
301Assert.Same(resource.Resource, r.Resource);
304Assert.True(resource.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var csRelationships));
309Assert.Same(endpoint.Resource, r.Resource);
314Assert.Same(key.Resource, r.Resource);
336var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
358var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
390var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
Aspire.Hosting.Valkey (1)
Aspire.Hosting.Valkey.Tests (22)
Aspire.Hosting.Yarp (9)
Aspire.Hosting.Yarp.Tests (8)
Aspire.Playground.Tests (1)
BicepSample.AppHost (1)
KafkaBasic.AppHost (2)
Stress.AppHost (2)