ASP.NET Core 7.0控制器测试：如何Mock外部服务避免数据库写入

1. 控制器硬编码实例化具体类，未依赖抽象：你的控制器中直接通过CreatePaymentAction(paymentInfo)创建PaymentAction实例，这种硬编码方式无法被Moq拦截替换，控制器始终会调用真实的PaymentAction执行数据库操作。
2. Mock对象未接入控制器执行流程：测试代码中创建了Mock<PaymentAction>，但没有将这个Mock实例关联到控制器的逻辑链里，控制器完全不知道Mock对象的存在，自然会走真实业务逻辑。

核心思路是通过依赖注入+抽象接口，让控制器依赖抽象而非具体实现，这样测试时就能用Mock替换真实服务。

步骤1：定义抽象接口 #

为PaymentAction定义接口，让Moq可以Mock这个抽象层：

public interface IPaymentAction
{
    Task<MyResponse> Execute();
}

// 修改PaymentAction实现该接口
public class PaymentAction : IPaymentAction
{
    private readonly PaymentInfo _paymentInfo;

    public PaymentAction(PaymentInfo paymentInfo)
    {
        _paymentInfo = paymentInfo;
    }

    public Task<MyResponse> Execute()
    {
        // 原有的写入数据库逻辑
    }
}

步骤2：引入工厂服务处理参数依赖 #

因为PaymentAction需要从请求体获取PaymentInfo参数，直接注入IPaymentAction无法动态传参，所以定义工厂接口来创建实例：

public interface IPaymentActionFactory
{
    IPaymentAction CreatePaymentAction(PaymentInfo paymentInfo);
}

// 实现真实工厂
public class PaymentActionFactory : IPaymentActionFactory
{
    public IPaymentAction CreatePaymentAction(PaymentInfo paymentInfo)
    {
        return new PaymentAction(paymentInfo);
    }
}

步骤3：改造控制器，注入工厂 #

修改控制器构造函数，注入IPaymentActionFactory，通过工厂创建IPaymentAction实例：

[ApiController]
[Route("api/payment")]
public class PaymentController : ControllerBase
{
    private readonly ILogger _logger;
    private readonly IPaymentActionFactory _paymentActionFactory;

    public PaymentController(ILogger logger, IPaymentActionFactory paymentActionFactory)
    {
        _logger = logger;
        _paymentActionFactory = paymentActionFactory;
    }

    [HttpPost("createPayment")]
    public Task<MyResponse> CreatePayment([FromBody] PaymentInfo paymentInfo)
    {
        IPaymentAction action = _paymentActionFactory.CreatePaymentAction(paymentInfo);
        return action.Execute();
    }
}

步骤4：在测试中Mock工厂与Action #

使用WebApplicationFactory配置测试服务，替换真实的IPaymentActionFactory为Mock实例：

public class PaymentControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public PaymentControllerTests(WebApplicationFactory<Program> factory)
    {
        // 配置Mock服务
        _client = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // 创建Mock的IPaymentAction
                var mockPaymentAction = new Mock<IPaymentAction>();
                mockPaymentAction.Setup(m => m.Execute())
                    .ReturnsAsync(new MyResponse 
                    { 
                        Message = "Success", 
                        Code = "200", 
                        Status = "Ok" 
                    });

                // 创建Mock工厂，返回Mock的Action
                var mockFactory = new Mock<IPaymentActionFactory>();
                mockFactory.Setup(f => f.CreatePaymentAction(It.IsAny<PaymentInfo>()))
                    .Returns(mockPaymentAction.Object);

                // 替换DI容器中的工厂服务
                services.AddSingleton(mockFactory.Object);
            });
        }).CreateClient();
    }

    [Fact]
    public async Task CreatePaymentReturnsSuccessCode()
    {
        // Arrange
        PaymentInfo paymentInfo = CreateTestPaymentInfo();
        var content = new StringContent(
            JsonConvert.SerializeObject(paymentInfo), 
            Encoding.UTF8, 
            "application/json");

        // Act
        var response = await _client.PostAsync("api/payment/createPayment", content);
        var responseContent = await response.Content.ReadAsAsync<MyResponse>();

        // Assert
        Assert.Equal("Success", responseContent.Message);
        Assert.Null(responseContent.Exception);
        Assert.Equal("Ok", responseContent.Status);
    }

    private PaymentInfo CreateTestPaymentInfo()
    {
        // 返回测试用的PaymentInfo实例，填充必要属性
        return new PaymentInfo 
        { 
            Amount = 100.00m,
            OrderId = "TEST_ORDER_001"
        };
    }
}

替代方案（不推荐，仅作参考） #

如果不想引入工厂，可以将PaymentAction的Execute方法改为虚方法，然后Mock具体类，但这种方式耦合度较高：

// 修改PaymentAction的Execute为虚方法
public class PaymentAction
{
    public PaymentAction(PaymentInfo paymentInfo) { }

    public virtual Task<MyResponse> Execute()
    {
        // 原逻辑
    }
}

测试时需要注入能创建MockPaymentAction的工厂，但本质还是依赖具体类，不如接口抽象灵活。

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