Name

ApplicationModel\EndpointAnnotation.cs (1)

ExpressionResolverTests.cs (1)

ApplicationModel\EndpointAnnotation.cs (1)

367AllocatedEndpointSnapshot.SetException(new InvalidOperationException($"The endpoint `{Name}` is not allocated"));

ApplicationModel\EndpointReference.cs (3)

30.Select(a => a.Name) 232.SingleOrDefault(a => string.Equals(a.Name, EndpointName, StringComparisons.EndpointAnnotationName)); 268EndpointName = endpoint.Name;

ApplicationModel\EndpointUpdateContext.cs (1)

19public string Name => _endpointAnnotation.Name;

ApplicationModel\HostUrl.cs (1)

73return r.GetEndpoint(ep.Name, networkContext);

ApplicationModel\IComputeEnvironmentResource.cs (2)

64_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 80throw new InvalidOperationException($"Endpoint '{endpoint.Name}' must specify a port for scheme '{scheme}'.");

ApplicationModel\ResourceExtensions.cs (2)

793endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName)) : 817endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName)) :

Ats\CoreExports.cs (1)

202endpoint => includedEndpointNames.Contains(endpoint.Name));

Dcp\ContainerCreator.cs (5)

433resourceLogger.LogWarning("Host endpoint '{EndpointName}' on resource '{HostResource}' is referenced by a container resource, but the endpoint is using a network protocol '{Protocol}' other than TCP. Only TCP is supported for container-to-host references.", endpoint.Name, re.Resource.Name, endpoint.Protocol); 443StringComparers.EndpointAnnotationName.Equals(swr.EndpointAnnotation.Name, endpoint.Name) 447throw new InvalidDataException($"Host endpoint '{endpoint.Name}' on resource '{re.Resource.Name}' should have an associated DCP Service resource already set up"); 464svc.Annotate(CustomResource.EndpointNameAnnotation, endpoint.Name);

Dcp\DcpExecutor.cs (7)

688_logger.LogWarning("Encountered the same service-endpoint combination more than once for {EndpointName} on resource {ResourceName} when creating default endpoint services. This should never happen.", endpoint.Name, sp.ModelResource.Name); 718svc.Annotate(CustomResource.EndpointNameAnnotation, endpoint.Name); 813_logger.LogDebug("Using persisted public port {Port} for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'.", persistedPort, endpoint.Name, resource.Name); 818_logger.LogDebug("Allocated public port {Port} for proxyless endpoint '{EndpointName}' on resource '{ResourceName}'.", publicPort, endpoint.Name, resource.Name); 825_logger.LogWarning("Failed to persist public port {Port} for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'. Enable user secrets, set a fixed public port, or configure the endpoint to use a proxy to avoid recreating the persistent resource each run.", publicPort, endpoint.Name, resource.Name); 865_logger.LogDebug("Ignoring invalid persisted public port value '{Port}' for proxyless endpoint '{EndpointName}' on persistent resource '{ResourceName}'.", configuredPort, endpoint.Name, resource.Name); 873return $"Resources:{resource.Name}:{endpoint.Name}:port";

Dcp\DcpModelUtilities.cs (10)

39throw new InvalidOperationException($"The endpoint '{endpoint.Name}' for container resource '{modelResourceName}' must specify the {nameof(EndpointAnnotation.TargetPort)} value"); 44throw new InvalidOperationException($"The endpoint '{endpoint.Name}' for resource '{modelResourceName}' is not using a proxy, and it has a value of {nameof(EndpointAnnotation.Port)} property that is different from the value of {nameof(EndpointAnnotation.TargetPort)} property. For proxy-less endpoints they must match."); 71throw new InvalidOperationException($"Resource '{modelResourceName}' uses multiple replicas and a proxy-less endpoint '{ea.Name}'. These features do not work together."); 81$"The endpoint '{ea.Name}' for resource '{modelResourceName}' requested a proxy ({nameof(ea.IsProxied)} is true). Non-container resources cannot be proxied when both {nameof(ea.TargetPort)} and {nameof(ea.Port)} are specified with the same value."); 87$"Resource '{modelResourceName}' can have multiple replicas, and it uses endpoint '{ea.Name}' that has {nameof(ea.TargetPort)} property set. Each replica must have a unique port; setting {nameof(ea.TargetPort)} is not allowed."); 191throw new InvalidOperationException($"Service '{svc.Metadata.Name}' needs to specify a port for endpoint '{sp.EndpointAnnotation.Name}' since it isn't using a proxy."); 311string.Equals(swr.EndpointAnnotation.Name, endpoint.Name, StringComparisons.EndpointAnnotationName) 316throw new InvalidDataException($"The '{endpoint.Name}' on resource '{ts.ResourceName}' should have an associated DCP Service resource already set up"); 341endpoint = endpoints.FirstOrDefault(e => string.Equals(e.Name, endpointName, StringComparisons.EndpointAnnotationName));

Dcp\DcpNameGenerator.cs (2)

123: GetObjectNameForResource(resource, _options.Value, endpoint.Name); 177=> $"{resource.Name}|{endpoint.Name}|{targetNetworkId.Value}";

Devcontainers\DevcontainerPortForwardingEventingSubscriber.cs (1)

47$"{@event.Resource.Name}-{endpoint.Name}");

Orchestrator\ApplicationOrchestrator.cs (7)

326_logger.LogTrace("Setting primary launch profile endpoint to '{EndpointName}' for resource '{ResourceName}'.", endpoint.Name, resource.Name); 418_logger.LogTrace("Added URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", url.Url, endpoint.Name, resource.Name); 425_logger.LogTrace("Added additional URL '{Url}' for endpoint '{EndpointName}' on resource '{ResourceName}'.", additionalUrl.Url, endpoint.Name, resource.Name); 483var primaryUrl = urls.FirstOrDefault(u => string.Equals(u.Endpoint?.EndpointName, primaryLaunchProfileEndpoint.Name, StringComparisons.EndpointAnnotationName)); 494_logger.LogTrace("Applying path '{Path}' from URL '{Url}' for primary launch profile endpoint '{EndpointName}' to other launch profile endpoints for resource '{ResourceName}'.", primaryPath, primaryUrl.Url, primaryLaunchProfileEndpoint.Name, resource.Name); 519_logger.LogTrace("URL '{Url}' for primary launch profile endpoint '{EndpointName}' for resource '{ResourceName}' does not have a path to apply to other launch profile endpoints.", primaryUrl.Url, primaryLaunchProfileEndpoint.Name, resource.Name); 527_logger.LogTrace("Could not find URL for primary launch profile endpoint '{EndpointName}' for resource '{ResourceName}'.", primaryLaunchProfileEndpoint.Name, resource.Name);

ProjectResourceBuilderExtensions.cs (3)

764var url = context.Urls.FirstOrDefault(u => string.Equals(u.Endpoint?.EndpointName, endpoint.Name, StringComparisons.EndpointAnnotationName)); 823projectResource.Annotations.OfType<EndpointAnnotation>().FirstOrDefault(sb => sb.UriScheme == scheme || string.Equals(sb.Name, scheme, StringComparisons.EndpointAnnotationName)); 1199context.EnvironmentVariables[$"Kestrel__Endpoints__{e.EndpointAnnotation.Name}__Url"] = url;

Publishing\ManifestPublishingContext.cs (1)

500Writer.WriteStartObject(endpoint.Name);

ResourceBuilderExtensions.cs (3)

1469.SingleOrDefault(ea => string.Equals(ea.Name, endpointName, StringComparisons.EndpointAnnotationName)); 1534!builder.Resource.Annotations.OfType<EndpointAnnotation>().Any(endpoint => string.Equals(endpoint.Name, endpointName, StringComparisons.EndpointAnnotationName))) 1572.FirstOrDefault(sb => string.Equals(sb.Name, resolvedName, StringComparisons.EndpointAnnotationName));

