如何用Moq模拟HttpClient的RequestClientCredentialsTokenAsync扩展方法？

问题场景 #

业务代码中使用IdentityModel的扩展方法请求客户端凭据令牌：

var tokenResponse = await _httpClient.RequestClientCredentialsTokenAsync(requestContent);

尝试用Moq模拟HttpClient时编写了如下代码：

var httpClient = new Mock<HttpClient>();

var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
    Content = JsonContent.Create(new
    {
        access_token = "token",
        expires_in = 5000
    })
};

var tokenResponse = ProtocolResponse.FromHttpResponseAsync<TokenResponse>(httpResponseMessage);

httpClient.Setup(x => x.RequestClientCredentialsTokenAsync(It.IsAny<ClientCredentialsTokenRequest>(), It.IsAny<CancellationToken>())).Returns(tokenResponse);

运行时抛出异常：

System.NotSupportedException : Unsupported expression: x => x.RequestClientCredentialsTokenAsync(It.IsAny(), It.IsAny())
Extension methods (here: HttpClientTokenRequestExtensions.RequestClientCredentialsTokenAsync) may not be used in setup / verification expressions.

原因分析 #

Moq无法直接模拟扩展方法，因为扩展方法本质是静态方法，并非HttpClient类的实例方法，它只是通过静态类包装对HttpClient底层方法（如SendAsync）的调用，因此不能直接对扩展方法设置Mock。

解决方案 #

方案1：模拟HttpClient的SendAsync方法 #

既然扩展方法最终会调用HttpClient.SendAsync向身份服务的令牌端点发送请求，我们可以拦截这个底层方法，返回预先构造的响应。

示例代码：

var mockHttpClient = new Mock<HttpClient>();

// 构造符合IdentityModel格式的令牌响应内容
var mockTokenContent = JsonContent.Create(new
{
    access_token = "mock_bearer_token",
    expires_in = 3600,
    token_type = "Bearer"
});

var mockResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
    Content = mockTokenContent
};

// 设置SendAsync的Mock，匹配令牌端点的POST请求
mockHttpClient.Setup(client => client.SendAsync(
    It.Is<HttpRequestMessage>(req => 
        req.Method == HttpMethod.Post && 
        req.RequestUri.ToString().EndsWith("/connect/token")), // 匹配实际的令牌端点路径
    It.IsAny<CancellationToken>()))
.ReturnsAsync(mockResponse);

// 测试调用扩展方法
var tokenRequest = new ClientCredentialsTokenRequest
{
    Address = "https://your-identity-server/connect/token",
    ClientId = "test-client",
    ClientSecret = "test-secret",
    Scope = "api.access"
};

var result = await mockHttpClient.Object.RequestClientCredentialsTokenAsync(tokenRequest);
// result.AccessToken 将是 "mock_bearer_token"

方案2：封装扩展方法为可注入接口 #

通过抽象层封装令牌请求逻辑，业务代码依赖抽象接口而非直接使用HttpClient，这样测试时可以直接Mock接口。

步骤1：定义抽象接口

public interface ITokenProvider
{
    Task<TokenResponse> GetClientCredentialsTokenAsync(
        ClientCredentialsTokenRequest request, 
        CancellationToken cancellationToken = default);
}

步骤2：实现接口

public class IdentityModelTokenProvider : ITokenProvider
{
    private readonly HttpClient _httpClient;

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

    public async Task<TokenResponse> GetClientCredentialsTokenAsync(
        ClientCredentialsTokenRequest request, 
        CancellationToken cancellationToken = default)
    {
        return await _httpClient.RequestClientCredentialsTokenAsync(request, cancellationToken);
    }
}

步骤3：业务代码依赖接口

public class YourBusinessService
{
    private readonly ITokenProvider _tokenProvider;

    public YourBusinessService(ITokenProvider tokenProvider)
    {
        _tokenProvider = tokenProvider;
    }

    public async Task ExecuteBusinessLogic()
    {
        var tokenRequest = new ClientCredentialsTokenRequest
        {
            // 填充请求参数
        };
        var tokenResponse = await _tokenProvider.GetClientCredentialsTokenAsync(tokenRequest);
        // 使用令牌执行后续逻辑
    }
}

步骤4：测试时Mock接口

var mockTokenProvider = new Mock<ITokenProvider>();
mockTokenProvider.Setup(provider => provider.GetClientCredentialsTokenAsync(
    It.IsAny<ClientCredentialsTokenRequest>(), 
    It.IsAny<CancellationToken>()))
.ReturnsAsync(new TokenResponse
{
    AccessToken = "mock_token",
    ExpiresIn = 3600,
    TokenType = "Bearer"
});

var businessService = new YourBusinessService(mockTokenProvider.Object);
// 执行测试逻辑

方案对比 #

• 方案1：无需修改现有业务代码，直接模拟底层HTTP请求，但需要匹配令牌端点的请求特征，灵活性稍弱。
• 方案2：符合依赖注入原则，测试逻辑更清晰，后续更换令牌获取方式时无需修改业务代码，但需要额外的抽象层实现。

内容的提问来源于stack exchange，提问作者Bruno Martins