为AspNetCore中间件编写单元测试

1.编辑单元测试项目文件
   例如使用xUnitTest项目时，在项目文件中的Project节点下加入如下代码：

    <ItemGroup>
        <FrameworkReference Include="Microsoft.AspNetCore.App"></FrameworkReference>
    </ItemGroup>

2.配置和构建Host

   例如配置服务、指定要使用的服务器以及加入需要测试的中间件，主要代码如下：

    using IHost host = new HostBuilder()
    .ConfigureWebHost(webHostBuilder =>
        {
            webHostBuilder
            .ConfigureServices(services =>
            {
                services.AddHttpContextAccessor();
                services.AddLogging();
                services.AddRouting();
            })
            .UseKestrel()
            .UseUrls(GetTestUrl(server))
            .UseWebRoot(AppContext.BaseDirectory)
            .Configure(app =>
            {
                app.UseRouting();

                app.Use(next => context =>
                {
                    // Assign an endpoint, this will make the default files noop.
                    context.SetEndpoint(new Endpoint((c) =>
                        {
                            return context.Response.WriteAsync("endpoint.");
                        },
                        new EndpointMetadataCollection(), "test"));

                    return next(context);
                });

                app.UseStaticFiles();

                //这里是需要单测的中间件
                app.UseDemoMiddleware();

                app.UseEndpoints(endpoints => { });
            });
        })
    .Build();

3.启动和使用Host
   配置完Host后，将该Host实例启动，并且使用HttpClient模拟请求，以期执行自定义的中间件，主要代码如下：

    await host.StartAsync();

    using var client = new HttpClient { BaseAddress = new Uri(GetAddress(host)) };
    string url = "/api/demo";
    var response = await client.GetAsync(url);
    
    Assert.Equal(HttpStatusCode.OK, response.StatusCode);

4.完整示例如下
   4.1 ServerType

    public enum ServerType
    {
        None,
        IISExpress,
        IIS,
        HttpSys,
        Kestrel,
        Nginx
    }

   4.2 TestUriHelper

    public static class TestUriHelper
    {
        public static Uri BuildTestUri(ServerType serverType)
        {
            return BuildTestUri(serverType, hint: null);
        }

        public static Uri BuildTestUri(ServerType serverType, string hint)
        {
            // Assume status messages are enabled for Kestrel and disabled for all other servers.
            var statusMessagesEnabled = (serverType == ServerType.Kestrel);

            return BuildTestUri(serverType, Uri.UriSchemeHttp, hint, statusMessagesEnabled);
        }

        internal static Uri BuildTestUri(ServerType serverType, string scheme, string hint, bool statusMessagesEnabled)
        {
            if (string.IsNullOrEmpty(hint))
            {
                if (serverType == ServerType.Kestrel && statusMessagesEnabled)
                {
                    // Most functional tests use this codepath and should directly bind to dynamic port "0" and scrape
                    // the assigned port from the status message, which should be 100% reliable since the port is bound
                    // once and never released.  Binding to dynamic port "0" on "localhost" (both IPv4 and IPv6) is not
                    // supported, so the port is only bound on "127.0.0.1" (IPv4).  If a test explicitly requires IPv6,
                    // it should provide a hint URL with "localhost" (IPv4 and IPv6) or "[::1]" (IPv6-only).
                    return new UriBuilder(scheme, "127.0.0.1", 0).Uri;
                }
                else if (serverType == ServerType.HttpSys)
                {
                    Debug.Assert(scheme == "http", "Https not supported");
                    return new UriBuilder(scheme, "localhost", 0).Uri;
                }
                else
                {
                    // If the server type is not Kestrel, or status messages are disabled, there is no status message
                    // from which to scrape the assigned port, so the less reliable GetNextPort() must be used.  The
                    // port is bound on "localhost" (both IPv4 and IPv6), since this is supported when using a specific
                    // (non-zero) port.
                    return new UriBuilder(scheme, "localhost", GetNextPort()).Uri;
                }
            }
            else
            {
                var uriHint = new Uri(hint);
                if (uriHint.Port == 0)
                {
                    // Only a few tests use this codepath, so it's fine to use the less reliable GetNextPort() for simplicity.
                    // The tests using this codepath will be reviewed to see if they can be changed to directly bind to dynamic
                    // port "0" on "127.0.0.1" and scrape the assigned port from the status message (the default codepath).
                    return new UriBuilder(uriHint) { Port = GetNextPort() }.Uri;
                }
                else
                {
                    // If the hint contains a specific port, return it unchanged.
                    return uriHint;
                }
            }
        }

        private static int GetNextPort()
        {
            using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
            return ((IPEndPoint)socket.LocalEndPoint).Port;
        }
    }

   4.3 DemoMiddlewareUnitTest

    public class DemoMiddlewareUnitTest
    {
        [Fact]
        public async Task DemoMiddlewareTest()
        {
            await DemoMiddleware(ServerType.IIS);
            await DemoMiddleware(ServerType.IISExpress);
            await DemoMiddleware(ServerType.Kestrel);
            await DemoMiddleware(ServerType.Nginx);
        }

        private async Task DemoMiddleware(ServerType server)
        {
            using IHost host = new HostBuilder()
                .ConfigureWebHost(webHostBuilder =>
                    {
                        webHostBuilder
                        .ConfigureServices(services =>
                        {
                            services.AddHttpContextAccessor();
                            services.AddLogging();
                            services.AddRouting();
                        })
                        .UseKestrel()
                        .UseUrls(GetTestUrl(server))
                        .UseWebRoot(AppContext.BaseDirectory)
                        .Configure(app =>
                        {
                            app.UseRouting();

                            app.Use(next => context =>
                            {
                                // Assign an endpoint, this will make the default files noop.
                                context.SetEndpoint(new Endpoint((c) =>
                                    {
                                        return context.Response.WriteAsync("endpoint.");
                                    },
                                    new EndpointMetadataCollection(), "test"));

                                return next(context);
                            });

                            app.UseStaticFiles();

                            app.UseDemoMiddleware();

                            app.UseEndpoints(endpoints => { });
                        });
                    })
                .Build();

            await host.StartAsync();

            using var client = new HttpClient { BaseAddress = new Uri(GetAddress(host)) };
            string url = "/api/demo";
            var response = await client.GetAsync(url);

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal("endpoint.", await response.Content.ReadAsStringAsync());
        }

        private string GetTestUrl(ServerType serverType)
        {
            return TestUriHelper.BuildTestUri(serverType).ToString();
        }

        private string GetAddress(IHost server)
        {
            return server.Services.GetService<IServer>().Features.Get<IServerAddressesFeature>().Addresses.First();
        }
    }