单元测试无法为扩展方法配置Mock，求解决方案

问题场景 #

编写ParticipantsController单元测试时，尝试Mock IDbConnection的LoadSingleByIdAsync和IDbConnectionFactory的OpenAsync扩展方法，触发Mock配置失效报错。

测试代码 #

namespace Producer.UnitTests.Controllers
{
    public class ParticipantsControllerTests
    {
        private readonly Mock<IDbConnectionFactory> _mockDbConnectionFactory;
        private readonly Mock<ILogger<Participant>> _mockLogger;
        private readonly Mock<IMapper> _mapper;
        public ParticipantsControllerTests()
        {
            _mockDbConnectionFactory = new Mock<IDbConnectionFactory>();
            _mockLogger = new Mock<ILogger<Participant>>();
            _mapper = new Mock<IMapper>();
        }

        [Fact]
        public async Task Get_ShouldReturnOkResponse_WhenIdExists()
        {
            var expectedSport = new Participant { Id = 1, Name = "Matan"};
            var mockDb = new Mock<IDbConnection>();
            mockDb.Setup(x => x.LoadSingleByIdAsync<Participant>(1, It.IsAny<string[]>(), It.IsAny<CancellationToken>())).ReturnsAsync(expectedSport);
            _mockDbConnectionFactory.Setup(x => x.OpenAsync(It.IsAny<CancellationToken>())).ReturnsAsync(mockDb.Object);
            var controller = new ParticipantsController(_mockDbConnectionFactory.Object, _mockLogger.Object, _mapper.Object);

            var result = await controller.Get(1);

            Assert.IsType<OkObjectResult>(result);
            var okResult = (OkObjectResult)result;
            var sport = (Sport)okResult.Value;
            Assert.Equal(expectedSport.Id, sport.Id);
            Assert.Equal(expectedSport.Name, sport.Name);
        }
    }
}

报错信息 #

System.NotSupportedException : Unsupported expression: x => x.LoadSingleByIdAsync((object)1, It.IsAny<string[]>(), It.IsAny())
Extension methods (here: OrmLiteReadApiAsync.LoadSingleByIdAsync) may not be used in setup / verification expressions.

解决方案 #

方法1：使用OrmLite内存数据库替代Mock #

OrmLite原生支持内存数据库（如SqliteMemoryDialect），可以创建真实的内存连接，绕开Mock静态扩展方法的限制，同时更贴近真实业务场景：

[Fact]
public async Task Get_ShouldReturnOkResponse_WhenIdExists()
{
    // 初始化内存数据库连接工厂
    var dbFactory = new OrmLiteConnectionFactory(":memory:", SqliteMemoryDialect.Provider);
    using var db = dbFactory.Open();
    // 创建表并插入测试数据
    db.CreateTable<Participant>();
    var expectedParticipant = new Participant { Id = 1, Name = "Matan" };
    db.Insert(expectedParticipant);

    // 配置Mapper映射规则
    _mapper.Setup(m => m.Map<Sport>(expectedParticipant))
           .Returns(new Sport { Id = expectedParticipant.Id, Name = expectedParticipant.Name });

    // 初始化控制器，传入真实内存DB工厂
    var controller = new ParticipantsController(dbFactory, _mockLogger.Object, _mapper.Object);

    var result = await controller.Get(1);

    Assert.IsType<OkObjectResult>(result);
    var okResult = (OkObjectResult)result;
    var sport = (Sport)okResult.Value;
    Assert.Equal(expectedParticipant.Id, sport.Id);
    Assert.Equal(expectedParticipant.Name, sport.Name);
}

方法2：封装数据访问逻辑到自定义接口 #

将依赖OrmLite扩展方法的操作封装到自定义接口中，通过依赖注入解耦，从而可以直接Mock自定义接口：

1. 定义数据访问接口：

public interface IParticipantRepository
{
    Task<Participant> GetByIdAsync(int id, CancellationToken cancellationToken = default);
}

2. 实现接口，内部调用OrmLite扩展方法：

