Dapper单元测试怎么写 Dapper仓储层单元测试方法

Dapper是一款轻量级的ORM框架，在.NET项目中常被用于仓储层的数据访问操作。对Dapper仓储层编写单元测试时，核心目标是验证仓储层的数据操作逻辑是否符合预期，同时避免依赖真实的数据库环境，减少测试的不确定性和执行成本。

Dapper仓储层单元测试的核心思路

仓储层的核心逻辑是调用Dapper的扩展方法执行SQL语句，完成数据的增删改查操作。要编写单元测试，首先需要解决两个问题：一是隔离真实的数据库连接，避免测试对生产数据库造成影响；二是模拟Dapper的方法调用，验证传入的SQL和参数是否正确，或者模拟返回预期的查询结果。

常见的实现方式有两种：一种是使用内存数据库（如SQLite的内存模式）替代真实数据库，执行真实的SQL逻辑；另一种是通过抽象数据库连接和Dapper的调用，使用Mock框架模拟相关依赖。

基于内存数据库的测试方案

SQLite的内存模式可以模拟真实的数据库环境，且数据仅在连接生命周期内存在，非常适合单元测试场景。首先需要定义仓储层的接口和基础实现：

// 仓储层接口定义
public interface IUserRepository
{
    Task<User> GetByIdAsync(int id);
    Task<int> AddAsync(User user);
}

// 用户实体类
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

// 仓储层实现
public class UserRepository : IUserRepository
{
    private readonly IDbConnection _connection;

    public UserRepository(IDbConnection connection)
    {
        _connection = connection;
    }

    public async Task<User> GetByIdAsync(int id)
    {
        var sql = "SELECT Id, Name, Age FROM User WHERE Id = @Id";
        return await _connection.QueryFirstOrDefaultAsync<User>(sql, new { Id = id });
    }

    public async Task<int> AddAsync(User user)
    {
        var sql = "INSERT INTO User (Name, Age) VALUES (@Name, @Age); SELECT last_insert_rowid()";
        return await _connection.ExecuteScalarAsync<int>(sql, user);
    }
}

接下来编写单元测试，使用SQLite内存数据库作为数据源：

using Dapper;
using Microsoft.Data.Sqlite;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Data;
using System.Threading.Tasks;

[TestClass]
public class UserRepositoryTests
{
    // 创建内存数据库连接
    private IDbConnection CreateInMemoryConnection()
    {
        var connection = new SqliteConnection("Data Source=:memory:");
        connection.Open();
        // 创建测试表
        connection.Execute(@"CREATE TABLE User (
            Id INTEGER PRIMARY KEY AUTOINCREMENT,
            Name TEXT NOT NULL,
            Age INTEGER NOT NULL
        )");
        return connection;
    }

    [TestMethod]
    public async Task GetByIdAsync_WhenUserExists_ReturnsUser()
    {
        // 准备
        using var connection = CreateInMemoryConnection();
        var repository = new UserRepository(connection);
        // 插入测试数据
        await connection.ExecuteAsync("INSERT INTO User (Name, Age) VALUES ('张三', 25)");

        // 执行
        var result = await repository.GetByIdAsync(1);

        // 断言
        Assert.IsNotNull(result);
        Assert.AreEqual("张三", result.Name);
        Assert.AreEqual(25, result.Age);
    }

    [TestMethod]
    public async Task AddAsync_ValidUser_ReturnsNewId()
    {
        // 准备
        using var connection = CreateInMemoryConnection();
        var repository = new UserRepository(connection);
        var user = new User { Name = "李四", Age = 30 };

        // 执行
        var newId = await repository.AddAsync(user);

        // 断言
        Assert.IsTrue(newId > 0);
        var insertedUser = await connection.QueryFirstOrDefaultAsync<User>("SELECT Id, Name, Age FROM User WHERE Id = @Id", new { Id = newId });
        Assert.IsNotNull(insertedUser);
        Assert.AreEqual("李四", insertedUser.Name);
    }
}

基于Mock框架的测试方案

如果不想依赖真实的数据库执行环境，可以使用Moq等Mock框架模拟IDbConnection和Dapper的方法调用，直接验证仓储层的逻辑是否符合预期：

using Dapper;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System.Data;
using System.Threading.Tasks;

[TestClass]
public class UserRepositoryMockTests
{
    private Mock<IDbConnection> _mockConnection;
    private IUserRepository _repository;

    [TestInitialize]
    public void Setup()
    {
        _mockConnection = new Mock<IDbConnection>();
        _repository = new UserRepository(_mockConnection.Object);
    }

    [TestMethod]
    public async Task GetByIdAsync_CallsCorrectSqlAndParameters()
    {
        // 准备
        User expectedUser = null;
        _mockConnection.Setup(c => c.QueryFirstOrDefaultAsync<User>(
            It.IsAny<string>(),
            It.IsAny<object>(),
            It.IsAny<IDbTransaction>(),
            It.IsAny<int?>(),
            It.IsAny<CommandType?>()
        )).ReturnsAsync(expectedUser);

        // 执行
        await _repository.GetByIdAsync(1);

        // 断言：验证调用的SQL和参数
        _mockConnection.Verify(c => c.QueryFirstOrDefaultAsync<User>(
            "SELECT Id, Name, Age FROM User WHERE Id = @Id",
            It.Is<object>(p => ((dynamic)p).Id == 1),
            null,
            null,
            null
        ), Times.Once);
    }

    [TestMethod]
    public async Task AddAsync_CallsCorrectSqlAndParameters()
    {
        // 准备
        var newId = 5;
        _mockConnection.Setup(c => c.ExecuteScalarAsync<int>(
            It.IsAny<string>(),
            It.IsAny<object>(),
            It.IsAny<IDbTransaction>(),
            It.IsAny<int?>(),
            It.IsAny<CommandType?>()
        )).ReturnsAsync(newId);

        var user = new User { Name = "王五", Age = 28 };

        // 执行
        var result = await _repository.AddAsync(user);

        // 断言
        Assert.AreEqual(newId, result);
        _mockConnection.Verify(c => c.ExecuteScalarAsync<int>(
            "INSERT INTO User (Name, Age) VALUES (@Name, @Age); SELECT last_insert_rowid()",
            It.Is<object>(p => ((dynamic)p).Name == "王五" && ((dynamic)p).Age == 28),
            null,
            null,
            null
        ), Times.Once);
    }
}

两种方案的适用场景

• 内存数据库方案适合需要验证SQL语句逻辑正确性的场景，能够更真实地模拟数据操作流程，测试覆盖更贴近实际执行情况。
• Mock框架方案适合只需要验证仓储层调用参数的场景，测试执行速度更快，不需要启动数据库环境，适合对调用逻辑做快速验证。

在实际项目中，可以根据测试目标选择合适的方案，也可以两种方案结合使用，既保证SQL逻辑的正确性，也验证调用参数的准确性。

Dapper单元测试仓储层SQL_Mapper修改时间：2026-07-04 19:09:22