# Unit Testing HttpClient WITHOUT Mocks

<datetime class="hidden">2025-11-29T07:00</datetime>

<!--category-- xUnit, Unit Testing, HttpClient -->
## Введение

Коли тестується код, який використовує `HttpClient`, традиційний підхід включає в себе посмішування `HttpMessageHandler` використовуючи такі фреймворки, як Moq. В той час, як це працює , це може бути безглуздо МSK2 церемонія M SK3 важка , і, чесно кажучи, трошки потворна MSC5 там МСК6 є чистіша альтернатива М СК7 використаючи `DelegatingHandler` для створення тест-хендерів, які поводяться як справжні HTTP кінцеві точки.

В цьому пості я покажу вам, чому ви можете повністю пропустити макети і використовувати `DelegatingHandler` для більш читабельної, підтримуючоїM SK1 і компактного тестового коду.

[TOC]

## Проблема з переміщенням HttpMessageHandler

Ось що типове `HttpMessageHandler` сміх виглядає так само, як у Moq:

```csharp
var mockHandler = new Mock<HttpMessageHandler>();
mockHandler.Protected()
    .Setup<Task<HttpResponseMessage>>(
        "SendAsync",
        ItExpr.Is<HttpRequestMessage>(x => x.RequestUri.ToString().Contains("api/send")),
        ItExpr.IsAny<CancellationToken>())
    .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);
```

У цьому є декілька проблем:

1. **Вербоза** - Багато котла для того, що має бути простою поведінкою
2. **Церемонія захисту методу** - Вам потрібно `Protected()` і `ItExpr` тому що `SendAsync` захищена
3. **Нелегко читати** - Фактична логіка тесту закопана в церемонії налаштування
4. **Не можна відновлювати** - Кожен тест потребує подібного коду налаштування
5. **Brittle** - Легко отримати неправильне ім 'я методу, заснованого на стріці

## Альтернатива DelegatingHandler

`DelegatingHandler` це вбудована-в klasiі .NET, розроблена саме для цього. - перехоплює HTTP-запити перед тим, як вони потрапляють в мережу.

Тут МСК0 має ту ж саму функцію, що і `DelegatingHandler`:

```csharp
public class EchoHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> 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")
        };
    }
}
```

Використовуючи його:

```csharp
var client = new HttpClient(new EchoHandler());
```

МSK0 - це воно. МSK1 - Ніяких смішних рамок, МSK2 - ні захищеної спортивної гимнастики, МСК3 - ні струн, MСК4 - назви методів, М СК5

## Справжній-World Example: Працівник Translation Service

Тут' - більш складний приклад тестувальника послуг перекладу

```csharp
public class TranslateDelegatingHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> 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<HttpResponseMessage> HandleTranslate(HttpRequestMessage request)
    {
        var content = await request.Content!.ReadFromJsonAsync<TranslateRequest>();

        // 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)
        };
    }
}
```

Цей обладнатель:

- Руйоти різні шляхи до різних поведінок
- Десеріалізує зміст запиту для прийняття рішень
- Возв 'язує необхідні коди помилок для конкретних сценаріїв
- Це повністю читабельне і самодокументоване

## Установлення з ін 'єкцією залежності

Коли ми використовуємо `IHttpClientFactory` (, який ви маєте бути ), інтеграція тест-хендерів є простою

```csharp
public static IServiceCollection SetupTestServices(DelegatingHandler handler)
{
    var services = new ServiceCollection();

    services.AddHttpClient<ITranslationService, TranslationService>(client =>
    {
        client.BaseAddress = new Uri("https://test.local");
    })
    .ConfigurePrimaryHttpMessageHandler(() => handler);

    return services;
}
```

Тоді в ваших тестах:

```csharp
[Fact]
public async Task Translate_ReturnsTranslatedText()
{
    var services = SetupTestServices(new TranslateDelegatingHandler());
    var provider = services.BuildServiceProvider();
    var service = provider.GetRequiredService<ITranslationService>();

    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<ITranslationService>();

    await Assert.ThrowsAsync<HttpRequestException>(
        () => service.TranslateAsync("Hello", "xx"));
}
```

## Заawansований візерунок: Налагоджені мандрівники

Для більшої гнучкісті, ви можете створити обладначі, які приймають конфігурацію

```csharp
public class ConfigurableHandler : DelegatingHandler
{
    private readonly Dictionary<string, Func<HttpRequestMessage, Task<HttpResponseMessage>>> _routes;

    public ConfigurableHandler()
    {
        _routes = new Dictionary<string, Func<HttpRequestMessage, Task<HttpResponseMessage>>>();
    }

    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<HttpRequestMessage, Task<HttpResponseMessage>> handler)
    {
        _routes[path] = handler;
        return this;
    }

    protected override async Task<HttpResponseMessage> 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);
    }
}
```

Використовування:

```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);
```

## Чому вибирати DelegatingHandler над Mocks?

| Aspect МSK1 Moq-based Mocking | DelegatingHandler МSK4
|--------|-------------------|-------------------|
| **Ліни коду** МSK0 Багато | Трохи МSK2
| **Прочитаність** | Трохи нижчий МSK1ремонія важка МSK2 | високий
| **Повторюваність** МSK0 Небагато | Чудово |
| **Розладнання** | важче МSK1 чари для втілення МSK2 | Легко мSK4 пройти крізь МSK5 \|
| **Переробка** МSK0 Brittle | Robust |
| **Кривая навчання** | Steeper (Moq APIsM SK2 МSK3 Minimal МSK4
| **Відлежність** | Потрібний Moq МSK1 Нічого МSK2 збудований - в МSK4

## Коли посмішування все ще має сенс

Якщо бути чесним, то є сценарії, коли моки в стилі Moq , "-", можуть бути корисними.

1. **Один- без простих відповідей** - Якщо вам потрібен єдинийM SK1реакційний обладнатель один раз, встромний Moq може бути швидшим
2. **Перевірка** - MoqM SK1s `Verify()` є корисною для того, щоб довести, що виклики були проведені
3. **Поширена база коду** - Якщо у вашому команді вже є обширна інфраструктура Moq

Для перевірки, ви можете додати його до DelegingHandler також:

```csharp
public class VerifyingHandler : DelegatingHandler
{
    public List<HttpRequestMessage> ReceivedRequests { get; } = new();

    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        ReceivedRequests.Add(request);
        return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));
    }
}
```

## Завершення

Використовуючи `DelegatingHandler` для тестування HttpClient дає вам:

- **Компактний код** - Жодна церемония схвилькування
- **Тести, які можна читати** - Звичайні класи CM SK1
- **Переробні обладначі** - Поширювати тестові класи
- **Легке виправлення** - Установка розривних точок , крок через код
- **Нуль залежності** - It's вбудовані в .NET

Наступного разу, коли ви досягнете `Mock<HttpMessageHandler>`, розгляньмо, чи простий `DelegatingHandler` стане вам краще служити. ваше майбутнє я ( і ваші товариші з команди МSK2 подякуватимуть вам за чистіший МСК3 більш підтримувальний тестовий код М СК4

Погляньте на тестові проекти в цьому рішення для реальних прикладів цього візерунку в дії