How do I use HttpClient (C#) in a unit test?

Using HttpClient in a unit test in C# often involves creating mock responses for the HttpClient to return, rather than making actual HTTP calls. This is important because unit tests should be fast, reliable, and not dependent on external services.

To mock the behavior of HttpClient, you'll typically use a testing library like Moq and the HttpMessageHandler class. Starting with .NET Core, you can also use HttpClientFactory along with IHttpClientFactory for more advanced scenarios.

Here's an example using Moq to mock HttpMessageHandler which will be used by the HttpClient. We'll test a hypothetical UserService that calls an API to retrieve user data:

Step 1: Install the Moq NuGet Package

First, you need to install the Moq NuGet package if it's not already installed in your project. You can do this via the NuGet Package Manager or by running the following command in the Package Manager Console:

Install-Package Moq

Step 2: Create a Mock HttpMessageHandler

using Moq;
using Moq.Protected;
using System;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

// ...

// Mock the handler
var handlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
handlerMock
   .Protected()
   // Setup the PROTECTED method to mock
   .Setup<Task<HttpResponseMessage>>(
       "SendAsync",
       ItExpr.IsAny<HttpRequestMessage>(),
       ItExpr.IsAny<CancellationToken>()
   )
   // prepare the expected response of the mocked http call
   .ReturnsAsync(new HttpResponseMessage()
   {
       StatusCode = HttpStatusCode.OK,
       Content = new StringContent(@"{ ""name"": ""Test User"" }"),
   })
   .Verifiable();

Step 3: Create an Instance of HttpClient Using the Mock Handler

// Use the handler to create an instance of HttpClient
var httpClient = new HttpClient(handlerMock.Object)
{
    BaseAddress = new Uri("http://example.com/"),
};

Step 4: Create the Class to Be Tested

Here, we assume you have a UserService class, which uses HttpClient to fetch user data.

public class UserService
{
    private readonly HttpClient _httpClient;

    public UserService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<string> GetUserNameAsync()
    {
        var response = await _httpClient.GetAsync("/users/1");
        response.EnsureSuccessStatusCode();
        var content = await response.Content.ReadAsStringAsync();

        // Assuming the response is JSON and has a "name" field
        dynamic user = Newtonsoft.Json.JsonConvert.DeserializeObject(content);
        return user.name;
    }
}

Step 5: Create the Unit Test

Here's how you might write a unit test using xUnit and Moq to test the UserService's GetUserNameAsync method.

using Xunit;

// ...

public class UserServiceTests
{
    [Fact]
    public async Task GetUserNameAsync_ReturnsCorrectName()
    {
        // Arrange
        var httpClient = new HttpClient(handlerMock.Object)
        {
            BaseAddress = new Uri("http://example.com/"),
        };
        var userService = new UserService(httpClient);

        // Act
        var userName = await userService.GetUserNameAsync();

        // Assert
        Assert.Equal("Test User", userName);

        // also check that the 'SendAsync' method was called once with the correct Uri
        handlerMock.Protected().Verify(
            "SendAsync",
            Times.Exactly(1), // we expected a single external request
            ItExpr.Is<HttpRequestMessage>(req =>
                req.Method == HttpMethod.Get  // we expected a GET request
                && req.RequestUri.ToString().EndsWith("/users/1") // to this uri
            ),
            ItExpr.IsAny<CancellationToken>()
        );
    }
}

In this test, we're verifying that UserService.GetUserNameAsync correctly parses the "name" field from the JSON response, and also that it makes the correct HTTP request. The mock HttpMessageHandler ensures that no real HTTP request is made, and it provides a controlled response to the HttpClient.

By using a mock HttpMessageHandler, you can simulate various scenarios like different response statuses or response content to thoroughly test your code's handling of HTTP interactions.