Testing HttpClient

Due to its peculiar architecture, testing components depending on HttpClient is quite complicated.
To understand the challenges, it is important to keep in mind that HttpClient is not a service that can be mocked (in fact, it does not implement any interface), rather a facade around a pipeline of instances of HttpMessageHandler subclasses. Here is a series of posts by Steve Gordon that touch the complexity of the HttpClient and related components.
Mocking HttpClient in reality equates to creating an instance of HttpClient with a fake HttpMessageHandler. Unfortunately, this is easier said than done as there are many aspects to be taken into consideration when creating a fake HttpMessageHandler.
The library MockHttp exposes a subclass of the HttpMessageHandler abstract class specifically designed to facilitate unit testing, providing a fluent configuration API. Since the system under test is consuming the HttpClient, it will remain unaware that the MockHttpMessageHandler is being used.
Let's consider this service using HttpClient as test subject
public class Service
{
    private readonly HttpClient _http;
​
    public Service(HttpClient http)
    {
        _http = http ?? throw new ArgumentNullException(nameof(http));
    }
​
    public Task<string> GetStringAsync(Uri uri)
    {
        return _http.GetStringAsync(uri);
    }
}
We can write a test that asserts that GetStringAsync retrieves the content from a certain URI and returns it as string. By using MockHttp, we can arrange the handler so that when a GET request is issued to the given URI, a given content is returned.
[Test]
public async Task GetStringAsync_uses_HttpClient_to_get_content_from_given_URI()
{
    // ARRANGE
    var fixture = new Fixture();
    var testUri = fixture.Create<Uri>();
    var expectedResult = fixture.Create<string>();
​
    var handler = new MockHttpMessageHandler();
    handler.When(HttpMethod.Get, testUri.ToString())
           .Respond(HttpStatusCode.OK, new StringContent(expectedResult));
​
    var http = handler.ToHttpClient();
​
    var sut = new Service(http);
​
    // ACT
    var result = await sut.GetStringAsync(testUri);
​
    // ASSERT
    Assert.That(result, Is.EqualTo(expectedResult));
}
The same test can be written in a much more concise form by leveraging a glue-library for AutoFixture that uses MockHttp. This library can be obtained from NuGet under the name of Kralizek.AutoFixture.Extensions.MockHttp. The library is built around a specimen builder that, when asked for an HttpClient, creates one that uses a MockHttpMessageHandler internally. Since the MockHttpMessageHandler is resolved using AutoFixture, we can leverage patterns like freezing and injection to retain access to the internal instance.
[Test]
public async Task GetStringAsync_uses_HttpClient_to_get_content_from_given_URI()
{
    // ARRANGE
    var fixture = new Fixture().AddMockHttp();
​
    var testUri = fixture.Create<Uri>();
    var expectedResult = fixture.Create<string>();
​
    var handler = fixture.Freeze<MockHttpMessageHandler>();
    handler.When(HttpMethod.Get, testUri.ToString())
           .Respond(HttpStatusCode.OK, new StringContent(expectedResult));
​
    var sut = fixture.Create<Service>();
​
    // ACT
    var result = await sut.GetStringAsync(testUri);
​
    // ASSERT
    Assert.That(result, Is.EqualTo(expectedResult));
}
Things get really interesting when we combine MockHttp with a AutoData attribute
[AttributeUsage(AttributeTargets.Method)]
public class HttpAutoDataAttribute : AutoDataAttribute
{
    public HttpAutoDataAttribute() : base (CreateFixture) {}
​
    private IFixture CreateFixture()
    {
        var fixture = new Fixture();
​
        fixture.AddMockHttp();
​
        return fixture;
    }
}
With the attribute defined, we can rewrite the unit test like this:
[Test, HttpAutoData]
public async Task GetStringAsync_uses_HttpClient_to_get_content_from_given_URI([Frozen] MockHttpMessageHandler handler, Service sut, Uri testUri, string expectedResult)
{
    // ARRANGE
    handler.When(HttpMethod.Get, testUri.ToString())
           .Respond(HttpStatusCode.OK, new StringContent(expectedResult));
​
    // ACT
    var result = await sut.GetStringAsync(testUri);
​
    // ASSERT
    Assert.That(result, Is.EqualTo(expectedResult));
}
As shown in the snippet above, by leveraging the integration between AutoFixture, NUnit and MockHttp, it is possible to write very concise yet powerful tests for components using the HttpClient class and its related components.
HttpClientFactory
To face some of the issues caused by bad usage of HttpClient (like socket exhaustion and DNS cache pinning), Microsoft included in .NET 2.1 a new API often referred to as HttpClientFactory.
Developers can leverage the new API in two ways:
by instructing the dependency injection engine to use the HttpClientFactory when requested an instance of HttpClient
by replacing the dependency to be a IHttpClientFactory and use it to fetch an instance of HttpClient
Since the first approach deosn't alter the test subject, the same setup as shown above can be used.
On the other hand, consuming an IHttpClientFactory requires some changes to the unit tests.
Here is the test subject modified so that it consumes an IHttpClientFactory.
public class Service
{
    private readonly IHttpClientFactory _httpFactory;
​
    public Service(IHttpClientFactory httpFactory)
    {
        _httpFactory = httpFactory ?? throw new ArgumentNullException(nameof(httpFactory));
    }
​
    public Task<string> GetStringAsync(Uri uri)
    {
        var http = _httpFactory.CreateClient(nameof(Service));
​
        return http.GetStringAsync(uri);
    }
}
Since we're dealing with an interface, we can use Moq to build a test fake.
public async Task GetStringAsync_uses_HttpClient_to_get_content_from_given_URI()
{
    // ARRANGE
    var fixture = new Fixture();
    var testUri = fixture.Create<Uri>();
    var expectedResult = fixture.Create<string>();
​
    var handler = new MockHttpMessageHandler();
    handler.When(HttpMethod.Get, testUri.ToString())
           .Respond(HttpStatusCode.OK, new StringContent(expectedResult));
​
    var http = handler.ToHttpClient();
​
    var mockHttpClientFactory = new Mock<IHttpClientFactory>();
    mockHttpClientFactory.Setup(p => p.CreateClient(It.IsAny<string>())).Returns(http);
​
    var sut = new Service(mockHttpClientFactory.Object);
​
    // ACT
    var result = await sut.GetStringAsync(testUri);
​
    // ASSERT
    Assert.That(result, Is.EqualTo(expectedResult));
}
Quite interestingly, when converting the unit test above into one leveraging the AutoData attribute, we get the exact same unit test as our example with a HttpClient. The complexity of IHttpClientFactory.CreateClient is handled automatically by Moq, once AutoMoq is configured accordingly.
[AttributeUsage(AttributeTargets.Method)]
public class HttpAutoDataAttribute : AutoDataAttribute
{
    public HttpAutoDataAttribute() : base (CreateFixture) {}
​
    private IFixture CreateFixture()
    {
        var fixture = new Fixture();
​
        fixture.AddMockHttp();
​
        fixture.Customize(new AutoMoqCustomization { ConfigureMembers = true, GenerateDelegates = true });
​
        return fixture;
    }
}
​
[Test, HttpAutoData]
public async Task GetStringAsync_uses_HttpClient_to_get_content_from_given_URI([Frozen] MockHttpMessageHandler handler, Service sut, Uri testUri, string expectedResult)
{
    // ARRANGE
    handler.When(HttpMethod.Get, testUri.ToString())
           .Respond(HttpStatusCode.OK, new StringContent(expectedResult));
​
    // ACT
    var result = await sut.GetStringAsync(testUri);
​
    // ASSERT
    Assert.That(result, Is.EqualTo(expectedResult));
}
AutoFixture - Previous
Extending AutoFixture
Last modified 2yr ago