Testowanie oprogramowania pośredniczącego platformy ASP.NET Core

Artykuł
01/12/2024

Autor: Chris Ross

Oprogramowanie pośredniczące można przetestować w izolacji za pomocą polecenia TestServer. Umożliwia to:

Utwórz wystąpienie potoku aplikacji zawierającego tylko składniki, które należy przetestować.
Wysyłanie niestandardowych żądań w celu zweryfikowania zachowania oprogramowania pośredniczącego.

Zalety:

Żądania są wysyłane w pamięci, a nie serializowane za pośrednictwem sieci.
Pozwala to uniknąć dodatkowych problemów, takich jak zarządzanie portami i certyfikaty HTTPS.
Wyjątki w oprogramowania pośredniczącego mogą przepływać bezpośrednio do testu wywołującego.
Istnieje możliwość dostosowania struktur danych serwera, takich jak HttpContext, bezpośrednio w teście.

Konfigurowanie serwera TestServer

W projekcie testowym utwórz test:

Skompiluj i uruchom hosta, który używa elementu TestServer.
Dodaj wszystkie wymagane usługi używane przez oprogramowanie pośredniczące.
Dodaj odwołanie do pakietu nuget do Microsoft.AspNetCore.TestHost projektu.

Skonfiguruj potok przetwarzania, aby używać oprogramowania pośredniczącego dla testu.

[Fact]
public async Task MiddlewareTest_ReturnsNotFoundForRequest()
{
    using var host = await new HostBuilder()
        .ConfigureWebHost(webBuilder =>
        {
            webBuilder
                .UseTestServer()
                .ConfigureServices(services =>
                {
                    services.AddMyServices();
                })
                .Configure(app =>
                {
                    app.UseMiddleware<MyMiddleware>();
                });
        })
        .StartAsync();

    ...
}

Uwaga

Aby uzyskać instrukcje dodawania pakietów do aplikacji .NET, zobacz artykuły w sekcji Instalowanie pakietów i zarządzanie nimi w temacie Przepływ pracy użycia pakietów (dokumentacja programu NuGet). Sprawdź prawidłowe wersje pakietów pod adresem NuGet.org.

Wysyłanie żądań za pomocą obiektu HttpClient

Wyślij żądanie przy użyciu polecenia HttpClient:

[Fact]
public async Task MiddlewareTest_ReturnsNotFoundForRequest()
{
    using var host = await new HostBuilder()
        .ConfigureWebHost(webBuilder =>
        {
            webBuilder
                .UseTestServer()
                .ConfigureServices(services =>
                {
                    services.AddMyServices();
                })
                .Configure(app =>
                {
                    app.UseMiddleware<MyMiddleware>();
                });
        })
        .StartAsync();

    var response = await host.GetTestClient().GetAsync("/");

    ...
}

Potwierdzanie wyniku. Najpierw utwórz asercji przeciwieństwo oczekiwanego wyniku. Początkowy przebieg z potwierdzeniem fałszywie dodatnim potwierdza, że test kończy się niepowodzeniem, gdy oprogramowanie pośredniczące działa prawidłowo. Uruchom test i upewnij się, że test zakończy się niepowodzeniem.

W poniższym przykładzie oprogramowanie pośredniczące powinno zwrócić kod stanu 404 (Nie znaleziono), gdy zażądano głównego punktu końcowego. Wykonaj pierwszy przebieg testu za pomocą Assert.NotEqual( ... );polecenia , który powinien zakończyć się niepowodzeniem:

[Fact]
public async Task MiddlewareTest_ReturnsNotFoundForRequest()
{
    using var host = await new HostBuilder()
        .ConfigureWebHost(webBuilder =>
        {
            webBuilder
                .UseTestServer()
                .ConfigureServices(services =>
                {
                    services.AddMyServices();
                })
                .Configure(app =>
                {
                    app.UseMiddleware<MyMiddleware>();
                });
        })
        .StartAsync();

    var response = await host.GetTestClient().GetAsync("/");

    Assert.NotEqual(HttpStatusCode.NotFound, response.StatusCode);
}

Zmień asercji, aby przetestować oprogramowanie pośredniczące w normalnych warunkach operacyjnych. W ostatnim teście użyto metody Assert.Equal( ... );. Uruchom ponownie test, aby potwierdzić, że przebiegnie pomyślnie.

[Fact]
public async Task MiddlewareTest_ReturnsNotFoundForRequest()
{
    using var host = await new HostBuilder()
        .ConfigureWebHost(webBuilder =>
        {
            webBuilder
                .UseTestServer()
                .ConfigureServices(services =>
                {
                    services.AddMyServices();
                })
                .Configure(app =>
                {
                    app.UseMiddleware<MyMiddleware>();
                });
        })
        .StartAsync();

    var response = await host.GetTestClient().GetAsync("/");

    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}

Wysyłanie żądań przy użyciu obiektu HttpContext

Aplikacja testowa może również wysłać żądanie przy użyciu polecenia SendAsync(Action<HttpContext>, CancellationToken). W poniższym przykładzie kilka kontroli jest przeprowadzanych podczas https://example.com/A/Path/?and=query przetwarzania przez oprogramowanie pośredniczące:

[Fact]
public async Task TestMiddleware_ExpectedResponse()
{
    using var host = await new HostBuilder()
        .ConfigureWebHost(webBuilder =>
        {
            webBuilder
                .UseTestServer()
                .ConfigureServices(services =>
                {
                    services.AddMyServices();
                })
                .Configure(app =>
                {
                    app.UseMiddleware<MyMiddleware>();
                });
        })
        .StartAsync();

    var server = host.GetTestServer();
    server.BaseAddress = new Uri("https://example.com/A/Path/");

    var context = await server.SendAsync(c =>
    {
        c.Request.Method = HttpMethods.Post;
        c.Request.Path = "/and/file.txt";
        c.Request.QueryString = new QueryString("?and=query");
    });

    Assert.True(context.RequestAborted.CanBeCanceled);
    Assert.Equal(HttpProtocol.Http11, context.Request.Protocol);
    Assert.Equal("POST", context.Request.Method);
    Assert.Equal("https", context.Request.Scheme);
    Assert.Equal("example.com", context.Request.Host.Value);
    Assert.Equal("/A/Path", context.Request.PathBase.Value);
    Assert.Equal("/and/file.txt", context.Request.Path.Value);
    Assert.Equal("?and=query", context.Request.QueryString.Value);
    Assert.NotNull(context.Request.Body);
    Assert.NotNull(context.Request.Headers);
    Assert.NotNull(context.Response.Headers);
    Assert.NotNull(context.Response.Body);
    Assert.Equal(404, context.Response.StatusCode);
    Assert.Null(context.Features.Get<IHttpResponseFeature>().ReasonPhrase);
}

SendAsync umożliwia bezpośrednią konfigurację HttpContext obiektu zamiast używania HttpClient abstrakcji. Umożliwia SendAsync manipulowanie strukturami dostępnymi tylko na serwerze, takimi jak HttpContext.Items lub HttpContext.Features.

Podobnie jak w przypadku wcześniejszego przykładu, który testował odpowiedź 404 — Nie znaleziono , sprawdź odwrotnie dla każdej Assert instrukcji w poprzednim teście. Sprawdzanie potwierdza, że test kończy się niepowodzeniem, gdy oprogramowanie pośredniczące działa normalnie. Po potwierdzeniu, że test fałszywie dodatni działa, ustaw końcowe Assert instrukcje dla oczekiwanych warunków i wartości testu. Uruchom go ponownie, aby potwierdzić, że test przebiegnie pomyślnie.

Dodawanie tras żądań

Dodatkowe trasy można dodać przy użyciu konfiguracji przy użyciu testu HttpClient:

	[Fact]
	public async Task TestWithEndpoint_ExpectedResponse ()
	{
		using var host = await new HostBuilder()
			.ConfigureWebHost(webBuilder =>
			{
				webBuilder
					.UseTestServer()
					.ConfigureServices(services =>
					{
						services.AddRouting();
					})
					.Configure(app =>
					{
						app.UseRouting();
						app.UseMiddleware<MyMiddleware>();
						app.UseEndpoints(endpoints =>
						{
							endpoints.MapGet("/hello", () =>
								TypedResults.Text("Hello Tests"));
						});
					});
			})
			.StartAsync();

		var client = host.GetTestClient();

		var response = await client.GetAsync("/hello");

		Assert.True(response.IsSuccessStatusCode);
		var responseBody = await response.Content.ReadAsStringAsync();
		Assert.Equal("Hello Tests", responseBody);

Dodatkowe trasy można również dodać przy użyciu metody server.SendAsync.

Ograniczenia serwera testowego

Testserver:

Utworzono w celu replikowania zachowań serwera w celu przetestowania oprogramowania pośredniczącego.
Nie próbuje replikować wszystkich HttpClient zachowań.
Próbuje nadać klientowi dostęp do jak największej kontroli nad serwerem i jak najwięcej wglądu w to, co dzieje się na serwerze, jak to możliwe. Na przykład może zgłaszać wyjątki, które nie są zwykle zgłaszane HttpClient , aby bezpośrednio komunikować się ze stanem serwera.
Nie ustawia niektórych nagłówków specyficznych dla transportu domyślnie, ponieważ nie są one zwykle istotne dla oprogramowania pośredniczącego. Aby uzyskać więcej informacji, zapoznaj się z następną sekcją.
Ignoruje pozycję przekazaną Stream przez StreamContentelement . HttpClient wysyła cały strumień z pozycji początkowej, nawet w przypadku ustawienia pozycjonowania. Aby uzyskać więcej informacji, zobacz ten problem w serwisie GitHub.

Nagłówki Content-Length i Transfer-Encoding

Serwer TestServer nie ustawia nagłówków żądań ani odpowiedzi związanych z transportem, takich jak Content-Length lub Transfer-Encoding. Aplikacje powinny unikać w zależności od tych nagłówków, ponieważ ich użycie różni się w zależności od klienta, scenariusza i protokołu. Jeśli Content-Length konieczne jest Transfer-Encoding przetestowanie określonego scenariusza, można je określić w teście podczas komponowania elementu HttpRequestMessage lub HttpContext. Aby uzyskać więcej informacji, zobacz następujące problemy z usługą GitHub: