C#业务代码单元测试如何验证异常分支中的事务回滚?

发布人:A5数据发布时间:2026-11-17 14:38阅读量:2

一次业务操作可能先写入订单,再写入明细;如果第二次写入失败,而代码没有用同一个数据库事务包住两次 SaveChangesAsync,订单头就可能已经留在数据库中。验证异常分支的回滚,不能只看方法是否抛出异常:还要确认事务回滚被触发,并从数据库重新读取,检查失败操作产生的数据确实不存在。

先区分单元测试与数据库回滚验证

EF Core 默认会为一次 SaveChangesAsync 中的写入提供事务保护,但这不等于多次 SaveChangesAsync 自动属于同一个事务。两次保存之间如果发生异常,第一次保存的数据可能已经提交。

因此,验证通常分成两层:

先区分单元测试与数据库回滚验证配图

  • 单元测试检查控制流程:发生异常时是否调用 RollbackAsync,是否没有调用 CommitAsync,以及异常是否按预期向上传递。它能证明代码走了回滚分支,但如果事务和数据库都被替身模拟,就不能证明真实数据已撤销。
  • 关系型数据库测试检查最终状态:在真实事务中执行多次写入,让后续写入失败,再通过新的 DbContext 查询数据库,确认前面的写入也不存在。这更接近回滚结果验收,通常应使用 SQLite 内存库或与生产一致的数据库提供程序。

下面用一个订单头和订单明细的例子演示。订单明细的 ExternalKey 有唯一索引:当数据库中已经存在同一个键时,创建订单头可以先成功,写入明细时则会触发唯一约束异常。这个情况也对应实际项目中常见的并发冲突:应用层即使先检查过,数据库约束仍然是最终保护。

在同一个事务中执行多次保存

示例使用 .NET 8、EF Core 8 和 SQLite 提供程序。生产项目应将 Microsoft.EntityFrameworkCore.Sqlite 等 EF Core 提供程序包与实际使用的 EF Core 主版本对齐。

public sealed class Order
{
    public int Id { get; set; }
    public string Number { get; set; } = string.Empty;
}

public sealed class OrderLine
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public string ExternalKey { get; set; } = string.Empty;
    public int Quantity { get; set; }
}

public sealed class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options)
    {
    }

    public DbSet<Order> Orders => Set<Order>();
    public DbSet<OrderLine> OrderLines => Set<OrderLine>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<OrderLine>()
            .HasIndex(line => line.ExternalKey)
            .IsUnique();
    }
}

业务方法在两次保存的外围显式开启事务,所有写入完成后才提交。第二次保存或提交之前出现异常时,代码尝试回滚,并继续向上抛出原异常。

public sealed class OrderService
{
    private readonly AppDbContext _db;

    public OrderService(AppDbContext db)
    {
        _db = db;
    }

    public async Task<int> CreateAsync(
        string orderNumber,
        string lineExternalKey,
        int quantity,
        CancellationToken cancellationToken = default)
    {
        if (quantity <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(quantity));
        }

        await using var transaction =
            await _db.Database.BeginTransactionAsync(cancellationToken);

        try
        {
            var order = new Order
            {
                Number = orderNumber
            };

            _db.Orders.Add(order);
            await _db.SaveChangesAsync(cancellationToken);

            var line = new OrderLine
            {
                OrderId = order.Id,
                ExternalKey = lineExternalKey,
                Quantity = quantity
            };

            _db.OrderLines.Add(line);
            await _db.SaveChangesAsync(cancellationToken);

            await transaction.CommitAsync(cancellationToken);
            return order.Id;
        }
        catch (Exception operationError)
        {
            try
            {
                // 即使调用方的令牌已取消,也尝试完成事务清理。
                await transaction.RollbackAsync(CancellationToken.None);
            }
            catch (Exception rollbackError)
            {
                // 同时保留业务操作异常和回滚异常,便于排查。
                throw new AggregateException(
                    "业务操作失败,且事务回滚也失败。",
                    operationError,
                    rollbackError);
            }

            throw;
        }
    }
}

这里的关键不是把两次 SaveChangesAsync 合并成一次,而是确保两次保存使用同一事务。第一次保存会取得数据库生成的订单 ID,供明细写入使用;但在事务提交前,它不会作为已完成的业务操作留存。第二次保存因为唯一约束失败时,显式事务回滚会撤销订单头的写入。

在同一个事务中执行多次保存配图

生产实现还应考虑记录回滚失败。示例使用 AggregateException 同时保留两个异常;有些项目会将回滚异常写入日志后重新抛出原始异常。无论选择哪种方式,都不宜悄悄忽略回滚失败。

用 SQLite 内存库检查最终数据

SQLite 内存数据库适合快速验证关系型事务行为。需要保持同一个连接打开:内存库通常在连接关闭时销毁。测试中使用两个 DbContext,一个执行操作,另一个重新读取最终状态,避免跟踪状态干扰判断。

using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Xunit;

