Create functional tests

tests/Aspire.Hosting.Tests/DistributedApplicationTests.cs

@@ -18,7 +18,6 @@ public class DistributedApplicationTests
 {
     private readonly ITestOutputHelper _testOutputHelper;
 
-    // Primary constructors don't get ITestOutputHelper injected
     public DistributedApplicationTests(ITestOutputHelper testOutputHelper)
     {
         _testOutputHelper = testOutputHelper;
@@ -187,109 +186,6 @@ public Task AfterEndpointsAllocatedAsync(DistributedApplicationModel appModel, C
         }
     }
 
-    [LocalOnlyFact]
-    public async Task TestProjectStartsAndStopsCleanly()
-    {
-        var testProgram = CreateTestProgram();
-        testProgram.AppBuilder.Services.AddLogging(b => b.AddXunit(_testOutputHelper));
-
-        testProgram.AppBuilder.Services
-            .AddHttpClient()
-            .ConfigureHttpClientDefaults(b =>
-            {
-                b.UseSocketsHttpHandler((handler, sp) => handler.PooledConnectionLifetime = TimeSpan.FromSeconds(5));
-            });
-
-        await using var app = testProgram.Build();
-
-        var client = app.Services.GetRequiredService<IHttpClientFactory>().CreateClient();
-
-        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
-
-        await app.StartAsync(cts.Token);
-
-        // Make sure each service is running
-        await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceBBuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
-    }
-
-    [LocalOnlyFact]
-    public async Task TestPortOnServiceBindingAnnotationAndAllocatedEndpointAnnotationMatch()
-    {
-        var testProgram = CreateTestProgram();
-        testProgram.AppBuilder.Services.AddLogging(b => b.AddXunit(_testOutputHelper));
-
-        testProgram.AppBuilder.Services
-            .AddHttpClient()
-            .ConfigureHttpClientDefaults(b =>
-            {
-                b.UseSocketsHttpHandler((handler, sp) => handler.PooledConnectionLifetime = TimeSpan.FromSeconds(5));
-            });
-
-        await using var app = testProgram.Build();
-
-        var client = app.Services.GetRequiredService<IHttpClientFactory>().CreateClient();
-
-        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
-
-        await app.StartAsync(cts.Token);
-
-        // Make sure each service is running
-        await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceBBuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
-
-        foreach (var projectBuilders in testProgram.ServiceProjectBuilders)
-        {
-            var serviceBinding = projectBuilders.Resource.Annotations.OfType<ServiceBindingAnnotation>().Single();
-            var allocatedEndpoint = projectBuilders.Resource.Annotations.OfType<AllocatedEndpointAnnotation>().Single();
-
-            Assert.Equal(serviceBinding.Port, allocatedEndpoint.Port);
-        }
-    }
-
-    [LocalOnlyFact]
-    public async Task TestPortOnServiceBindingAnnotationAndAllocatedEndpointAnnotationMatchForReplicatedServices()
-    {
-        var testProgram = CreateTestProgram();
-
-        foreach (var serviceBuilder in testProgram.ServiceProjectBuilders)
-        {
-            serviceBuilder.WithReplicas(2);
-        }
-
-        testProgram.AppBuilder.Services.AddLogging(b => b.AddXunit(_testOutputHelper));
-
-        testProgram.AppBuilder.Services
-            .AddHttpClient()
-            .ConfigureHttpClientDefaults(b =>
-            {
-                b.UseSocketsHttpHandler((handler, sp) => handler.PooledConnectionLifetime = TimeSpan.FromSeconds(5));
-            });
-
-        await using var app = testProgram.Build();
-
-        var client = app.Services.GetRequiredService<IHttpClientFactory>().CreateClient();
-
-        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
-
-        await app.StartAsync(cts.Token);
-
-        // Make sure each service is running
-        await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceBBuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
-
-        foreach (var projectBuilders in testProgram.ServiceProjectBuilders)
-        {
-            var serviceBinding = projectBuilders.Resource.Annotations.OfType<ServiceBindingAnnotation>().Single();
-            var allocatedEndpoint = projectBuilders.Resource.Annotations.OfType<AllocatedEndpointAnnotation>().Single();
-
-            Assert.Equal(serviceBinding.Port, allocatedEndpoint.Port);
-        }
-    }
-
     [LocalOnlyFact]
     public async Task TestServicesWithMultipleReplicas()
     {
@@ -315,6 +211,11 @@ public async Task TestServicesWithMultipleReplicas()
 
         await app.StartAsync(cts.Token);
 
+        // Give the server some time to be ready to handle requests to
+        // minimize the amount of retries the clients have to do (and log).
+
+        await Task.Delay(1000, cts.Token);
+
         // Make sure services A and C are running
         await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
         await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
@@ -336,67 +237,6 @@ public async Task TestServicesWithMultipleReplicas()
         }
     }
 
-    [LocalOnlyFact]
-    public async Task VerifyHealthyOnIntegrationServiceA()
-    {
-        var testProgram = CreateTestProgram(includeIntegrationServices: true);
-        testProgram.AppBuilder.Services.AddLogging(b => b.AddXunit(_testOutputHelper));
-
-        testProgram.AppBuilder.Services
-            .AddHttpClient()
-            .ConfigureHttpClientDefaults(b =>
-            {
-                b.UseSocketsHttpHandler((handler, sp) => handler.PooledConnectionLifetime = TimeSpan.FromSeconds(5));
-            });
-
-        await using var app = testProgram.Build();
-
-        var client = app.Services.GetRequiredService<IHttpClientFactory>().CreateClient();
-
-        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
-
-        await app.StartAsync(cts.Token);
-
-        // Make sure all services are running
-        await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceBBuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
-        await testProgram.IntegrationServiceABuilder!.HttpGetPidAsync(client, "http", cts.Token);
-
-        // We wait until timeout for the /health endpoint to return successfully. We assume
-        // that components wired up into this project have health checks enabled.
-        await testProgram.IntegrationServiceABuilder!.WaitForHealthyStatus(client, "http", cts.Token);
-    }
-
-    [LocalOnlyFact("node")]
-    public async Task VerifyNodeAppWorks()
-    {
-        var testProgram = CreateTestProgram(includeNodeApp: true);
-        testProgram.AppBuilder.Services.AddLogging(b => b.AddXunit(_testOutputHelper));
-
-        testProgram.AppBuilder.Services
-            .AddHttpClient()
-            .ConfigureHttpClientDefaults(b =>
-            {
-                b.UseSocketsHttpHandler((handler, sp) => handler.PooledConnectionLifetime = TimeSpan.FromSeconds(5));
-                b.AddStandardResilienceHandler();
-            });
-
-        await using var app = testProgram.Build();
-
-        var client = app.Services.GetRequiredService<IHttpClientFactory>().CreateClient();
-
-        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
-
-        await app.StartAsync(cts.Token);
-
-        var response0 = await testProgram.NodeAppBuilder!.HttpGetWithRetryAsync(client, "http", "/", cts.Token);
-        var response1 = await testProgram.NpmAppBuilder!.HttpGetWithRetryAsync(client, "http", "/", cts.Token);
-
-        Assert.Equal("Hello from node!", response0);
-        Assert.Equal("Hello from node!", response1);
-    }
-
     [LocalOnlyFact("docker")]
     public async Task VerifyDockerAppWorks()
     {

tests/Aspire.Hosting.Tests/Helpers/AllocatedEndpointAnnotationTestExtensions.cs

@@ -2,43 +2,89 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 namespace Aspire.Hosting.Tests.Helpers;
+
 public static class AllocatedEndpointAnnotationTestExtensions
 {
-    public static async Task<string> HttpGetAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string path, CancellationToken cancellationToken)
+    /// <summary>
+    /// Sends a GET request to the specified resource and returns the response body as a string.
+    /// </summary>
+    /// <typeparam name="T">The type of the resource.</typeparam>
+    /// <param name="builder">The resource.</param>
+    /// <param name="client">The <see cref="HttpClient"/> instance to use.</param>
+    /// <param name="bindingName">The name of the binding.</param>
+    /// <param name="path">The path the request is sent to.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The string representing the response body.</returns>
+    public static async Task<string> HttpGetStringAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string path, CancellationToken cancellationToken)
         where T : IResourceWithBindings
     {
-        // We have to get the allocated endpoint each time through the loop
-        // because it may not be populated yet by the time we get here.
         var allocatedEndpoint = builder.Resource.Annotations.OfType<AllocatedEndpointAnnotation>().Single(a => a.Name == bindingName);
         var url = $"{allocatedEndpoint.UriString}{path}";
 
         var response = await client.GetStringAsync(url, cancellationToken);
         return response;
     }
 
