How to add middleware to WebApplicationFactory<TEntryPoint> ?

[paulomorgado]

Create a simple web API application project and unit tests:

dotnet new webapi --name WebApi --output WebApi
dotnet new xunit --name WebApiTests --project WebApi
dotnet add WebApiTests reference WebApi
dotnet new sln
dotnet sln add webapi
dotnet sln add WebApiTests

Change Program.cs to make the Program class and WeatherForecast record public:

...
public sealed partial class Program
{
    private Program() { }
}

public record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

Change UnitTest1.cs to be:

using Microsoft.AspNetCore.Mvc.Testing;
using System.Net.Http.Json;

namespace WebApiTests;

public class UnitTest1
{
    [Fact]
    public async Task Test1Async()
    {
        var server = new WeatherForecastWebApplicationFactory();

        var client = server.CreateClient();

        var response = await client.GetFromJsonAsync<WeatherForecast[]>("/weatherforecast");

        Assert.NotNull(response);
    }

    private sealed class WeatherForecastWebApplicationFactory : WebApplicationFactory<global::Program>
    {
    }
}

Run the WebApiTests.UnitTest1.Test1Async test and the test succeeds.

Change UnitTest1.cs to be:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using System.Net.Http.Json;

namespace WebApiTests;

public class UnitTest1
{
    [Fact]
    public async Task Test1Async()
    {
        var server = new WeatherForecastWebApplicationFactory();

        var client = server.CreateClient();

        var response = await client.GetFromJsonAsync<WeatherForecast[]>("/weatherforecast");

        Assert.NotNull(response);
    }

    private sealed class WeatherForecastWebApplicationFactory : WebApplicationFactory<global::Program>
    {
        protected override void ConfigureWebHost(IWebHostBuilder builder)
        {
            builder.Configure(app =>
            {
                app.Use(async (ctx, next) =>
                {
                    await next(ctx);
                });
            });

            base.ConfigureWebHost(builder);
        }
    }
}

Now the test fails with:

  Message: 
System.Net.Http.HttpRequestException : Response status code does not indicate success: 404 (Not Found).

  Stack Trace: 
HttpResponseMessage.EnsureSuccessStatusCode()
HttpClientJsonExtensions.<FromJsonAsyncCore>g__Core|12_0[TValue,TJsonOptions](HttpClient client, Task`1 responseTask, Boolean usingResponseHeadersRead, CancellationTokenSource linkedCTS, Func`4 deserializeMethod, TJsonOptions jsonOptions, CancellationToken cancellationToken)
UnitTest1.Test1Async() line 17
--- End of stack trace from previous location ---

Is it not possible to add middleware to the application being tested?

[markmouton22]

HI :)

Yes, it is possible to add middleware to the application being tested. However, the issue you’re encountering is likely due to the fact that the middleware you added does not call the next middleware in the pipeline.

In ConfigureWebHost :

app.Use(async (ctx, next) => { await next(ctx); });
The next delegate here represents the next middleware in the pipeline, but it does not take any parameters. So, you should call it without passing ctx.

app.Use(async (ctx, next) => { await next(); });
Should fix the 404 (Not Found) error you’re seeing in your tests.

[simkin2004]

This code returns a 404 - Not Found.

    public class CustomWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
    {
        protected override void ConfigureWebHost(IWebHostBuilder builder)
        {
            builder.Configure(app => 
                        {
                            app.Use(async (ctx, next) => { await next(); });

                        });
            
            base.ConfigureWebHost(builder);
        }
    }

This code returns a 200 - OK

    public class CustomWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
    {
        protected override void ConfigureWebHost(IWebHostBuilder builder)
        {           
            base.ConfigureWebHost(builder);
        }
    }

It is definitely -NOT- the middleware.

[simkin2004]

And for full disclosure - doing nothing in that action also causes a 404 - Not Found

public class CustomWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
    {
        protected override void ConfigureWebHost(IWebHostBuilder builder)
        {
            
            builder.Configure(app => 
                        {
                            // no op
                        });
            
            base.ConfigureWebHost(builder);
        }
    } 

[eskild-th]

also ran into this issue

[ideal-railroad]

Rejoice, my friends! I have found the solution: add an IStartupFilter to the services.

class CustomWebApplicationFactory : WebApplicationFactory<Program> {
    readonly ITestOutputHelper _output;
    readonly DateTimeOffset _logStart;

    public CustomWebApplicationFactory(ITestOutputHelper output, DateTimeOffset logStart) {
        _output = output;
        _logStart = logStart;
    }

    protected override void ConfigureWebHost(IWebHostBuilder builder) {
        builder.ConfigureTestServices(services => {
            services.AddSingleton<IStartupFilter>(new LoggingStartupFilter(_output, _logStart));
        });
    }
}

class LoggingStartupFilter : IStartupFilter {
    private readonly ITestOutputHelper _output;
    private readonly DateTimeOffset _logStart;

    public LoggingStartupFilter(ITestOutputHelper output, DateTimeOffset logStart) {
        _output = output;
        _logStart = logStart;
    }

    public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next) {
        return app => {
            // This middleware runs at the beginning of the request pipeline
            app.Use(async (context, next) => {
                _output.WriteLine($"[{(DateTimeOffset.Now - _logStart).TotalSeconds:N3}s] Inbound HTTP request: {context.Request.Method} {context.Request.Path}{context.Request.QueryString}");

                await next(context);

                _output.WriteLine($"[{(DateTimeOffset.Now - _logStart).TotalSeconds:N3}s] Outbound HTTP response: {context.Response.StatusCode}");
            });

            next(app);

            // Middleware registered here will be after everything defined in Program/Startup
        };
    }
}