如何在并行环境中重复运行xUnit测试集合多次？

你遇到的核心问题是自定义测试框架复制集合后，Azure DevOps中仅执行一次，本质是测试集合/用例的唯一标识重复、xUnit集合并行配置未生效，以及Fixture关联逻辑未正确触发导致的。以下是针对性的解决方案：

一、核心问题分析 #

1. 测试标识重复：你原代码中测试集合的DisplayName复用了原集合的UniqueID，且未修改测试用例的唯一ID，Azure DevOps的测试运行器（如VSTest）会基于唯一ID去重，仅执行一次。
2. Fixture关联失效：复制TestCollection时，未确保新集合正确绑定Collection Fixture的实例化逻辑，导致xUnit未识别为独立集合。
3. 并行配置缺失：xUnit默认不开启集合级并行，需显式配置。

二、修正后的实现代码 #

1. 自定义xUnit测试框架及运行器 #

重写测试类运行器，在执行阶段复制测试集合与用例，并确保每个副本的唯一标识独立：

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Xunit;
using Xunit.Abstractions;
using Xunit.Sdk;

namespace Xunit.Custom
{
    public class ParallelTestCollectionFramework : XunitTestFramework
    {
        private readonly int _testSuiteRuns;

        public ParallelTestCollectionFramework(IMessageSink diagnosticMessageSink) : base(diagnosticMessageSink)
        {
            // 从环境变量读取重复次数（Azure DevOps中可配置）
            _testSuiteRuns = int.TryParse(Environment.GetEnvironmentVariable("TEST_SUITE_RUNS"), out var runs) ? runs : 2;
        }

        protected override ITestClassRunner CreateTestClassRunner(ITestClass testClass, IMessageSink diagnosticMessageSink, ITestFrameworkExecutionOptions executionOptions)
        {
            return new ParallelCollectionTestClassRunner(testClass, diagnosticMessageSink, executionOptions, _testSuiteRuns);
        }
    }

    public class ParallelCollectionTestClassRunner : XunitTestClassRunner
    {
        private readonly int _testSuiteRuns;

        public ParallelCollectionTestClassRunner(ITestClass testClass, IMessageSink diagnosticMessageSink, ITestFrameworkExecutionOptions executionOptions, int testSuiteRuns)
            : base(testClass, diagnosticMessageSink, executionOptions)
        {
            _testSuiteRuns = testSuiteRuns;
        }

        protected override async Task<RunSummary> RunTestMethodsAsync(IMessageBus messageBus, IEnumerable<IXunitTestCase> testCases)
        {
            var duplicatedTestCases = SetUpTestCaseParallelization(testCases).ToList();
            return await base.RunTestMethodsAsync(messageBus, duplicatedTestCases);
        }

        private IEnumerable<IXunitTestCase> SetUpTestCaseParallelization(IEnumerable<IXunitTestCase> testCases)
        {
            var result = new List<IXunitTestCase>();
            if (!testCases.Any()) return result;

            var oldTestMethod = testCases.First().TestMethod;
            var oldTestClass = oldTestMethod.TestClass;
            var oldTestCollection = oldTestMethod.TestClass.TestCollection;

            for (int c = 0; c < _testSuiteRuns; c++)
            {
                // 创建唯一标识的新测试集合
                var newTestCollection = new TestCollection(
                    oldTestCollection.TestAssembly,
                    oldTestCollection.CollectionDefinition,
                    displayName: $"{oldTestCollection.DisplayName} (Run {c + 1})");
                newTestCollection.UniqueID = Guid.NewGuid();

                var newTestClass = new TestClass(newTestCollection, oldTestClass.Class);

                foreach (var testCase in testCases)
                {
                    var testMethod = testCase.TestMethod;
                    var newTestMethod = new TestMethod(newTestClass, testMethod.Method);
                    IXunitTestCase newTestCase;

                    switch (testCase)
                    {
                        case XunitTheoryTestCase theoryCase:
                            newTestCase = new XunitTheoryTestCase(
                                DiagnosticMessageSink,
                                GetTestMethodDisplay(theoryCase),
                                GetTestMethodDisplayOptions(theoryCase),
                                newTestMethod);
                            break;
                        case XunitTestCase regularCase:
                            newTestCase = new XunitTestCase(
                                DiagnosticMessageSink,
                                GetTestMethodDisplay(regularCase),
                                GetTestMethodDisplayOptions(regularCase),
                                newTestMethod,
                                regularCase.TestMethodArguments);
                            break;
                        default:
                            throw new ArgumentOutOfRangeException($"不支持的测试用例类型：{testCase.GetType()}");
                    }

                    // 修改测试用例的唯一ID，避免Azure DevOps去重
                    var uniqueIdProp = newTestCase.GetType().GetProperty("UniqueID", BindingFlags.Instance | BindingFlags.NonPublic);
                    if (uniqueIdProp != null)
                        uniqueIdProp.SetValue(newTestCase, Guid.NewGuid().ToString());

                    result.Add(newTestCase);
                }
            }

            return result;
        }

        static TestMethodDisplay GetTestMethodDisplay(TestMethodTestCase testCase)
        {
            return (TestMethodDisplay)typeof(TestMethodTestCase)
                .GetProperty("DefaultMethodDisplay", BindingFlags.Instance | BindingFlags.NonPublic)!
                .GetValue(testCase)!;
        }

        static TestMethodDisplayOptions GetTestMethodDisplayOptions(TestMethodTestCase testCase)
        {
            return (TestMethodDisplayOptions)typeof(TestMethodTestCase)
                .GetProperty("DefaultMethodDisplayOptions", BindingFlags.Instance | BindingFlags.NonPublic)!
                .GetValue(testCase)!;
        }
    }
}

2. 配置xUnit并行 #

在项目根目录创建xunit.runner.json，开启集合级并行：

{
  "parallelizeTestCollections": true,
  "maxParallelThreads": -1
}

三、Azure DevOps Pipeline配置 #

1. 设置重复次数环境变量：在测试步骤前添加变量，或直接在VsTest任务中设置：

   variables:
     TEST_SUITE_RUNS: '3' # 重复运行3次
   

2. 测试运行任务配置：确保VsTest任务未启用测试去重，示例：

   - task: VsTest@2
     inputs:
       testAssemblyVer2: '**/YourTestAssembly.dll'
       runSettingsFile: 'xunit.runner.json'
       env:
         TEST_SUITE_RUNS: $(TEST_SUITE_RUNS)
   

四、关键注意事项 #

• Collection Fixture独立性：每个新创建的TestCollection会自动实例化独立的Collection Fixture，因为xUnit按TestCollection管理Fixture生命周期。
• 测试用例唯一ID：必须修改每个复制用例的UniqueID，否则Azure DevOps会识别为同一测试并跳过重复执行。
• 性能控制：根据机器资源调整maxParallelThreads，避免资源耗尽。

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