-    public static Task<string> WaitForHealthyStatus(this IResourceBuilder<ProjectResource> builder, HttpClient client, string bindingName, CancellationToken cancellationToken)
+    /// <summary>
+    /// Sends a GET request to the specified resource and returns the response message.
+    /// </summary>
+    /// <typeparam name="T">The type of the resource.</typeparam>
+    /// <param name="builder">The resource.</param>
+    /// <param name="client">The <see cref="HttpClient"/> instance to use.</param>
+    /// <param name="bindingName">The name of the binding.</param>
+    /// <param name="path">The path the request is sent to.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The response message.</returns>
+    public static async Task<HttpResponseMessage> HttpGetAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string path, CancellationToken cancellationToken)
+        where T : IResourceWithBindings
     {
-        return HttpGetWithRetryAsync(builder, client, bindingName, "/health", cancellationToken);
+        var allocatedEndpoint = builder.Resource.Annotations.OfType<AllocatedEndpointAnnotation>().Single(a => a.Name == bindingName);
+        var url = $"{allocatedEndpoint.UriString}{path}";
+
+        var response = await client.GetAsync(url, cancellationToken);
+        return response;
+    }
+
+    /// <summary>
+    /// Sends a POST request to the specified resource and returns the response message.
+    /// </summary>
+    /// <typeparam name="T">The type of the resource.</typeparam>
+    /// <param name="builder">The resource.</param>
+    /// <param name="client">The <see cref="HttpClient"/> instance to use.</param>
+    /// <param name="bindingName">The name of the binding.</param>
+    /// <param name="path">The path the request is sent to.</param>
+    /// <param name="content">The HTTP request content sent to the server.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The response message.</returns>
+    public static async Task<HttpResponseMessage> HttpPostAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string path, HttpContent? content, CancellationToken cancellationToken)
+        where T : IResourceWithBindings
+    {
+        var allocatedEndpoint = builder.Resource.Annotations.OfType<AllocatedEndpointAnnotation>().Single(a => a.Name == bindingName);
+        var url = $"{allocatedEndpoint.UriString}{path}";
+
+        var response = await client.PostAsync(url, content, cancellationToken);
+        return response;
+    }
+
+    public static Task<string> WaitForHealthyStatusAsync(this IResourceBuilder<ProjectResource> builder, HttpClient client, string bindingName, CancellationToken cancellationToken)
+    {
+        return HttpGetStringWithRetryAsync(builder, client, bindingName, "/health", cancellationToken);
     }
 
     public static Task<string> HttpGetPidAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, CancellationToken cancellationToken)
         where T : IResourceWithBindings
     {
-        return HttpGetWithRetryAsync(builder, client, bindingName, "/pid", cancellationToken);
+        return HttpGetStringWithRetryAsync(builder, client, bindingName, "/pid", cancellationToken);
     }
 
-    public static async Task<string> HttpGetWithRetryAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string request, CancellationToken cancellationToken)
+    public static async Task<string> HttpGetStringWithRetryAsync<T>(this IResourceBuilder<T> builder, HttpClient client, string bindingName, string request, CancellationToken cancellationToken)
         where T : IResourceWithBindings
     {
         while (true)
         {
             try
             {
-                return await builder.HttpGetAsync(client, bindingName, request, cancellationToken);
-            }
-            catch (HttpRequestException ex)
-            {
-                Console.WriteLine(ex);
+                return await builder.HttpGetStringAsync(client, bindingName, request, cancellationToken);
             }
             catch
             {

tests/Aspire.Hosting.Tests/Helpers/LocalOnlyFactAttribute.cs

@@ -12,6 +12,8 @@ public override string Skip
     {
         get
         {
+            // BUILD_BUILDID is defined by Azure Dev Ops
+
             if (Environment.GetEnvironmentVariable("BUILD_BUILDID") != null)
             {
                 return "LocalOnlyFactAttribute tests are not run as part of CI.";

tests/Aspire.Hosting.Tests/IntegrationServicesTests.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Hosting.Tests.Helpers;
+using Xunit;
+
+namespace Aspire.Hosting.Tests;
+
+[Collection("IntegrationServices")]
+public class IntegrationServicesTests
+{
+    private readonly IntegrationServicesFixture _integrationServicesFixture;
+
+    public IntegrationServicesTests(IntegrationServicesFixture integrationServicesFixture)
+    {
+        _integrationServicesFixture = integrationServicesFixture;
+    }
+
+    [LocalOnlyFact]
+    public async Task VerifyHealthyOnIntegrationServiceA()
+    {
+        var testProgram = _integrationServicesFixture.TestProgram;
+        var client = _integrationServicesFixture.HttpClient;
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
+
+        // Make sure all services are running
+        await testProgram.ServiceABuilder.HttpGetPidAsync(client, "http", cts.Token);
+        await testProgram.ServiceBBuilder.HttpGetPidAsync(client, "http", cts.Token);
+        await testProgram.ServiceCBuilder.HttpGetPidAsync(client, "http", cts.Token);
+        await testProgram.IntegrationServiceABuilder!.HttpGetPidAsync(client, "http", cts.Token);
+
+        // We wait until timeout for the /health endpoint to return successfully. We assume
+        // that components wired up into this project have health checks enabled.
+        await testProgram.IntegrationServiceABuilder!.WaitForHealthyStatusAsync(client, "http", cts.Token);
+    }
+}

tests/Aspire.Hosting.Tests/MongoDB/MongoDBFunctionalTests.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Hosting.Tests.Helpers;
+using Xunit;
+
+namespace Aspire.Hosting.Tests.MongoDB;
+
+[Collection("IntegrationServices")]
+public class MongoDBFunctionalTests
+{
+    private readonly IntegrationServicesFixture _integrationServicesFixture;
+
+    public MongoDBFunctionalTests(IntegrationServicesFixture integrationServicesFixture)
+    {
+        _integrationServicesFixture = integrationServicesFixture;
+    }
+
+    [LocalOnlyFact()]
+    public async Task VerifyMongoWorks()
+    {
+        var testProgram = _integrationServicesFixture.TestProgram;
+        var client = _integrationServicesFixture.HttpClient;
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
+
+        var response = await testProgram.IntegrationServiceABuilder!.HttpGetAsync(client, "http", "/mongodb/verify", cts.Token);
+        var responseContent = await response.Content.ReadAsStringAsync();
+
+        Assert.True(response.IsSuccessStatusCode, responseContent);
+    }
+}