# Unit Testing HttpClient utan Mocks ## Inleiding När man testar kod som använder `HttpClient`, det traditionella sättet innebär att skämta `HttpMessageHandler` med hjälp av plattformar som Moq. `DelegatingHandler` att skapa tester som beter sig som riktiga HTTP slutpunkter. I denna artikel ska jag visa er varför ni kan hoppa över modellerna helt och använda `DelegatingHandler` för mer läsbar [TOC] ## Problemet med att kopiera HttpMessageHandler Här är vad som typiskt `HttpMessageHandler` mocking ser ut som med Moq: ```csharp var mockHandler = new Mock(); mockHandler.Protected() .Setup>( "SendAsync", ItExpr.Is(x => x.RequestUri.ToString().Contains("api/send")), ItExpr.IsAny()) .ReturnsAsync((HttpRequestMessage request, CancellationToken cancellationToken) => { var requestBody = request.Content?.ReadAsStringAsync(cancellationToken).Result; return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(requestBody ?? "No content", Encoding.UTF8, "application/json") }; }); var client = new HttpClient(mockHandler.Object); ``` Det har flera problem. 1. **Verbose** - Många boilerplattor för vad som borde vara ett enkelt beteende 2. **Protected method ceremoni** - Du behöver `Protected()` och `ItExpr` eftersom `SendAsync` är skyddad 3. **Svårt att läsa** - Den faktiska testlogiken är begravd i inställningssceremonin 4. **Inte återanvändbar** - Varje test behöver samma konfigurationskod 5. **Brittle** - Det är lätt att få tag i stringen-baserade metodens namn fel ## DelegeringHandler alternativet `DelegatingHandler` är en inbyggd NET-klass, designad precis för den här syften. - tar emot HTTP- begäran innan de träffar nätverket. Här ' har samma funktion med `DelegatingHandler`: ```csharp public class EchoHandler : DelegatingHandler { protected override async Task SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { var content = request.Content != null ? await request.Content.ReadAsStringAsync(cancellationToken) : "No content"; return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(content, Encoding.UTF8, "application/json") }; } } ``` Att använda den: ```csharp var client = new HttpClient(new EchoHandler()); ``` Det "'" är det "." Ingen mocking ramverk , , ingen skyddad metod gymnastik , , inga strängar, - , med metoder som baseras på namn, . ## Ett verkligt-World Example: Translation Service Handler Här är ett mer sofistikerat exempel från en testbehandlare för översättningstjänster. ```csharp public class TranslateDelegatingHandler : DelegatingHandler { protected override async Task SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { var absPath = request.RequestUri?.AbsolutePath; var method = request.Method; return absPath switch { "/translate" when method == HttpMethod.Post => await HandleTranslate(request), "/translate" => new HttpResponseMessage(HttpStatusCode.OK), "/health" => new HttpResponseMessage(HttpStatusCode.OK), _ => new HttpResponseMessage(HttpStatusCode.NotFound) }; } private static async Task HandleTranslate(HttpRequestMessage request) { var content = await request.Content!.ReadFromJsonAsync(); // Simulate error for specific test case if (content?.TargetLanguage == "xx") return new HttpResponseMessage(HttpStatusCode.InternalServerError); var response = new TranslateResponse("es", new[] { "Texto traducido" }); return new HttpResponseMessage(HttpStatusCode.OK) { Content = JsonContent.Create(response) }; } } ``` Den här handledaren: - Routerar olika vägar till olika beteenden - Deserialiserar begäran innehåll för att fatta beslut - Ge tillbaka lämpliga felkoder för specifika scenarior - Är fullständigt läsbar och självdokumenterar ## Konfiguration av beroende injektion När man använder `IHttpClientFactory` (där du borde vara ), integrerande testbehandlare är enkelt ```csharp public static IServiceCollection SetupTestServices(DelegatingHandler handler) { var services = new ServiceCollection(); services.AddHttpClient(client => { client.BaseAddress = new Uri("https://test.local"); }) .ConfigurePrimaryHttpMessageHandler(() => handler); return services; } ``` Sedan i dina tester: ```csharp [Fact] public async Task Translate_ReturnsTranslatedText() { var services = SetupTestServices(new TranslateDelegatingHandler()); var provider = services.BuildServiceProvider(); var service = provider.GetRequiredService(); var result = await service.TranslateAsync("Hello", "es"); Assert.Equal("Texto traducido", result); } [Fact] public async Task Translate_InvalidLanguage_ThrowsException() { var services = SetupTestServices(new TranslateDelegatingHandler()); var provider = services.BuildServiceProvider(); var service = provider.GetRequiredService(); await Assert.ThrowsAsync( () => service.TranslateAsync("Hello", "xx")); } ``` ## avancerad mönster : Konfigurerade handler För mer flexibilitet, kan du skapa handler som accepterar konfigurationen: ```csharp public class ConfigurableHandler : DelegatingHandler { private readonly Dictionary>> _routes; public ConfigurableHandler() { _routes = new Dictionary>>(); } public ConfigurableHandler WithRoute(string path, HttpStatusCode status) { _routes[path] = _ => Task.FromResult(new HttpResponseMessage(status)); return this; } public ConfigurableHandler WithRoute(string path, object responseBody) { _routes[path] = _ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = JsonContent.Create(responseBody) }); return this; } public ConfigurableHandler WithRoute( string path, Func> handler) { _routes[path] = handler; return this; } protected override async Task SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { var path = request.RequestUri?.AbsolutePath ?? ""; if (_routes.TryGetValue(path, out var handler)) return await handler(request); return new HttpResponseMessage(HttpStatusCode.NotFound); } } ``` Användning: ```csharp var handler = new ConfigurableHandler() .WithRoute("/api/users", new[] { new User("Alice"), new User("Bob") }) .WithRoute("/api/health", HttpStatusCode.OK) .WithRoute("/api/error", HttpStatusCode.InternalServerError); var client = new HttpClient(handler); ``` ## Varför välja DelegatingHandler över Mocks? | Aspect | Moq-based Mocking | DelegatingHandler | |--------|-------------------|-------------------| | **Kodlinjer** | Många | Få | | **Läsbarhet** | låga ( festligt tungt) | högt M(just C | **Återanvändbarhet** | Fattig | Utmärkt | | **Debugging** | Svårare ( skämt magi ) | enkelt ( gå genom | **Refactoring** | Brittle | Robust | | **Lärningskurva** | Steeper | ( | Moq APIs | ) | МSK3 | Minimal || | **beroenden** | kräver Moq | Ingen ( byggt - i ) ## När mocking fortfarande verkar vettigt För att vara rättvis, så finns det scenarioer där Moqs mockerning fortfarande kan vara lämpligt. 1. **Ett-lös enkla svar** - Om du behöver en enda handlere för ett svar en gång , Moq kan vara snabbare 2. **Bekräftelse** - MoqM SK1s `Verify()` är användbar för att bevisa att samtalen gjorts 3. **Existerande kodbas** - Om ditt team redan har en omfattande Moq-infrastruktur För att verifiera, kan du lägga till den i DelegatingHandler också: ```csharp public class VerifyingHandler : DelegatingHandler { public List ReceivedRequests { get; } = new(); protected override Task SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { ReceivedRequests.Add(request); return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)); } } ``` ## Slutsatsen Att använda `DelegatingHandler` för HttpClient-testning ger dig - **Kompaktkod** - Ingen mocking ram ceremoni - **Läsbara tester** - Bara regelbundna CM SK1 klass - **Handler som kan användas igen** - dela genom testklassen - **Låg dämpning** - Set breakpoints , step through code - **Null beroenden** - Det' är inbyggt i .NET Nästa gång du når för `Mock`, överväg om en enkel `DelegatingHandler` skulle tjäna dig bättre. ditt framtida själv ( och dina lagkamrater ) kommer tacka dig för den renare Se testprojektet i denna lösning för verkliga exempel på detta mönster i verkligheten