针对含实体关联的真实关系数据库的应用逻辑集成测试最佳方法问询

我完全懂这种痛苦——每次写集成测试都要先手动构建一堆依赖实体，不仅费时间，代码还越堆越乱，到最后大家都不想碰测试了。针对你用C#、EF Core和NUnit的场景，我整理了几个能大幅简化测试数据准备的技巧，而且这些思路也适用于其他技术栈：

把实体的创建逻辑封装成专门的Builder类，隐藏依赖细节，让测试代码更简洁易维护。以你的Person和Car为例：

public class PersonBuilder
{
    private int _personId = 1;
    private string _name = "John";
    private string _surname = "Doe";

    public PersonBuilder WithName(string name)
    {
        _name = name;
        return this;
    }

    public PersonBuilder WithSurname(string surname)
    {
        _surname = surname;
        return this;
    }

    public Person Build()
    {
        return new Person
        {
            PersonId = _personId,
            Name = _name,
            Surname = _surname,
            Cars = new List<Car>()
        };
    }

    // 直接保存到数据库的快捷方法
    public async Task<Person> BuildAndSaveAsync(AppDbContext context)
    {
        var person = Build();
        context.People.Add(person);
        await context.SaveChangesAsync();
        return person;
    }
}

public class CarBuilder
{
    private int _carId = 1;
    private string _make = "Toyota";
    private string _model = "Camry";
    private Person _person;

    public CarBuilder WithPerson(Person person)
    {
        _person = person;
        return this;
    }

    public CarBuilder WithMake(string make)
    {
        _make = make;
        return this;
    }

    public Car Build()
    {
        // 自动补全默认依赖，避免测试报错
        _person ??= new PersonBuilder().Build();
        return new Car
        {
            CarId = _carId,
            Make = _make,
            Model = _model,
            PersonId = _person.PersonId,
            Person = _person
        };
    }

    public async Task<Car> BuildAndSaveAsync(AppDbContext context)
    {
        var car = Build();
        // 检查Person是否已存入数据库，未存入则自动保存
        if (!context.People.Local.Any(p => p.PersonId == car.PersonId))
        {
            context.People.Add(car.Person);
            await context.SaveChangesAsync();
        }
        context.Cars.Add(car);
        await context.SaveChangesAsync();
        return car;
    }
}

测试中用法：

// 一行代码创建带关联Person的Car并保存
var hondaCar = await new CarBuilder()
    .WithMake("Honda")
    .WithPerson(await new PersonBuilder().WithName("Alice").BuildAndSaveAsync(context))
    .BuildAndSaveAsync(context);

后续如果实体结构变更，只需要修改Builder类，不用逐个修改测试代码。

每个测试开始时开启数据库事务，测试结束后回滚，避免测试之间的数据污染，同时省去手动清理数据的麻烦。结合NUnit的[SetUp]和[TearDown]：

[TestFixture]
public class CarRequestHandlerTests
{
    private AppDbContext _context;
    private IDbContextTransaction _transaction;
    private CarRequestHandler _handler;

    [SetUp]
    public async Task SetUp()
    {
        // 初始化测试用上下文
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer("YourTestConnectionString")
            .Options;
        _context = new AppDbContext(options);
        
        // 开启事务，测试结束后回滚
        _transaction = await _context.Database.BeginTransactionAsync();
        _handler = new CarRequestHandler(_context);

        // 准备通用基础测试数据（可选）
        await new PersonBuilder().WithName("Bob").BuildAndSaveAsync(_context);
    }

    [TearDown]
    public async Task TearDown()
    {
        await _transaction.RollbackAsync();
        await _context.DisposeAsync();
    }

    [Test]
    public async Task GetList_WithNameFilter_ReturnsMatchingCars()
    {
        // 创建测试专属数据
        var alice = await new PersonBuilder().WithName("Alice").BuildAndSaveAsync(_context);
        await new CarBuilder().WithPerson(alice).WithMake("Honda").BuildAndSaveAsync(_context);

        // 执行测试逻辑
        var result = await _handler.GetList("Honda");

        // 断言验证
        Assert.That(result.Count(), Is.EqualTo(1));
        Assert.That(result.First().Make, Is.EqualTo("Honda"));
    }
}

这种方式保证了每个测试都在干净的数据库环境中运行，不用手动删除数据，效率极高。

如果需要大量真实感的测试数据，可以用第三方库（比如Bogus）结合自定义生成器，自动处理依赖关系：

public static class TestDataGenerator
{
    private static readonly Faker _faker = new Faker();

    public static Person GeneratePerson()
    {
        return new Person
        {
            Name = _faker.Name.FirstName(),
            Surname = _faker.Name.LastName(),
            Cars = new List<Car>()
        };
    }

    public static Car GenerateCar(Person person = null)
    {
        person ??= GeneratePerson();
        return new Car
        {
            Make = _faker.Vehicle.Manufacturer(),
            Model = _faker.Vehicle.Model(),
            Person = person,
            PersonId = person.PersonId
        };
    }

    public static async Task SeedDatabaseAsync(AppDbContext context, int personCount, int carsPerPerson)
    {
        for (int i = 0; i < personCount; i++)
        {
            var person = GeneratePerson();
            context.People.Add(person);
            for (int j = 0; j < carsPerPerson; j++)
            {
                context.Cars.Add(GenerateCar(person));
            }
        }
        await context.SaveChangesAsync();
    }
}

测试中用法：

// 快速生成5个Person，每个关联2辆Car
await TestDataGenerator.SeedDatabaseAsync(_context, 5, 2);

把常用的数据库操作封装成助手方法，让所有测试复用这些逻辑，进一步简化代码：

public static class TestDbHelper
{
    public static async Task<Person> CreatePersonAsync(AppDbContext context, string name = null)
    {
        var builder = new PersonBuilder();
        if (!string.IsNullOrEmpty(name)) builder.WithName(name);
        return await builder.BuildAndSaveAsync(context);
    }

    public static async Task<Car> CreateCarAsync(AppDbContext context, string make = null, Person person = null)
    {
        var builder = new CarBuilder();
        if (!string.IsNullOrEmpty(make)) builder.WithMake(make);
        if (person != null) builder.WithPerson(person);
        return await builder.BuildAndSaveAsync(context);
    }
}

测试中用法：

var alice = await TestDbHelper.CreatePersonAsync(_context, "Alice");
var hondaCar = await TestDbHelper.CreateCarAsync(_context, "Honda", alice);

这些技巧的核心是抽象和复用——把重复的依赖构建逻辑抽离出来，让测试代码专注于验证业务逻辑本身，而不是数据准备。这样团队写测试的成本会大幅降低，也更愿意维护测试代码库。

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