AzureContainerAppEnvironmentResource.cs (1)

387_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.")

ContainerAppContext.cs (4)

149throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} specify an unsupported transport. The supported transports are 'http', 'http2', and 'tcp'."); 231_endpointMapping[endpoint.Name] = new(scheme, NormalizedContainerAppName, port, targetPort, true, httpIngress.External, endpoint.TlsEnabled); 239.Select(r => r.Endpoint.Name) 263_endpointMapping[endpoint.Name] = new(endpoint.UriScheme, NormalizedContainerAppName, resolved.ExposedPort.Value ?? g.Port.Value, g.Port.Value, false, g.External, endpoint.TlsEnabled);

AzureAppServiceEnvironmentResource.cs (1)

539_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.")

AzureAppServiceWebsiteContext.cs (4)

107throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} on resource '{resource.Name}' specifies an unsupported scheme. Only http and https are supported in App Service."); 130throw new NotSupportedException($"The endpoint '{endpoint.Name}' on resource '{resource.Name}' is not external. App Service only supports external endpoints."); 140_endpointMapping[endpoint.Name] = new( 154.Select(r => r.Endpoint.Name)

AddAzureKustoTests.cs (2)

70var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http"); 360var httpEndpoint = endpointAnnotations.SingleOrDefault(e => e.Name == "http");

AzureSandboxContainerDeployment.cs (7)

1450throw new InvalidOperationException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' does not have a target port. Configure a target port before deploying it to an Azure sandbox."); 1455endpointOptions?.TryGetValue(resolvedEndpoint.Endpoint.Name, out resolvedEndpointOptions); 1456unmatchedEndpointOptions?.Remove(resolvedEndpoint.Endpoint.Name); 1458resolvedEndpoint.Endpoint.Name, 1469throw new NotSupportedException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' shares target port {targetPort} with endpoint '{existingEndpoint.Name}' but uses a different transport. Azure sandbox ports support a single HTTP protocol per target port."); 1474throw new NotSupportedException($"Endpoint '{resolvedEndpoint.Endpoint.Name}' on resource '{resource.TargetResource.Name}' shares target port {targetPort} with endpoint '{existingEndpoint.Name}' but configures a different anonymous-access policy. Azure sandbox ports support a single access policy per target port."); 1503_ => throw new NotSupportedException($"Endpoint '{endpoint.Name}' on resource '{resource.Name}' uses transport '{endpoint.Transport}'. Azure sandbox ports currently support only HTTP and HTTP/2 endpoints.")

AzureSandboxEndpointPropertyValueProvider.cs (2)

32throw new InvalidOperationException($"Endpoint '{endpoint.Name}' on resource '{resource.TargetResource.Name}' is not external. Azure sandbox endpoint references are only supported for external HTTP endpoints because ADC only assigns public URLs to exposed ports."); 184if (string.Equals(resolvedEndpoint.Endpoint.Name, endpointName, StringComparison.Ordinal) &&

AzureCosmosDBExtensionsTests.cs (7)

793var emulatorEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulator"); 825var emulatorEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulator"); 854var dataExplorerEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 884var dataExplorerEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 996var endpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer"); 1054var healthEndpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "emulatorhealth"); 1105var endpoint = Assert.Single(cosmos.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "data-explorer");

AzureEventHubsExtensionsTests.cs (2)

248Assert.Equal("emulator", endpoints[0].Name); 251Assert.Equal("emulatorhealth", endpoints[1].Name);

AzureManagedRedisExtensionsTests.cs (1)

90Assert.Equal("tcp", endpoint.Name);

AzurePostgresExtensionsTests.cs (1)

185Assert.Equal("tcp", endpoint.Name);

