1 implementation of Resource
Aspire.Hosting (1)
2055 references to Resource
Aspire.Hosting (140)
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)
185var url = await externalService.Resource.UrlParameter.GetValueAsync(context.CancellationToken).ConfigureAwait(false);
188throw new DistributedApplicationException($"The URL parameter '{externalService.Resource.UrlParameter.Name}' for the external service '{externalService.Resource.Name}' is invalid: {message}");
192context.EnvironmentVariables[name] = externalService.Resource.UrlParameter;
213builder.WithReferenceRelationship(parameter.Resource);
217context.EnvironmentVariables[name] = parameter.Resource;
239builder.WithReferenceRelationship(resource.Resource);
243context.EnvironmentVariables[envVarName] = new ConnectionStringReference(resource.Resource, optional: false);
453var resource = source.Resource;
480ApplyEndpoints(builder, source.Resource);
527builder.WithReferenceRelationship(externalService.Resource);
529if (externalService.Resource.Uri is { } uri)
531var envVarName = $"services__{externalService.Resource.Name}__{uri.Scheme}__0";
534else if (externalService.Resource.UrlParameter is not null)
542envVarName = $"services__{externalService.Resource.Name}__default__0";
544else if (ExternalServiceResource.UrlIsValidForExternalService(await externalService.Resource.UrlParameter.GetValueAsync(context.CancellationToken).ConfigureAwait(false), out var uri, out var message))
546envVarName = $"services__{externalService.Resource.Name}__{uri.Scheme}__0";
550throw new DistributedApplicationException($"The URL parameter '{externalService.Resource.UrlParameter.Name}' for the external service '{externalService.Resource.Name}' is invalid: {message}");
552context.EnvironmentVariables[envVarName] = externalService.Resource.UrlParameter;
584var endpointReferenceAnnotation = builder.Resource.Annotations
648var endpoint = builder.Resource.Annotations
662builder.Resource.Annotations.Add(endpoint);
702if (builder.Resource.Annotations.OfType<EndpointAnnotation>().Any(sb => string.Equals(sb.Name, annotation.Name, StringComparisons.EndpointAnnotationName)))
708if (env is not null && builder.Resource is IResourceWithEndpoints resourceWithEndpoints and IResourceWithEnvironment)
793if (!builder.Resource.TryGetAnnotationsOfType<EndpointAnnotation>(out var endpoints))
821return builder.Resource.GetEndpoint(name);
1038context.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);
1085context.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);
1184if (builder.Resource as IResource == dependency.Resource)
1186throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for itself.");
1189if (builder.Resource is IResourceWithParent resourceWithParent && resourceWithParent.Parent == dependency.Resource)
1191throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for its parent '{dependency.Resource.Name}'.");
1194if (dependency.Resource is IResourceWithParent dependencyResourceWithParent)
1206if (dependency.Resource is ConnectionStringResource cs)
1217builder.WithRelationship(dependency.Resource, KnownRelationshipTypes.WaitFor);
1220return builder.WithAnnotation(new WaitAnnotation(dependency.Resource, WaitType.WaitUntilHealthy) { WaitBehavior = waitBehavior });
1280if (builder.Resource as IResource == dependency.Resource)
1282throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for itself.");
1285if (builder.Resource is IResourceWithParent resourceWithParent && resourceWithParent.Parent == dependency.Resource)
1287throw new DistributedApplicationException($"The '{builder.Resource.Name}' resource cannot wait for its parent '{dependency.Resource.Name}'.");
1290builder.WithRelationship(dependency.Resource, KnownRelationshipTypes.WaitFor);
1292return builder.WithAnnotation(new WaitAnnotation(dependency.Resource, WaitType.WaitForCompletion, exitCode));
1336if (builder.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var annotations) && annotations.Any(a => a.Key == key))
1338throw new DistributedApplicationException($"Resource '{builder.Resource.Name}' already has a health check with key '{key}'.");
1420?? throw new DistributedApplicationException($"Could not create HTTP health check for resource '{builder.Resource.Name}' as the endpoint selector returned null.");
1424throw 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.");
1436throw new DistributedApplicationException($"The endpoint '{endpointName}' does not exist on the resource '{builder.Resource.Name}'.");
1450var healthCheckKey = $"{builder.Resource.Name}_{endpointName}_{path}_{statusCode}_check";
1540var existingAnnotation = builder.Resource.Annotations.OfType<ResourceCommandAnnotation>().SingleOrDefault(a => a.Name == name);
1543builder.Resource.Annotations.Remove(existingAnnotation);
1605var existingAnnotation = builder.Resource.Annotations.OfType<ResourceCommandAnnotation>().SingleOrDefault(a => a.Name == name);
1608builder.Resource.Annotations.Remove(existingAnnotation);
1772?? throw new DistributedApplicationException($"Could not create HTTP command for resource '{builder.Resource.Name}' as the endpoint selector returned null.");
1776throw 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.");
1874var endpoints = builder.Resource.GetEndpoints();
1884throw 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.");
1892throw new DistributedApplicationException($"Could not create {errorDisplayNoun} for resource '{builder.Resource.Name}' as no endpoint was found matching one of the specified names: {endpointNamesString}");
1900var endpoints = builder.Resource.GetEndpoints();
1912throw new DistributedApplicationException($"Could not create HTTP command for resource '{builder.Resource.Name}' as it has no HTTP endpoints.");
2009AddReference(resourceBuilder.Resource);
2040return builder.WithAnnotation(new ResourceRelationshipAnnotation(resourceBuilder.Resource, KnownRelationshipTypes.Reference));
2070return builder.WithParentRelationship(parent.Resource);
2155builder.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(name, name, parameterResource.Resource);
202var secret = new AzureKeyVaultSecretResource(name, name, builder.Resource, parameterResource);
203builder.Resource.Secrets.Add(secret);
222var secret = new AzureKeyVaultSecretResource(name, name, 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)
356var passwordParameter = ParameterResourceBuilderExtensions.CreateDefaultPasswordParameter(builder.ApplicationBuilder, $"{builder.Resource.Name}-sql-pwd", minLower: 1, minUpper: 1, minNumeric: 1);
370.AddContainer($"{builder.Resource.Name}-sqledge",
384var sqlEndpoint = sqlEdgeResource.Resource.GetEndpoint("tcp");
393var surrogate = new AzureServiceBusEmulatorResource(builder.Resource);
414var customConfigFile = builder.Resource.Annotations.OfType<ConfigFileAnnotation>().FirstOrDefault();
427var tempConfig = JsonNode.Parse(CreateEmulatorConfigJson(builder.Resource));
435var configJsonAnnotations = builder.Resource.Annotations.OfType<ConfigJsonAnnotation>();
Aspire.Hosting.Azure.SignalR (2)
Aspire.Hosting.Azure.Sql (11)
Aspire.Hosting.Azure.Storage (25)
AzureStorageExtensions.cs (24)
181var blobConnectionString = await builder.Resource.GetBlobConnectionString().GetValueAsync(ct).ConfigureAwait(false) ?? throw new DistributedApplicationException($"{nameof(ConnectionStringAvailableEvent)} was published for the '{builder.Resource.Name}' resource but the connection string was null.");
184var queueConnectionString = await builder.Resource.GetQueueConnectionString().GetValueAsync(ct).ConfigureAwait(false) ?? throw new DistributedApplicationException($"{nameof(ConnectionStringAvailableEvent)} was published for the '{builder.Resource.Name}' resource but the connection string was null.");
195foreach (var container in builder.Resource.BlobContainers)
201foreach (var queue in builder.Resource.Queues)
209var healthCheckKey = $"{builder.Resource.Name}_check";
221var surrogate = new AzureStorageEmulatorResource(builder.Resource);
242return builder.WithBindMount(path ?? $".azurite/{builder.Resource.Name}", "/data", isReadOnly);
341if (string.Equals(name, builder.Resource.Name + "-blobs", StringComparisons.ResourceName))
378var name = builder.Resource.Name + "-blobs";
380return builder.Resource.BlobStorageBuilder ??= CreateBlobService(builder, name);
397AzureBlobStorageContainerResource resource = new(name, blobContainerName, GetBlobService(builder).Resource);
398builder.Resource.BlobContainers.Add(resource);
434AzureBlobStorageContainerResource resource = new(name, blobContainerName, builder.Resource);
435builder.Resource.Parent.BlobContainers.Add(resource);
480if (string.Equals(name, builder.Resource.Name + "-queues", StringComparisons.ResourceName))
499var name = builder.Resource.Name + "-queues";
501return builder.Resource.QueueStorageBuilder ??= CreateQueueService(builder, name);
518AzureQueueStorageQueueResource resource = new(name, queueName, builder.GetQueueService().Resource);
519builder.Resource.Queues.Add(resource);
598var resource = new AzureBlobStorageResource(name, builder.Resource);
623var resource = new AzureTableStorageResource(name, builder.Resource);
629var resource = new AzureQueueStorageResource(name, builder.Resource);
Aspire.Hosting.Azure.Tests (596)
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 (43)
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);
535Assert.True(cosmos.Resource.IsEmulator());
536Assert.Contains(cosmos.Resource.Annotations, a => a is EmulatorResourceAnnotation);
549Assert.True(cosmos.Resource.IsEmulator());
550Assert.Contains(cosmos.Resource.Annotations, a => a is EmulatorResourceAnnotation);
AzureEventHubsExtensionsTests.cs (31)
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");
617Assert.True(eventHubs.Resource.IsEmulator());
618Assert.Contains(eventHubs.Resource.Annotations, a => a is EmulatorResourceAnnotation);
AzureKeyVaultTests.cs (22)
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);
189Assert.True(secretResource.Resource.TryGetAnnotationsOfType<ManifestPublishingCallbackAnnotation>(out var manifestAnnotations));
208var (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.");
107Assert.Equal($"localhost:12455,password={redisResource.PasswordParameter.Value}", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
121redisResource = c.Resource;
139Assert.True(redis.Resource.IsContainer(), "The resource should now be a container resource.");
142Assert.Equal($"localhost:12455,password=p@ssw0rd1", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));
197Assert.True(redis.Resource.IsContainer());
198Assert.NotNull(redis.Resource.PasswordParameter);
201Assert.Equal($"localhost:12455,password={redis.Resource.PasswordParameter.Value}", await redis.Resource.GetConnectionStringAsync());
204var manifest = await AzureManifestUtils.GetManifestWithBicep(redis.Resource);
AzureServiceBusExtensionsTests.cs (34)
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);
838Assert.True(serviceBus.Resource.IsEmulator());
839Assert.Contains(serviceBus.Resource.Annotations, a => a is EmulatorResourceAnnotation);
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 (23)
49await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token);
51await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
55await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token);
56await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token);
57await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token);
59await 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);
137await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token);
139await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
143await rns.WaitForResourceHealthyAsync(testQueue.Resource.Name, cts.Token);
145await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
175hb.Configuration[$"ConnectionStrings:{blobsResourceName}"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
176hb.Configuration[$"ConnectionStrings:{blobContainerName}"] = await container.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
177hb.Configuration[$"ConnectionStrings:{queuesResourceName}"] = await queues.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
178hb.Configuration[$"ConnectionStrings:{queueName}"] = await queue.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
190await rns.WaitForResourceHealthyAsync(storage.Resource.Name, cts.Token);
223await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cancellationToken: cts.Token);
226hb.Configuration["ConnectionStrings:BlobConnection"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
262await rns.WaitForResourceHealthyAsync(queue.Resource.Name, cancellationToken: cts.Token);
265hb.Configuration["ConnectionStrings:QueueConnection"] = await queues.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);
AzureStorageExtensionsTests.cs (90)
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));
274Assert.Equal("Endpoint={storage.outputs.blobEndpoint};ContainerName=myContainer", blobContainer.Resource.ConnectionStringExpression.ValueExpression);
291Assert.True(storage.Resource.IsContainer());
295Assert.Equal(expected, await ((IResourceWithConnectionString)queues.Resource).GetConnectionStringAsync());
307storage.Resource.Outputs["queueEndpoint"] = connectionString;
311Assert.Equal(connectionString, await ((IResourceWithConnectionString)queues.Resource).GetConnectionStringAsync());
322Assert.Equal("{storage.outputs.queueEndpoint}", queues.Resource.ConnectionStringExpression.ValueExpression);
339Assert.True(storage.Resource.IsContainer());
344string? connectionString = await ((IResourceWithConnectionString)queues.Resource).GetConnectionStringAsync();
347Assert.Equal(expected, await ((IResourceWithConnectionString)queue.Resource).GetConnectionStringAsync());
359storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
364string? connectionString = await ((IResourceWithConnectionString)queues.Resource).GetConnectionStringAsync();
367Assert.Equal(expected, await ((IResourceWithConnectionString)queue.Resource).GetConnectionStringAsync());
379Assert.Equal("Endpoint={storage.outputs.queueEndpoint};QueueName=myqueue", queue.Resource.ConnectionStringExpression.ValueExpression);
394var manifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
411Assert.True(storage.Resource.IsContainer());
418=> new(storage.Resource, new EndpointAnnotation(ProtocolType.Tcp, name: name, targetPort: port));
424Assert.Equal(blobqs, blob.Resource.ConnectionStringExpression.ValueExpression);
425Assert.Equal(queueqs, queue.Resource.ConnectionStringExpression.ValueExpression);
426Assert.Equal(tableqs, table.Resource.ConnectionStringExpression.ValueExpression);
433Assert.Equal(Resolve(blobqs, "blob", 10000), await ((IResourceWithConnectionString)blob.Resource).GetConnectionStringAsync());
434Assert.Equal(Resolve(queueqs, "queue", 10001), await ((IResourceWithConnectionString)queue.Resource).GetConnectionStringAsync());
435Assert.Equal(Resolve(tableqs, "table", 10002), await ((IResourceWithConnectionString)table.Resource).GetConnectionStringAsync());
454storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
455storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
456storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
459Assert.Equal("storage", storage.Resource.Name);
461var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
479var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
488var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
494var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
503var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
509var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
518var tableManifest = await ManifestUtils.GetManifest(table.Resource);
539storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
540storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
541storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
544Assert.Equal("storage", storage.Resource.Name);
546var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
564var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
573var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
579var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
588var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
594var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
603var tableManifest = await ManifestUtils.GetManifest(table.Resource);
627storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
628storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
629storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
632Assert.Equal("storage", storage.Resource.Name);
636var storageManifest = await GetManifestWithBicep(model, storage.Resource);
702var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
711var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
715var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
724var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
728var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
737var tableManifest = await ManifestUtils.GetManifest(table.Resource);
758storage.Resource.Outputs["blobEndpoint"] = "https://myblob";
759storage.Resource.Outputs["queueEndpoint"] = "https://myqueue";
760storage.Resource.Outputs["tableEndpoint"] = "https://mytable";
763Assert.Equal("storage", storage.Resource.Name);
765var storageManifest = await AzureManifestUtils.GetManifestWithBicep(storage.Resource);
784var connectionStringBlobResource = (IResourceWithConnectionString)blob.Resource;
793var blobManifest = await ManifestUtils.GetManifest(blob.Resource);
799var connectionStringQueueResource = (IResourceWithConnectionString)queue.Resource;
808var queueManifest = await ManifestUtils.GetManifest(queue.Resource);
814var connectionStringTableResource = (IResourceWithConnectionString)table.Resource;
823var tableManifest = await ManifestUtils.GetManifest(table.Resource);
850Assert.Equal("storage-blobs", blobService.Resource.Name);
851Assert.Equal(blobService.Resource, blobStorageResource);
877Assert.Equal("storage-queues", queueService.Resource.Name);
878Assert.Equal(queueService.Resource, queueStorageResource);
889Assert.True(storage.Resource.IsEmulator());
890Assert.Contains(storage.Resource.Annotations, a => a is EmulatorResourceAnnotation);
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)
16Assert.Equal("redis-stack", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
24Assert.Equal("redis-stack", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
25Assert.Equal("1.0.0", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
33container.Resource.Annotations.RemoveAt(0);
36Assert.Equal("new-image", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Image);
37Assert.Equal("latest", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
45container.Resource.Annotations.Add(new ContainerImageAnnotation { Image = "another-image" });
48Assert.Equal("new-image", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Last().Image);
49Assert.Equal("latest", container.Resource.Annotations.OfType<ContainerImageAnnotation>().Last().Tag);
57Assert.Equal("7.1", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Tag);
65Assert.Equal("myregistry.azurecr.io", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().Registry);
73Assert.Equal("42b5c726e719639fcc1e9dbc13dd843f567dcd37911d0e1abb9f47f2cc1c95cd", redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single().SHA256);
151var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
163var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
176var annotation = redis.Resource.Annotations.OfType<ContainerImageAnnotation>().Single();
212var annotation = redis.Resource.Annotations.OfType<ContainerImagePullPolicyAnnotation>().Single();
220var 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.GitHub.Models (12)
Aspire.Hosting.GitHub.Models.Tests (33)
GitHubModelsExtensionTests.cs (33)
20Assert.Equal("github", github.Resource.Name);
21Assert.Equal("openai/gpt-4o-mini", github.Resource.Model);
32Assert.NotNull(github.Resource.Key);
33Assert.Equal("mymodel-gh-apikey", github.Resource.Key.Name);
34Assert.True(github.Resource.Key.Secret);
45var connectionString = github.Resource.ConnectionStringExpression.ValueExpression;
57var connectionString = github.Resource.ConnectionStringExpression.ValueExpression;
78var connectionString = await github.Resource.ConnectionStringExpression.GetValueAsync(default);
80Assert.Equal(apiKeyParameter.Resource, github.Resource.Key);
91Assert.NotNull(github.Resource.Key);
92Assert.Equal("github-gh-apikey", github.Resource.Key.Name);
93Assert.True(github.Resource.Key.Secret);
104Assert.Null(github.Resource.Organization);
118Assert.NotNull(github.Resource.Organization);
119Assert.Equal("github-org", github.Resource.Organization.Name);
120Assert.Equal(orgParameter.Resource, github.Resource.Organization);
134var connectionString = github.Resource.ConnectionStringExpression.ValueExpression;
154var connectionString = await github.Resource.ConnectionStringExpression.GetValueAsync(default);
169var connectionString = github.Resource.ConnectionStringExpression.ValueExpression;
188var resource = new GitHubModelResource("test", "openai/gpt-4o-mini", orgParameter.Resource, apiKeyParameter.Resource);
192Assert.Equal(orgParameter.Resource, resource.Organization);
193Assert.Equal(apiKeyParameter.Resource, resource.Key);
204var resource = new GitHubModelResource("test", "openai/gpt-4o-mini", null, apiKeyParameter.Resource);
209Assert.Equal(apiKeyParameter.Resource, resource.Key);
223var resource = new GitHubModelResource("test", "openai/gpt-4o-mini", null, apiKeyParameter.Resource);
226resource.Organization = orgParameter.Resource;
227Assert.Equal(orgParameter.Resource, resource.Organization);
255Assert.Equal(apiKey.Resource, github.Resource.Key);
287var healthCheckAnnotations = github.Resource.Annotations.OfType<HealthCheckAnnotation>().ToList();
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)
22Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName);
32Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName);
159var mySqlManifest = await ManifestUtils.GetManifest(mysql.Resource);
160var dbManifest = await ManifestUtils.GetManifest(db.Resource);
198var serverManifest = await ManifestUtils.GetManifest(mysql.Resource);
250Assert.Equal($"{mysql.Resource.Name}:{mysql.Resource.PrimaryEndpoint.TargetPort}", config["PMA_HOST"]);
282string pattern1 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql1.Resource.Name}:{mysql1.Resource.PrimaryEndpoint.TargetPort}';";
283string pattern2 = $@"\$cfg\['Servers'\]\[\$i\]\['host'\] = '{mysql2.Resource.Name}:{mysql2.Resource.PrimaryEndpoint.TargetPort}';";
323Assert.Equal(["db1", "db2"], mysql1.Resource.Databases.Keys);
324Assert.Equal(["customers1", "customers2"], mysql1.Resource.Databases.Values);
326Assert.Equal("customers1", db1.Resource.DatabaseName);
327Assert.Equal("customers2", db2.Resource.DatabaseName);
329Assert.Equal("{mysql1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
330Assert.Equal("{mysql1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
344Assert.Equal("imports", db1.Resource.DatabaseName);
345Assert.Equal("imports", db2.Resource.DatabaseName);
347Assert.Equal("{mysql1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
348Assert.Equal("{mysql2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
MySqlFunctionalTests.cs (40)
49await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
55await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
57await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
90[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
93hb.AddMySqlDataSource(db.Resource.Name);
133var password = mysql1.Resource.PasswordParameter.Value;
166[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default)
169hb.AddMySqlDataSource(db1.Resource.Name);
235[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
238hb.AddMySqlDataSource(db2.Resource.Name);
338[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
341hb.AddMySqlDataSource(db.Resource.Name);
424[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
427hb.AddMySqlDataSource(db.Resource.Name);
494[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token)
497hb.AddMySqlDbContext<TestDbContext>(db.Resource.Name);
651hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
653hb.AddMySqlDataSource(newDb.Resource.Name);
659await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
726hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
728hb.AddMySqlDataSource(newDb.Resource.Name);
734await app.ResourceNotifications.WaitForResourceHealthyAsync(mysql.Resource.Name, cts.Token);
785hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
786hb.AddKeyedMySqlDataSource(db.Resource.Name);
795await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
797var conn = host.Services.GetRequiredKeyedService<MySqlConnection>(db.Resource.Name);
827hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
828hb.AddMySqlDataSource(newDb.Resource.Name);
833await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
Aspire.Hosting.Nats (2)
Aspire.Hosting.Nats.Tests (33)
NatsFunctionalTests.cs (19)
35await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
39hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
80await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
84var connectionString = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
85hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = connectionString;
122await app.WaitForTextAsync("Listening for client connections", nats.Resource.Name);
126var connectionString = await nats.Resource.ConnectionStringExpression.GetValueAsync(default);
131hb.Configuration[$"ConnectionStrings:{nats.Resource.Name}"] = modifiedConnectionString;
184await app.WaitForTextAsync("Listening for client connections", nats1.Resource.Name);
189hb.Configuration[$"ConnectionStrings:{nats1.Resource.Name}"] = await nats1.Resource.ConnectionStringExpression.GetValueAsync(default);
232await app.WaitForTextAsync("Listening for client connections", nats2.Resource.Name);
237hb.Configuration[$"ConnectionStrings:{nats2.Resource.Name}"] = await nats2.Resource.ConnectionStringExpression.GetValueAsync(default);
342await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
344await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
348await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
350await 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)
21Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", orcl.Resource.PasswordParameter.Default?.GetType().FullName);
31Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", orcl.Resource.PasswordParameter.Default?.GetType().FullName);
199var serverManifest = await ManifestUtils.GetManifest(oracleServer.Resource);
200var dbManifest = await ManifestUtils.GetManifest(db.Resource);
238var serverManifest = await ManifestUtils.GetManifest(oracleServer.Resource);
294Assert.Equal("customers1", db1.Resource.DatabaseName);
295Assert.Equal("customers2", db2.Resource.DatabaseName);
297Assert.Equal("{oracle1.connectionString}/customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
298Assert.Equal("{oracle1.connectionString}/customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
312Assert.Equal("imports", db1.Resource.DatabaseName);
313Assert.Equal("imports", db2.Resource.DatabaseName);
315Assert.Equal("{oracle1.connectionString}/imports", db1.Resource.ConnectionStringExpression.ValueExpression);
316Assert.Equal("{oracle2.connectionString}/imports", db2.Resource.ConnectionStringExpression.ValueExpression);
Aspire.Hosting.Orleans (7)
Aspire.Hosting.PostgreSQL (10)
Aspire.Hosting.PostgreSQL.Tests (75)
AddPostgresTests.cs (27)
21Assert.Single(redis.Resource.Annotations, a => a is HealthCheckAnnotation hca && hca.Key == "postgres_check");
31Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", pg.Resource.PasswordParameter.Default?.GetType().FullName);
41Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", pg.Resource.PasswordParameter.Default?.GetType().FullName);
157var connectionStringResource = postgres.Resource as IResourceWithConnectionString;
162Assert.Equal($"Host=localhost;Port=2000;Username=postgres;Password={postgres.Resource.PasswordParameter.Value}", connectionString);
250var serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
251var dbManifest = await ManifestUtils.GetManifest(db.Resource);
294var serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
320serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
346serverManifest = await ManifestUtils.GetManifest(pgServer.Resource);
489Assert.Equal(pg1.Resource.Name, servers.GetProperty("1").GetProperty("Name").GetString());
497Assert.Equal($"echo '{pg1.Resource.PasswordParameter.Value}'", servers.GetProperty("1").GetProperty("PasswordExecCommand").GetString());
501Assert.Equal(pg2.Resource.Name, servers.GetProperty("2").GetProperty("Name").GetString());
509Assert.Equal($"echo '{pg2.Resource.PasswordParameter.Value}'", servers.GetProperty("2").GetProperty("PasswordExecCommand").GetString());
557Assert.Equal(CreatePgWebBookmarkfileContent(db1.Resource), file.Contents);
564Assert.Equal(CreatePgWebBookmarkfileContent(db2.Resource), file.Contents);
601Assert.Equal("customers1", db1.Resource.DatabaseName);
602Assert.Equal("customers2", db2.Resource.DatabaseName);
604Assert.Equal("{postgres1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
605Assert.Equal("{postgres1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
619Assert.Equal("imports", db1.Resource.DatabaseName);
620Assert.Equal("imports", db2.Resource.DatabaseName);
622Assert.Equal("{postgres1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
623Assert.Equal("{postgres2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
668var connectionString = await postgres.Resource.GetConnectionStringAsync();
682var connectionString = await postgres.Resource.GetConnectionStringAsync();
684Assert.Equal($"Host=localhost;Port=2000;Username=user1;Password={postgres.Resource.PasswordParameter.Value}", connectionString);
PostgresFunctionalTests.cs (45)
52await app.ResourceNotifications.WaitForResourceAsync(postgres.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
61await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
64await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
86await app.WaitForTextAsync("Listening at", resourceName: adminBuilder.Resource.Name);
88var client = app.CreateHttpClient(adminBuilder.Resource.Name, "http");
119[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
122hb.AddNpgsqlDataSource(db.Resource.Name);
128await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token);
165var client = app.CreateHttpClient(pgWebBuilder.Resource.Name, "http");
167await app.ResourceNotifications.WaitForResourceHealthyAsync(pgWebBuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
233await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token);
241[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default)
244hb.AddNpgsqlDataSource(db1.Resource.Name);
295await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token);
303[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default)
306hb.AddNpgsqlDataSource(db2.Resource.Name);
398[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
401hb.AddNpgsqlDataSource(db.Resource.Name);
407await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
484[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default)
487hb.AddNpgsqlDataSource(db.Resource.Name);
493await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
611hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
613hb.AddNpgsqlDataSource(newDb.Resource.Name);
619await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
652hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
654hb.AddNpgsqlDataSource(newDb.Resource.Name);
660await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
721hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
723hb.AddNpgsqlDataSource(newDb.Resource.Name);
729await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token);
780hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
781hb.AddKeyedNpgsqlDataSource(db.Resource.Name);
790await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
792var 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)
19Assert.Single(redis.Resource.Annotations, a => a is HealthCheckAnnotation hca && hca.Key == "redis_check");
135var manifest = await ManifestUtils.GetManifest(redis.Resource);
169var manifest = await ManifestUtils.GetManifest(redis.Resource);
204var manifest = await ManifestUtils.GetManifest(redis.Resource);
239var manifest = await ManifestUtils.GetManifest(redis.Resource);
309Assert.Equal(redis1.Resource.Name, item.Value);
314Assert.Equal($"{redis1.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
319Assert.Equal(redis1.Resource.Name, item.Value);
325Assert.Equal(redis1.Resource.PasswordParameter!.Value, item.Value);
331Assert.Equal(redis2.Resource.Name, item.Value);
336Assert.Equal($"{redis2.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
341Assert.Equal(redis2.Resource.Name, item.Value);
347Assert.Equal(redis2.Resource.PasswordParameter!.Value, item.Value);
353Assert.Equal(redis3.Resource.Name, item.Value);
358Assert.Equal($"{redis3.Resource.PrimaryEndpoint.TargetPort!.Value}", item.Value);
363Assert.Equal(redis3.Resource.Name, item.Value);
504Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{redis.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]);
526Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0:{password}", config["REDIS_HOSTS"]);
551Assert.Equal($"myredis1:{redis1.Resource.Name}:6379:0:{redis1.Resource.PasswordParameter?.Value},myredis2:myredis2:6379:0:{redis2.Resource.PasswordParameter?.Value}", config["REDIS_HOSTS"]);
572var volumeAnnotation = redis.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
597var volumeAnnotation = redis.Resource.Annotations.OfType<ContainerMountAnnotation>().Single();
667var args = await ArgumentEvaluator.GetArgumentListAsync(builder.Resource);
678Assert.True(redis.Resource.TryGetAnnotationsOfType<CommandLineArgsCallbackAnnotation>(out var argsAnnotations));
RedisFunctionalTests.cs (44)
51await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
57await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
59await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
80await app.WaitForTextAsync("Redis Connection", resourceName: commanderBuilder.Resource.Name);
82var client = app.CreateHttpClient(commanderBuilder.Resource.Name, "http");
85var path = $"/apiv2/server/R:{redis.Resource.Name}:{endpoint.TargetPort}:0/info";
106[$"ConnectionStrings:{redis.Resource.Name}"] = await redis.Resource.GetConnectionStringAsync()
109hb.AddRedisClient(redis.Resource.Name);
145await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
147var client = app.CreateHttpClient(redisInsightBuilder.Resource.Name, "http");
163Assert.Equal(redis1.Resource.Name, db.Name);
164Assert.Equal(redis1.Resource.Name, db.Host);
165Assert.Equal(redis1.Resource.PrimaryEndpoint.TargetPort, db.Port);
169Assert.Equal(redis2.Resource.Name, db.Name);
170Assert.Equal(redis2.Resource.Name, db.Host);
171Assert.Equal(redis2.Resource.PrimaryEndpoint.TargetPort, db.Port);
175Assert.Equal(redis3.Resource.Name, db.Name);
176Assert.Equal(redis3.Resource.Name, db.Host);
177Assert.Equal(redis3.Resource.PrimaryEndpoint.TargetPort, db.Port);
212[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
215hb.AddRedisClient(redis1.Resource.Name);
248[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
251hb.AddRedisClient(redis2.Resource.Name);
295[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
298hb.AddRedisClient(redis1.Resource.Name);
330[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
333hb.AddRedisClient(redis2.Resource.Name);
379[$"ConnectionStrings:{redis1.Resource.Name}"] = $"{await redis1.Resource.GetConnectionStringAsync()},allowAdmin=true"
382hb.AddRedisClient(redis1.Resource.Name);
409[$"ConnectionStrings:{redis2.Resource.Name}"] = await redis2.Resource.GetConnectionStringAsync()
412hb.AddRedisClient(redis2.Resource.Name);
477await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
481var httpClient = app.CreateHttpClient(redisInsightBuilder1.Resource.Name, "http");
512await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token);
516var httpClient = app.CreateHttpClient(redisInsightBuilder2.Resource.Name, "http");
615await 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)
21Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName);
31Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName);
129var serverManifest = await ManifestUtils.GetManifest(sqlServer.Resource);
130var dbManifest = await ManifestUtils.GetManifest(db.Resource);
170var serverManifest = await ManifestUtils.GetManifest(sqlServer.Resource);
227Assert.Equal("customers1", db1.Resource.DatabaseName);
228Assert.Equal("customers2", db2.Resource.DatabaseName);
230Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
231Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
245Assert.Equal("imports", db1.Resource.DatabaseName);
246Assert.Equal("imports", db2.Resource.DatabaseName);
248Assert.Equal("{sqlserver1.connectionString};Initial Catalog=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
249Assert.Equal("{sqlserver2.connectionString};Initial Catalog=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
SqlServerFunctionalTests.cs (34)
43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token);
45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token);
49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token);
51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
80hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
82hb.AddSqlServerDbContext<TestDbContext>(newDb.Resource.Name);
83hb.AddSqlServerClient(newDb.Resource.Name);
142var password = sqlserver1.Resource.PasswordParameter.Value;
180await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token);
188[$"ConnectionStrings:{db1.Resource.Name}"] = await db1.Resource.ConnectionStringExpression.GetValueAsync(default),
191hb1.AddSqlServerClient(db1.Resource.Name);
265await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token);
273[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(default),
276hb2.AddSqlServerClient(db2.Resource.Name);
369hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
371hb.AddSqlServerClient(newDb.Resource.Name);
377await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
422hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
424hb.AddSqlServerClient(newDb.Resource.Name);
430await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token);
494hb.Configuration[$"ConnectionStrings:{newDb.Resource.Name}"] = await newDb.Resource.ConnectionStringExpression.GetValueAsync(default);
496hb.AddSqlServerClient(newDb.Resource.Name);
502await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token);
554hb.Configuration[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(default);
555hb.AddKeyedSqlServerClient(db.Resource.Name);
564await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token);
566var conn = host.Services.GetRequiredKeyedService<SqlConnection>(db.Resource.Name);
Aspire.Hosting.Testing.Tests (1)
Aspire.Hosting.Tests (444)
DistributedApplicationTests.cs (12)
475using var clientA = app.CreateHttpClient(testProgram.ServiceABuilder.Resource.Name, "http");
476using var clientC = app.CreateHttpClient(testProgram.ServiceCBuilder.Resource.Name, "http");
483var uri = app.GetEndpoint(testProgram.ServiceBBuilder.Resource.Name, "http");
1104await app.WaitForTextAsync("Content root path:", resourceName: testProgram.ServiceABuilder.Resource.Name).DefaultTimeout(TestConstants.LongTimeoutDuration);
1107var httpEndPoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "http");
1125var httpsEndpoint = app.GetEndpoint(testProgram.ServiceABuilder.Resource.Name, endpointName: "https");
1173using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");
1182Assert.Equal($"localhost:1234,password={redis.Resource.PasswordParameter?.Value}", env.Value);
1191Assert.Equal($"localhost:6379,password={redisNoPort.Resource.PasswordParameter?.Value}", otherRedisEnv.Value);
1227using var clientA = app.CreateHttpClient(servicea.Resource.Name, "http");
1240Assert.Equal($"localhost:1234,password={redis.Resource.PasswordParameter!.Value}", env.Value);
1249Assert.Equal($"localhost:6379,password={redisNoPort.Resource.PasswordParameter!.Value}", otherRedisEnv.Value);
ExpressionResolverTests.cs (5)
97var csRef = new ConnectionStringReference(target.Resource, false);
109var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(source.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
143var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(test.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
162var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(test.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
183var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(dep.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance, "ContainerHostName").DefaultTimeout();
ExternalServiceTests.cs (35)
21Assert.Equal("nuget", externalService.Resource.Name);
22Assert.Equal("https://nuget.org/", externalService.Resource.Uri?.ToString());
23Assert.Null(externalService.Resource.UrlParameter);
34Assert.Equal("nuget", externalService.Resource.Name);
35Assert.Equal("https://nuget.org/", externalService.Resource.Uri?.ToString());
36Assert.Null(externalService.Resource.UrlParameter);
47Assert.Equal("nuget", externalService.Resource.Name);
48Assert.Null(externalService.Resource.Uri);
49Assert.NotNull(externalService.Resource.UrlParameter);
50Assert.Equal("nuget-url", externalService.Resource.UrlParameter.Name);
97Assert.Equal("nuget", externalService.Resource.Name);
98Assert.Equal(validUrl, externalService.Resource.Uri?.ToString());
111var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
127var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
145var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
167var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Publish, app.Services).DefaultTimeout();
172Assert.Equal(urlParam.Resource.ValueExpression, urlValue);
189await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
205Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
206Assert.NotNull(healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external")));
221Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
222Assert.NotNull(healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external")));
244Assert.True(externalService.Resource.TryGetAnnotationsOfType<ResourceSnapshotAnnotation>(out var snapshotAnnotations));
257Assert.IsAssignableFrom<IResourceWithoutLifetime>(externalService.Resource);
269Assert.True(externalService.Resource.TryGetAnnotationsOfType<ManifestPublishingCallbackAnnotation>(out var manifestAnnotations));
309externalService.Resource.Name,
336externalService.Resource.Name,
363externalService.Resource.Name,
387Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
388var healthCheckAnnotation = healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external"));
408Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
409var healthCheckAnnotation = healthCheckAnnotations.FirstOrDefault(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external"));
433Assert.True(externalService.Resource.TryGetAnnotationsOfType<HealthCheckAnnotation>(out var healthCheckAnnotations));
434var healthCheckKey = healthCheckAnnotations.First(hc => hc.Key.StartsWith($"{externalService.Resource.Name}_external")).Key;
458var manifest = await ManifestUtils.GetManifest(project.Resource);
Health\ResourceHealthCheckServiceTests.cs (30)
32await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
40await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
72await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
80await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
115await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
123await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
162await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
171Assert.Equal(resource.Resource, e1.Resource);
177await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
185await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
199Assert.Equal(resource.Resource, e2.Resource);
228await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
232await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout();
269await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
312await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
316await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout();
348await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
354Assert.Equal(resource.Resource, @event.Resource);
379await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
441await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
486await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
526var child = builder.AddResource(new ChildResource("child", parent.Resource))
537await app.ResourceNotifications.PublishUpdateAsync(parent.Resource, s => s with
545await app.ResourceNotifications.PublishUpdateAsync(child.Resource, s => s with
551Assert.Equal(parentReadyEvent.Resource, parent.Resource);
554Assert.Equal(childReadyEvent.Resource, child.Resource);
581await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
589await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
627await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
635await app.ResourceNotifications.PublishUpdateAsync(resource.Resource, s => s with
Orchestrator\ApplicationOrchestratorTests.cs (25)
24var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
41if (item.Resource == parentResource.Resource)
45else if (item.Resource == childResource.Resource)
88if (item.Resource == parentResource.Resource)
92else if (item.Resource == childResource.Resource)
134applicationEventing.Subscribe<InitializeResourceEvent>(resource.Resource, (@event, ct) =>
152Assert.Equal(resource.Resource, initEvent.Resource);
186if (item.Resource == parent.Resource)
190else if (item.Resource == child.Resource)
195else if (item.Resource == nestedChild.Resource)
199else if (item.Resource == child2.Resource)
251if (item.Resource == firstParent.Resource)
255else if (item.Resource == secondParent.Resource)
259else if (item.Resource == child.Resource)
302if (item.Resource == projectA.Resource)
306else if (item.Resource == projectB.Resource)
351new ChildResourceWithConnectionString("child", new Dictionary<string, string> { {"Namespace", "ns"} }, parentResource.Resource)
354new ChildResourceWithConnectionString("grand-child", new Dictionary<string, string> { {"Database", "db"} }, childResource.Resource)
371applicationEventing.Subscribe<ConnectionStringAvailableEvent>(parentResource.Resource, (_, _) =>
376applicationEventing.Subscribe<ConnectionStringAvailableEvent>(childResource.Resource, (_, _) =>
381applicationEventing.Subscribe<ConnectionStringAvailableEvent>(grandChildResource.Resource, (_, _) =>
387await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parentResource.Resource, parentResource.Resource.Name));
417if (item.Resource == resource.Resource)
431await applicationEventing.PublishAsync(new ConnectionStringAvailableEvent(resource.Resource, app.Services), CancellationToken.None);
Orchestrator\RelationshipEvaluatorTests.cs (14)
17var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
18var grandChildResource = builder.AddResource(new CustomChildResource("grandchild", childResource.Resource));
19var greatGrandChildResource = builder.AddResource(new CustomChildResource("greatgrandchild", grandChildResource.Resource));
33Assert.Collection(parentChildLookup[parentResource.Resource],
34x => Assert.Equal(childResource.Resource, x),
35x => Assert.Equal(childWithAnnotationsResource.Resource, x));
37Assert.Single(parentChildLookup[childResource.Resource], grandChildResource.Resource);
38Assert.Single(parentChildLookup[grandChildResource.Resource], greatGrandChildResource.Resource);
40Assert.Empty(parentChildLookup[greatGrandChildResource.Resource]);
42Assert.Single(parentChildLookup[childWithAnnotationsResource.Resource], grandChildWithAnnotationsResource.Resource);
44Assert.Empty(parentChildLookup[grandChildWithAnnotationsResource.Resource]);
Publishing\ResourceContainerImageBuilderTests.cs (13)
36await imageBuilder.BuildImageAsync(servicea.Resource, options: null, cts.Token);
66await imageBuilder.BuildImageAsync(servicea.Resource, options: null, cts.Token);
104await imageBuilder.BuildImageAsync(servicea.Resource, options, cts.Token);
142await imageBuilder.BuildImageAsync(servicea.Resource, options, cts.Token);
176await imageBuilder.BuildImageAsync(servicea.Resource, options, cts.Token);
213await imageBuilder.BuildImageAsync(container.Resource, options, cts.Token);
253await imageBuilder.BuildImageAsync(container.Resource, options, cts.Token);
292await imageBuilder.BuildImageAsync(servicea.Resource, options, cts.Token);
328await imageBuilder.BuildImageAsync(servicea.Resource, options, cts.Token);
359await imageBuilder.BuildImageAsync(servicea.Resource, options: null, cts.Token);
410await imageBuilder.BuildImagesAsync([servicea.Resource], options: options, cts.Token);
439await imageBuilder.BuildImagesAsync([dockerfileResource.Resource], options: null, cts.Token);
467imageBuilder.BuildImagesAsync([container.Resource], options: null, cts.Token));
WaitForTests.cs (60)
31await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
32await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
33await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token);
64var childResourceBuilder = builder.AddResource(new CustomChildResource("child", parentResourceBuilder.Resource));
106await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
108await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
137await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
139await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
174await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
179await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
215await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
217await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
222await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token);
243dependency.Resource.Name,
267dependency.Resource.Name,
297await app.ResourceNotifications.WaitForResourceHealthyAsync(dependency.Resource.Name)
326await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
328await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
333await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token);
360await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
362await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
367await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
370await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
375await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
407await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
409await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
414await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
417await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
422await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
452await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
457await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
467await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token);
499await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token);
504await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
514await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
554await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token);
559await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
570await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
608await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
613await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
622await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token);
659await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
662await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test0", s => s with
667await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
670await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test1", s => s with
675await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
712await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
715await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test0", s => s with
720await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
723await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, "test1", s => s with
728await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
761await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token);
764await app.ResourceNotifications.PublishUpdateAsync(dependency.Resource, s => s with
769await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
781var childResource = builder.AddResource(new CustomChildResource("child", parentResource.Resource));
785Assert.True(containerResource.Resource.TryGetAnnotationsOfType<WaitAnnotation>(out var waitAnnotations));
788a => Assert.Equal(a.Resource, parentResource.Resource),
789a => Assert.Equal(a.Resource, childResource.Resource)
792Assert.True(containerResource.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationshipAnnotations));
795Assert.Equal(childResource.Resource, relationshipAnnotation.Resource);
WithEnvironmentTests.cs (37)
32container.Resource,
54var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
58Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
63Assert.Same(projectA.Resource, r.Resource);
75var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
91var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(project.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
107var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
124var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
128Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
133Assert.Same(parameter.Resource, r.Resource);
147var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource,
164projectA.Resource,
189var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
213var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectA.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
238.WithEnvironment("HOST", $"{test.Resource};name=1");
240var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource).DefaultTimeout();
241var manifestConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
255Assert.True(containerB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
260Assert.Same(container.Resource, r.Resource);
265Assert.Same(test.Resource, r.Resource);
286Assert.True(containerB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
291Assert.Same(container.Resource, r.Resource);
312var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(containerB.Resource).DefaultTimeout();
336var runConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(targetBuilder.Resource, DistributedApplicationOperation.Run).DefaultTimeout();
342var publishConfig = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(targetBuilder.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
347Assert.True(targetBuilder.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
352Assert.Same(sourceBuilder.Resource, r.Resource);
367projectA.Resource,
375projectA.Resource,
388var testValue = new TestValueWithReferences("test-value", resourceA.Resource);
394Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
397Assert.Same(resourceA.Resource, relationship.Resource);
401projectA.Resource,
448projectA.Resource,
456projectA.Resource,
463Assert.True(projectA.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
466Assert.Same(container.Resource, relationship.Resource);
WithHttpCommandTests.cs (19)
88var command = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().FirstOrDefault();
94Assert.Equal($"{resourceBuilder.Resource.Name}-http-http-post-/some-path", command.Name);
121var command = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().FirstOrDefault();
151var commands = resourceBuilder.Resource.Annotations.OfType<ResourceCommandAnnotation>().ToList();
190var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
214var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
237var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
276var result = await app.ResourceCommands.ExecuteCommandAsync(serviceB.Resource, "mycommand");
314resolvedResourceName = resourceBuilder.Resource.GetResolvedResourceNames().Single();
316var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
355resolvedResourceName = resourceBuilder.Resource.GetResolvedResourceNames().Single();
357var result = await app.ResourceCommands.ExecuteCommandAsync(resourceBuilder.Resource, "mycommand");
399await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
403await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Starting).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
409await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
413await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
469await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
473await app.ResourceNotifications.WaitForResourceAsync(service.Resource.Name, KnownResourceStates.Running).DefaultTimeout(TestConstants.LongTimeoutTimeSpan);
480await app.ResourceNotifications.PublishUpdateAsync(service.Resource, s => s with
WithReferenceTests.cs (27)
28var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
32Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
37Assert.Same(projectA.Resource, r.Resource);
59var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
84var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
107var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
112Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
117Assert.Same(projectA.Resource, r.Resource);
136var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
141Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
146Assert.Same(projectA.Resource, r.Resource);
162await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
176var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
195var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance);
214var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
230var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
246var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Publish).DefaultTimeout();
265var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
289var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
295Assert.True(projectB.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var relationships));
300Assert.Same(resource.Resource, r.Resource);
303Assert.True(resource.Resource.TryGetAnnotationsOfType<ResourceRelationshipAnnotation>(out var csRelationships));
308Assert.Same(endpoint.Resource, r.Resource);
313Assert.Same(key.Resource, r.Resource);
335var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
357var config = await EnvironmentVariableEvaluator.GetEnvironmentVariablesAsync(projectB.Resource, DistributedApplicationOperation.Run, TestServiceProvider.Instance).DefaultTimeout();
389var 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)