public class ParticipantRepository : IParticipantRepository
{
    private readonly IDbConnectionFactory _dbConnectionFactory;

    public ParticipantRepository(IDbConnectionFactory dbConnectionFactory)
    {
        _dbConnectionFactory = dbConnectionFactory;
    }

    public async Task<Participant> GetByIdAsync(int id, CancellationToken cancellationToken = default)
    {
        using var db = await _dbConnectionFactory.OpenAsync(cancellationToken);
        return await db.LoadSingleByIdAsync<Participant>(id, cancellationToken: cancellationToken);
    }
}

3. 修改ParticipantsController依赖自定义接口：

public class ParticipantsController : ControllerBase
{
    private readonly IParticipantRepository _participantRepository;
    private readonly ILogger<Participant> _logger;
    private readonly IMapper _mapper;

    public ParticipantsController(IParticipantRepository participantRepository, ILogger<Participant> logger, IMapper mapper)
    {
        _participantRepository = participantRepository;
        _logger = logger;
        _mapper = mapper;
    }

    public async Task<IActionResult> Get(int id)
    {
        var participant = await _participantRepository.GetByIdAsync(id);
        if (participant == null) return NotFound();
        var sport = _mapper.Map<Sport>(participant);
        return Ok(sport);
    }
}

4. 单元测试中Mock自定义接口：

[Fact]
public async Task Get_ShouldReturnOkResponse_WhenIdExists()
{
    var expectedParticipant = new Participant { Id = 1, Name = "Matan" };
    var mockRepo = new Mock<IParticipantRepository>();
    mockRepo.Setup(r => r.GetByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(expectedParticipant);

    _mapper.Setup(m => m.Map<Sport>(expectedParticipant))
           .Returns(new Sport { Id = expectedParticipant.Id, Name = expectedParticipant.Name });

    var controller = new ParticipantsController(mockRepo.Object, _mockLogger.Object, _mapper.Object);

    var result = await controller.Get(1);

    Assert.IsType<OkObjectResult>(result);
    var okResult = (OkObjectResult)result;
    var sport = (Sport)okResult.Value;
    Assert.Equal(expectedParticipant.Id, sport.Id);
    Assert.Equal(expectedParticipant.Name, sport.Name);
}

这种方式遵循依赖倒置原则，既提升代码可维护性，也让单元测试更灵活。

方法3：使用Moq的SetupStatic静态Mock（仅Moq 4.16+） #

如果必须Mock扩展方法，可使用Moq的SetupStatic功能，但该方式会污染全局测试环境，不推荐在多测试并行场景下使用：

[Fact]
public async Task Get_ShouldReturnOkResponse_WhenIdExists()
{
    var expectedParticipant = new Participant { Id = 1, Name = "Matan" };
    var mockDb = new Mock<IDbConnection>();
    
    // 静态Mock OrmLite扩展方法
    using var mock = Mock.SetupStatic<OrmLiteReadApiAsync>();
    mock.Setup(x => x.LoadSingleByIdAsync<Participant>(mockDb.Object, 1, It.IsAny<string[]>(), It.IsAny<CancellationToken>()))
        .ReturnsAsync(expectedParticipant);

    _mockDbConnectionFactory.Setup(x => x.OpenAsync(It.IsAny<CancellationToken>())).ReturnsAsync(mockDb.Object);
    _mapper.Setup(m => m.Map<Sport>(expectedParticipant))
           .Returns(new Sport { Id = expectedParticipant.Id, Name = expectedParticipant.Name });

    var controller = new ParticipantsController(_mockDbConnectionFactory.Object, _mockLogger.Object, _mapper.Object);

    var result = await controller.Get(1);

    Assert.IsType<OkObjectResult>(result);
    var okResult = (OkObjectResult)result;
    var sport = (Sport)okResult.Value;
    Assert.Equal(expectedParticipant.Id, sport.Id);
    Assert.Equal(expectedParticipant.Name, sport.Name);
}

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