AzureRedisExtensionsTests.cs (1)

134Assert.Equal("tcp", endpoint.Name);

AzureSqlExtensionsTests.cs (1)

152Assert.Equal("tcp", endpoint.Name);

DurableTaskResourceExtensionsTests.cs (3)

169var grpc = endpointAnnotations.SingleOrDefault(e => e.Name == "grpc"); 173var http = endpointAnnotations.SingleOrDefault(e => e.Name == "http"); 178var dashboard = endpointAnnotations.SingleOrDefault(e => e.Name == "dashboard");

BlazorGatewayExtensions.cs (1)

729Name: ep.Name,

BrowserDebuggerHelper.cs (1)

115var endpointReference = parentResource.GetEndpoint(endpointAnnotation.Name);

AddDotnetProjectBlazorGatewayTests.cs (1)

29gateway.Resource.Annotations.OfType<EndpointAnnotation>().Select(e => e.Name));

BrowserLogsBuilderExtensions.cs (2)

333var endpointReference = resource.GetEndpoint(endpointAnnotation.Name); 336throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, BrowserMessageStrings.BrowserLogsEndpointNotAllocated, endpointAnnotation.Name, resource.Name));

src\Aspire.Hosting.Browsers\BrowserLogsBuilderExtensions.cs (2)

333var endpointReference = resource.GetEndpoint(endpointAnnotation.Name); 336throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, BrowserMessageStrings.BrowserLogsEndpointNotAllocated, endpointAnnotation.Name, resource.Name));

DevTunnelResourceBuilderExtensions.cs (2)

547.SingleOrDefault(a => string.Equals(a.Name, targetEndpoint.EndpointName, StringComparisons.EndpointAnnotationName)) is { } targetEndpointAnnotation) 553throw new ArgumentException($"Cannot tunnel endpoint '{targetEndpointAnnotation.Name}' with host '{targetEndpointAnnotation.TargetHost}' on resource '{targetResource.Name}' because it is not a localhost endpoint.", nameof(targetEndpoint));

DockerComposeEnvironmentContext.cs (2)

57serviceResource.EndpointMappings.Add(endpoint.Name, 64endpoint.Name));

HostedAgent\AzureHostedAgentResource.cs (1)

473throw CreateEndpointResolutionException(hostedAgent, resource, environmentVariableName, endpointReference, $"Endpoint '{endpoint.Name}' is internal. Foundry hosted agents can only reference externally exposed endpoints during publish.");

HostedAgent\HostedAgentBuilderExtension.cs (2)

293var existingHttpEndpoint = builder.Resource.Annotations.OfType<EndpointAnnotation>().FirstOrDefault(e => e.Name == "http"); 566targetWithEndpoints.Annotations.OfType<EndpointAnnotation>().Any(e => string.Equals(e.Name, "http", StringComparisons.EndpointAnnotationName)))

HostedAgentExtensionTests.cs (4)

34Assert.Contains(endpoints, e => e.Name == "http"); 49var httpEndpoints = endpoints.Where(e => e.Name == "http").ToList(); 66var httpEndpoint = endpoints.Single(e => e.Name == "http"); 402Assert.Equal("http", endpoint.Name);

AddGarnetTests.cs (2)

30Assert.Equal("tcp", endpoint.Name); 58Assert.Equal("tcp", endpoint.Name);

AddQuarkusAppTests.cs (1)

145Assert.Equal("http", endpoint.Name);

AddSpringBootAppTests.cs (1)

157Assert.Equal("http", endpoint.Name);

JavaScriptHostingExtensions.cs (1)

2287var endpointReference = parentResource.GetEndpoint(endpointAnnotation.Name);

AddKafkaTests.cs (4)

32var primaryEndpoint = Assert.Single(endpoints, e => e.Name == "tcp"); 35Assert.Equal("tcp", primaryEndpoint.Name); 41var internalEndpoint = Assert.Single(endpoints, e => e.Name == "internal"); 44Assert.Equal("internal", internalEndpoint.Name);

