XUnit中如何在指定[Theory]的所有测试完成后运行代码？

核心思路 #

要实现某个[Theory]的所有测试案例执行完毕后触发属性覆盖检查，同时避免错误信息关联到无关测试，可以通过追踪已测试属性+控制测试执行顺序的方式实现，以下是具体可行的方案：

方案1：测试类内追踪+独立验证测试 #

这是最直观的实现方式，通过静态集合记录已测试属性，再用一个独立的[Fact]方法在所有[Theory]案例执行后做检查。

1. 追踪已测试属性
   在测试类中定义线程安全的静态集合，每次CheckValue测试执行时记录当前属性：

private static readonly HashSet<string> _testedProperties = new HashSet<string>();

[Theory]
[InlineData(nameof(MyClass.Value1))]
[InlineData(nameof(MyClass.Value2))]
public void CheckValue(string propertyName)
{
    // 你的业务测试逻辑示例
    var myClass = new MyClass();
    var propertyValue = typeof(MyClass).GetProperty(propertyName)?.GetValue(myClass);
    Assert.NotNull(propertyValue);

    // 记录已测试属性
    lock (_testedProperties)
    {
        _testedProperties.Add(propertyName);
    }
}

2. 添加独立验证测试并控制执行顺序
   自定义测试优先级特性，确保验证测试在所有[Theory]案例后执行：

[TestCaseOrderer("YourNamespace.PriorityOrderer", "YourAssemblyName")]
public class MyClassTests
{
    [Fact, TestPriority(2)]
    public void VerifyAllPropertiesAreTested()
    {
        var allProperties = typeof(MyClass).GetProperties().Select(p => p.Name).ToList();
        var untestedProperties = allProperties.Except(_testedProperties).ToList();
        
        Assert.Empty(untestedProperties, $"以下属性未被测试覆盖：{string.Join(", ", untestedProperties)}");
    }
}

// 自定义优先级排序器
public class PriorityOrderer : ITestCaseOrderer
{
    public IEnumerable<TTestCase> OrderTestCases<TTestCase>(IEnumerable<TTestCase> testCases) where TTestCase : ITestCase
    {
        var sortedMethods = new SortedDictionary<int, List<TTestCase>>();
        foreach (var testCase in testCases)
        {
            var priority = testCase.TestMethod.Method.GetCustomAttributes(typeof(TestPriorityAttribute))
                .FirstOrDefault() is TestPriorityAttribute attr ? attr.Priority : 0;
            
            if (!sortedMethods.ContainsKey(priority))
                sortedMethods[priority] = new List<TTestCase>();
            
            sortedMethods[priority].Add(testCase);
        }

        foreach (var priority in sortedMethods.Keys.OrderBy(k => k))
        {
            foreach (var testCase in sortedMethods[priority])
                yield return testCase;
        }
    }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class TestPriorityAttribute : Attribute
{
    public int Priority { get; }
    public TestPriorityAttribute(int priority) => Priority = priority;
}

这种方式下，验证失败的错误会单独显示为VerifyAllPropertiesAreTested方法的结果，不会关联到其他测试案例。

方案2：测试类Dispose方法中执行检查 #

让测试类实现IDisposable，在Dispose方法中完成属性覆盖检查，该方法会在测试类的所有测试执行完毕后触发：

public class MyClassTests : IDisposable
{
    private static readonly HashSet<string> _testedProperties = new HashSet<string>();

    [Theory]
    [InlineData(nameof(MyClass.Value1))]
    [InlineData(nameof(MyClass.Value2))]
    public void CheckValue(string propertyName)
    {
        // 测试逻辑
        // ...
        
        lock (_testedProperties)
        {
            _testedProperties.Add(propertyName);
        }
    }

    public void Dispose()
    {
        var allProperties = typeof(MyClass).GetProperties().Select(p => p.Name).ToList();
        var untestedProperties = allProperties.Except(_testedProperties).ToList();

        if (untestedProperties.Any())
        {
            Assert.Fail($"漏测属性：{string.Join(", ", untestedProperties)}");
        }
    }
}

这种方式的错误会标记为测试类级别的失败，适合不需要单独拆分验证测试的场景。

方案3：集合Fixture复用检查逻辑 #

如果多个测试类需要类似的属性覆盖检查，可以使用ICollectionFixture实现复用：

public class PropertyCoverageFixture : IDisposable
{
    public HashSet<string> TestedProperties { get; } = new HashSet<string>();

    public void Dispose()
    {
        var allProperties = typeof(MyClass).GetProperties().Select(p => p.Name).ToList();
        var untested = allProperties.Except(TestedProperties).ToList();
        if (untested.Any())
        {
            Assert.Fail($"漏测属性：{string.Join(", ", untested)}");
        }
    }
}

[Collection("PropertyCoverage")]
public class MyClassTests
{
    private readonly PropertyCoverageFixture _fixture;

    public MyClassTests(PropertyCoverageFixture fixture) => _fixture = fixture;

    [Theory]
    [InlineData(nameof(MyClass.Value1))]
    [InlineData(nameof(MyClass.Value2))]
    public void CheckValue(string propertyName)
    {
        // 测试逻辑
        // ...
        
        lock (_fixture.TestedProperties)
        {
            _fixture.TestedProperties.Add(propertyName);
        }
    }
}

集合Fixture的Dispose会在该集合下所有测试类执行完毕后触发，适合多类共享检查逻辑的场景。

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