如何在Xunit Collection Fixture中并行化所有测试

问题描述 #

我在Xunit测试中使用集合夹具（Collection Fixture）对所有测试分组，要实现两项需求：

1. Docker数据库初始化
2. 每个测试拥有独立服务集合用于测试活动

当前问题是：所有测试同属一个集合夹具，导致测试类无法并行运行。我试过Xunit官方并行化文档中的多种方法均无效，虽然测试当前运行速度尚可，但并行化能大幅提升性能，求可行解决思路？

相关代码 #

测试集合夹具代码 #

[CollectionDefinition(nameof(TestFixture))]
public class TestFixtureCollection : ICollectionFixture<TestFixture> {}

public class TestFixture : IAsyncLifetime
{
    public static IServiceScopeFactory BaseScopeFactory;

    public async Task InitializeAsync()
    {
          // docker db setup

        builder.ConfigureServices();
        var services = builder.Services;

        var provider = services.BuildServiceProvider();
        BaseScopeFactory = provider.GetService<IServiceScopeFactory>();
    }

    
    public Task DisposeAsync()
    {
        return Task.CompletedTask;
    }
}

public static class ServiceCollectionServiceExtensions
{
    public static IServiceCollection ReplaceServiceWithSingletonMock<TService>(this IServiceCollection services)
        where TService : class
    {
        services.RemoveAll(typeof(TService));
        services.AddScoped<TService>(_ => Mock.Of<TService>());
        return services;
    }
}

测试服务范围代码 #

public class TestingServiceScope 
{
    private readonly IServiceScope _scope;

    public TestingServiceScope()
    {
        _scope = BaseScopeFactory.CreateScope();
    }

    public TScopedService GetService<TScopedService>()
    {
        var service = _scope.ServiceProvider.GetService<TScopedService>();
        return service;
    }

    public async Task<T> ExecuteScopeAsync<T>(Func<IServiceProvider, Task<T>> action)
        => await action(_scope.ServiceProvider);

    public Task<T> ExecuteDbContextAsync<T>(Func<CoreDomainDbContext, Task<T>> action)
        => ExecuteScopeAsync(sp => action(sp.GetService<CoreDomainDbContext>()));
    
    public Task<int> InsertAsync<T>(params T[] entities) where T : class
    {
        return ExecuteDbContextAsync(db =>
        {
            foreach (var entity in entities)
            {
                db.Set<T>().Add(entity);
            }
            return db.SaveChangesAsync();
        });
    }
}

示例测试代码 #

[Collection(nameof(TestFixture))]
public class AddRecipeCommandTests
{
    [Fact]
    public async Task can_add_new_recipe_to_db()
    {
        // Arrange
        var testingServiceScope = new TestingServiceScope();
        var fakeRecipeOne = new FakeRecipeForCreationDto().Generate();

        // Act
        var command = new AddRecipe.Command(fakeRecipeOne);
        var recipeReturned = await testingServiceScope.SendAsync(command);
        var recipeCreated = await testingServiceScope.ExecuteDbContextAsync(db => db.Recipes
            .FirstOrDefaultAsync(r => r.Id == recipeReturned.Id));

        // Assert
        recipeReturned.Title.Should().Be(fakeRecipeOne.Title);
        recipeReturned.Visibility.Should().Be(fakeRecipeOne.Visibility);
        recipeReturned.Directions.Should().Be(fakeRecipeOne.Directions);
        recipeReturned.Rating.Should().Be(fakeRecipeOne.Rating);
        recipeReturned.DateOfOrigin.Should().Be(fakeRecipeOne.DateOfOrigin);
        recipeReturned.HaveMadeItMyself.Should().Be(fakeRecipeOne.HaveMadeItMyself);

        recipeCreated.Title.Should().Be(fakeRecipeOne.Title);
        recipeCreated.Visibility.Should().Be(fakeRecipeOne.Visibility);
        recipeCreated.Directions.Should().Be(fakeRecipeOne.Directions);
        recipeCreated.Rating.Should().Be(fakeRecipeOne.Rating);
        recipeCreated.DateOfOrigin.Should().Be(fakeRecipeOne.DateOfOrigin);
        recipeCreated.HaveMadeItMyself.Should().Be(fakeRecipeOne.HaveMadeItMyself);
    }
}

解决思路 #

1. 拆分集合夹具+类夹具组合，分离全局初始化与测试隔离 #

把全局资源初始化（Docker数据库）和测试类的服务隔离拆解开：

• 用集合夹具仅做一次全局Docker数据库初始化，确保资源只启动一次
• 用类夹具为每个测试类创建独立的服务范围，这样不同测试类属于不同的并行单元，可实现并行运行

代码调整示例：

// 全局数据库初始化集合夹具（仅执行一次）
[CollectionDefinition(nameof(DbInitCollection))]
public class DbInitCollection : ICollectionFixture<DbInitFixture> {}

public class DbInitFixture : IAsyncLifetime
{
    public IServiceScopeFactory GlobalScopeFactory { get; private set; }

    public async Task InitializeAsync()
    {
        // 保留原Docker数据库初始化代码
        var builder = ...;
        builder.ConfigureServices();
        var provider = builder.Services.BuildServiceProvider();
        GlobalScopeFactory = provider.GetService<IServiceScopeFactory>();
    }

    public Task DisposeAsync() => Task.CompletedTask;
}

// 类夹具：为每个测试类提供独立服务范围
public class TestClassFixture : IAsyncLifetime
{
    public TestingServiceScope ServiceScope { get; private set; }
    private readonly DbInitFixture _dbInitFixture;

    public TestClassFixture(DbInitFixture dbInitFixture)
    {
        _dbInitFixture = dbInitFixture;
    }

    public Task InitializeAsync()
    {
        ServiceScope = new TestingServiceScope(_dbInitFixture.GlobalScopeFactory);
        return Task.CompletedTask;
    }

    public Task DisposeAsync()
    {
        // 可在此处添加服务范围的释放逻辑
        return Task.CompletedTask;
    }
}

// 修改TestingServiceScope，移除静态依赖，改为构造注入
public class TestingServiceScope 
{
    private readonly IServiceScope _scope;

    public TestingServiceScope(IServiceScopeFactory scopeFactory)
    {
        _scope = scopeFactory.CreateScope();
    }

    // 其余方法保持不变...
}

// 测试类调整：绑定全局集合+使用类夹具
[Collection(nameof(DbInitCollection))]
public class AddRecipeCommandTests : IClassFixture<TestClassFixture>
{
    private readonly TestingServiceScope _serviceScope;

    public AddRecipeCommandTests(TestClassFixture classFixture)
    {
        _serviceScope = classFixture.ServiceScope;
    }

    // 测试方法逻辑保持不变，仅替换_serviceScope的使用
}

2. 数据库层面保证并行安全 #

并行测试时需避免数据冲突：

• 给每个测试绑定独立数据库事务，测试结束后自动回滚（可在TestingServiceScope的Dispose中实现）
• 或为每个测试生成唯一的数据库Schema/表前缀，隔离测试数据

3. 确认Xunit并行配置 #

确保项目根目录的xunit.runner.json配置正确：

{
  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
  "parallelizeTestCollections": true,
  "maxParallelThreads": -1
}

parallelizeTestCollections设为true时，不同集合的测试类会并行执行，同一集合内的测试类仍串行，因此拆分集合是并行的核心前提。

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