KeycloakResourceBuilderTests.cs (6)

34var endpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == defaultEndpointName); 37Assert.Equal(defaultEndpointName, endpoint.Name); 45var healthEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == managementEndpointName); 48Assert.Equal(managementEndpointName, healthEndpoint.Name); 85var primaryEndpoint = Assert.Single(endpoints, e => e.Name == "http"); 90Assert.DoesNotContain(endpoints, e => e.Name == "https");

KubernetesResource.cs (7)

256EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), httpMapping.Port, endpoint.Name); 276EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), HelmValue.Literal(portValue), endpoint.Name, ServicePort: servicePort); 285var paramName = $"port_{endpoint.Name}".ToHelmValuesSectionName(); 291EndpointMappings[endpoint.Name] = new(endpoint.UriScheme, GetKubernetesProtocolName(endpoint.Protocol), resource.Name.ToServiceName(), helmValue, endpoint.Name);

MauiPlatformExtensionsTests.cs (1)

703var dashboardEndpoint = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName);

AddMilvusTests.cs (5)

36.FirstOrDefault(e => e.Name == "grpc"); 40Assert.Equal("grpc", endpoint.Name); 66.FirstOrDefault(e => e.Name == "grpc"); 70Assert.Equal("grpc", endpoint.Name); 195var grpcEndpoint = milvusResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "grpc");

AddMongoDBTests.cs (2)

47Assert.Equal("tcp", endpoint.Name); 75Assert.Equal("tcp", endpoint.Name);

AddMySqlTests.cs (2)

57Assert.Equal("tcp", endpoint.Name); 96Assert.Equal("tcp", endpoint.Name);

AddNatsTests.cs (2)

107Assert.Equal("tcp", endpoint.Name); 153Assert.Equal("tcp", endpoint.Name);

AddOracleTests.cs (3)

55Assert.Equal("tcp", endpoint.Name); 94Assert.Equal("tcp", endpoint.Name); 176Assert.Equal("tcp", endpoint.Name);

AddPostgresTests.cs (3)

66Assert.Equal("tcp", endpoint.Name); 120Assert.Equal("tcp", endpoint.Name); 236Assert.Equal("tcp", endpoint.Name);

PostgresMcpBuilderTests.cs (1)

33Assert.Equal(PostgresMcpContainerResource.PrimaryEndpointName, endpoint.Name);

AddQdrantTests.cs (8)

63.FirstOrDefault(e => e.Name == "grpc"); 67Assert.Equal("grpc", endpoint.Name); 102.FirstOrDefault(e => e.Name == "http"); 107Assert.Equal("http", endpoint.Name); 135.FirstOrDefault(e => e.Name == "grpc"); 139Assert.Equal("grpc", endpoint.Name); 333var grpcEndpoint = qdrantResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "grpc"); 341var httpEndpoint = qdrantResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http");

AddRabbitMQTests.cs (4)

55var primaryEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "tcp"); 58Assert.Equal("tcp", primaryEndpoint.Name); 66var mangementEndpoint = Assert.Single(containerResource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "management"); 69Assert.Equal("management", mangementEndpoint.Name);

Publishing\RadiusInfrastructureBuilder.cs (2)

1078if (RadiusServiceDiscovery.ResolveServicePort(resource, endpoint.Name) is not int containerPort) 1101ports[endpoint.Name] = port;

Publishing\RadiusServiceDiscovery.cs (1)

94.FirstOrDefault(r => string.Equals(r.Endpoint.Name, endpointName, StringComparison.OrdinalIgnoreCase));

RadiusEnvironmentResource.cs (3)

157var resolvedServicePort = RadiusServiceDiscovery.ResolveServicePort(endpointReference.Resource, endpoint.Name); 179_ => throw new InvalidOperationException($"The property '{property}' is not supported for the endpoint '{endpoint.Name}'.") 198throw new InvalidOperationException($"Endpoint '{endpoint.Name}' must specify a port for scheme '{scheme}'.");