public sealed class OrderServiceTests
{
    [Fact]
    public async Task DuplicateLineKey_RollsBackNewOrder()
    {
        await using var connection =
            new SqliteConnection("Data Source=:memory:");

        await connection.OpenAsync();

        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlite(connection)
            .Options;

        // 建表并写入一条已有订单及明细。
        await using (var setupDb = new AppDbContext(options))
        {
            await setupDb.Database.EnsureCreatedAsync();

            var existingOrder = new Order
            {
                Number = "ORDER-OLD"
            };

            setupDb.Orders.Add(existingOrder);
            await setupDb.SaveChangesAsync();

            setupDb.OrderLines.Add(new OrderLine
            {
                OrderId = existingOrder.Id,
                ExternalKey = "LINE-001",
                Quantity = 1
            });

            await setupDb.SaveChangesAsync();
        }

        // 新订单头能够先保存;相同 ExternalKey 使第二次保存失败。
        await using (var operationDb = new AppDbContext(options))
        {
            var service = new OrderService(operationDb);

            await Assert.ThrowsAsync<DbUpdateException>(() =>
                service.CreateAsync(
                    "ORDER-NEW",
                    "LINE-001",
                    2));
        }

        // 使用新的 DbContext 从数据库核实最终状态。
        await using (var verifyDb = new AppDbContext(options))
        {
            var orderNumbers = await verifyDb.Orders
                .AsNoTracking()
                .OrderBy(order => order.Number)
                .Select(order => order.Number)
                .ToListAsync();

            var lineCount = await verifyDb.OrderLines
                .AsNoTracking()
                .CountAsync();

            Assert.Equal(new[] { "ORDER-OLD" }, orderNumbers);
            Assert.Equal(1, lineCount);
        }
    }
}

这个测试的判据不仅是“收到 DbUpdateException”。测试还确认了失败前已执行过的订单头写入没有留在数据库中,并确认原有订单和明细未受影响。若事务边界缺失,订单头通常会保留,orderNumbers 就会包含 ORDER-NEW,断言会失败。

用 SQLite 内存库检查最终数据配图

还应为成功路径添加配套测试:使用未重复的明细键调用 CreateAsync,确认方法返回有效订单 ID,并在新 DbContext 中查到订单头和明细。否则,即使实现错误地总是回滚,异常测试仍可能通过,却没有覆盖提交是否正常。

订单与明细等业务数据服务的运行,离不开后端计算与持久化资源。A5idc数据提供香港、美国、日本等地区的物理服务器,配置涵盖多核处理器及SSD或NVMe存储,可用于承载业务后台、接口和数据库相关工作负载;不同地区与套餐各有硬件和线路选择,适合按业务访问范围组织应用与数据服务部署。

纯单元测试能证明什么

如果事务对象通过接口注入,单元测试可以用替身验证异常分支的调用约定:

  • 操作失败时,RollbackAsync 调用一次;
  • 失败操作不调用 CommitAsync;
  • 回滚成功时,原操作异常继续向上传递;
  • 操作成功时,执行提交而不是回滚。

这类断言适合验证业务服务与事务边界之间的控制流程。但它们不等价于上面的数据库状态检查:模拟对象接收到回滚调用,并不能证明数据库提供程序真的撤销了先前写入。

如果当前代码直接调用 _db.Database.BeginTransactionAsync,EF Core 的数据库外观不适合用普通 mock 来模拟真实数据库行为。可以将事务边界抽取为可注入的事务执行器,单元测试该执行器的提交、回滚调用;同时保留关系型数据库测试,验证最终数据。不要为了让测试看起来像纯单元测试而模拟 DbContext,再把模拟结果当作真实回滚证据。

让测试结果可信的几个条件

避免用 EF Core InMemory 提供程序证明事务回滚。 它不是关系型数据库,不能替代关系型事务、唯一约束和数据库约束的验证。SQLite 内存库能覆盖常见关系型行为,但与 SQL Server 等数据库仍存在差异。如果测试目标涉及特定数据库的隔离级别、锁、触发器、错误码或并发行为,应在对应数据库提供程序上运行测试,例如使用专用测试数据库或临时数据库实例。

核对事务是否覆盖全部写入。 只在第一处 SaveChangesAsync 外开启事务,或在写入不同 DbContext 时没有共享事务,都可能让部分数据不受当前事务控制。多个上下文或多个数据库连接需要额外配置共享连接和事务;不能仅凭“服务方法只有一个”就推断它们处于同一事务中。

区分数据库写入与外部副作用。 数据库回滚不能撤回已经发送的邮件、已经调用的外部接口或已经发出的消息。如果流程包含这些操作,不要把“数据库回滚成功”描述成“整个业务流程全部回滚”。常见做法是先在数据库事务中保存业务数据和待发送的 Outbox 消息,提交后再由后台处理消息;根据业务需要,还应设计幂等处理和失败重试。

让测试结果可信的几个条件配图

单独处理提交阶段的异常。 如果异常发生在提交请求过程中,客户端收到异常不一定能确定数据库最终是否提交成功。例如连接中断可能发生在数据库完成提交之后、客户端收到确认之前。这种情况不能一概断言“回滚一定成功”;需要结合幂等键、状态查询或对账机制判断业务结果。

验收时可以把标准落到两类断言上:异常分支确实触发回滚路径,且使用新的上下文查询后,失败操作新增的数据不存在;成功分支则确认数据存在。前者用关系型数据库测试证明实际持久化结果,后者与事务接口的单元测试互相补充,才能同时覆盖代码流程和数据库行为。

本文由A5数据原创发布,转载请注明出处:https://www.a5idc.com/helpcontent/9975.html

相关推荐