RedisBuilderExtensions.cs (1)

266var secondaryEndpoint = endpoints.FirstOrDefault(ep => string.Equals(ep.Name, RedisResource.SecondaryEndpointName, StringComparisons.EndpointAnnotationName));

AddRedisTests.cs (3)

46Assert.Equal("tcp", endpoint.Name); 74Assert.Equal("tcp", endpoint.Name); 880var endpoint = Assert.Single(redis.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "tcp");

AddSeqTests.cs (4)

29Assert.Equal("http", endpoint.Name); 57Assert.Equal("http", endpoint.Name); 183Assert.Equal("http", endpoint.Name); 216Assert.Equal("http", endpoint.Name);

AddSqlServerTests.cs (1)

51Assert.Equal("tcp", endpoint.Name);

Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (1)

2165var endpoint = dashboard.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http");

Dashboard\DashboardEventHandlersTests.cs (6)

454var endpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == expectedScheme); 456var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 458var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 536var httpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "http"); 538var otlpGrpcEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 540var otlpHttpEndpointAnnotation = dashboardResource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName);

Dashboard\DashboardResourceTests.cs (14)

Dcp\DcpExecutorTests.cs (1)

3373.WithEndpointsInEnvironment(e => e.Name != "dontinjectme")

EndpointReferenceTests.cs (1)

352var expression = destination.GetEndpoint(annotation.Name).Property(property);

KestrelConfigTests.cs (10)

29Assert.Equal("http", a.Name); 35Assert.Equal("ExplicitHttp", a.Name); 65Assert.Equal("http", a.Name); 71Assert.Equal("ExplicitHttp", a.Name); 98Assert.Equal("https", a.Name); 115Assert.Equal("FirstHttpEndpoint", a.Name); 123Assert.Equal("SecondHttpEndpoint", a.Name); 284.WithEndpointsInEnvironment(e => e.Name != "FirstHttpEndpoint") 285.WithEndpointsInEnvironment(e => e.Name != "ExplicitProxiedHttp"); 457endpoint.AllocatedEndpoint = new AllocatedEndpoint(endpoint, "localhost", endpoint.Port ?? 0, targetPortExpression: $"port_{endpoint.Name}");

ProjectResourceTests.cs (3)

329Assert.Equal("https", a.Name); 335Assert.Equal("http", a.Name); 412.WithEndpointsInEnvironment(filter: e => e.Name != "dontinjectme")

PublishAsDockerfileTests.cs (5)

301Assert.Equal("http", endpoint.Name); 325Assert.Equal("http", endpoint.Name); 343var endpoints = container.Annotations.OfType<EndpointAnnotation>().OrderBy(e => e.Name).ToList(); 348Assert.Equal("http", e.Name); 353Assert.Equal("https", e.Name);

WithEndpointTests.cs (20)

WithOtlpExporterTests.cs (6)

107var annotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == endpointName); 137var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 140var httpAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpHttpEndpointName); 192var grpcAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 249var dashboardAnnotation = dashboard.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == KnownEndpointNames.OtlpGrpcEndpointName); 252var collectorAnnotation = collector.Resource.Annotations.OfType<EndpointAnnotation>().Single(e => e.Name == "otlp-grpc");

AddValkeyTests.cs (2)

30Assert.Equal("tcp", endpoint.Name); 58Assert.Equal("tcp", endpoint.Name);

AddYarpTests.cs (3)

30Assert.Equal("http", endpoint.Name); 446var httpsEndpoint = Assert.Single(yarp.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "https"); 471Assert.DoesNotContain(yarp.Resource.Annotations.OfType<EndpointAnnotation>(), e => e.Name == "https");

TestProgram.cs (1)

193["Name"] = endpoint.Name,