如何在xUnit 2.4.1中动态跳过依赖SqlServer的集成测试？

针对你需要自动检测环境并跳过依赖SQL Server的集成测试需求，xUnit 2.x虽然没有Assert.Skip()，但可以通过以下几种方式实现目标：

方案1：自定义特性（侵入性最低，推荐） #

继承xUnit的FactAttribute，在特性内部完成SQL Server可用性检测，自动设置跳过逻辑：

using System.Data.SqlClient;
using Xunit;

public class DemandSqlServerFactAttribute : FactAttribute
{
    public DemandSqlServerFactAttribute()
    {
        if (!IsSqlServerReachable())
        {
            Skip = "跳过测试：当前环境无法连接SQL Server";
        }
    }

    private bool IsSqlServerReachable()
    {
        // 从配置文件读取连接字符串，避免硬编码
        var connectionString = "你的测试数据库连接字符串";
        try
        {
            using var connection = new SqlConnection(connectionString);
            connection.Open();
            return true;
        }
        catch (SqlException)
        {
            return false;
        }
    }
}

替换原有测试代码中的[Fact]特性即可：

public class Some_database_interaction
{
    [DemandSqlServerFact]
    [Trait("Demand", "SqlServer")]
    public async Task One_thing_is_inserted()
    {
        using var connection = await Connect();
        var applicationService = new SomeService(connection);
        
        var resultCount = await applicationService.DoTheImportantThing("some args", true);

        Assert.Equal(1, resultCount);
    }
}

方案2：在测试中异步检测并抛出SkipException #

xUnit 2.x会将抛出SkipException的测试标记为“跳过”状态，而非成功或失败。你可以在测试开头加入异步检测逻辑：

using Xunit.Sdk;

public static class TestEnvironmentHelper
{
    public static async Task EnsureSqlServerAvailable()
    {
        try
        {
            using var connection = await Connect();
        }
        catch (Exception ex)
        {
            throw new SkipException("SQL Server不可用", ex);
        }
    }
}

在测试中调用该方法：

public class Some_database_interaction
{
    [Fact]
    [Trait("Demand", "SqlServer")]
    public async Task One_thing_is_inserted()
    {
        await TestEnvironmentHelper.EnsureSqlServerAvailable();
        
        using var connection = await Connect();
        var applicationService = new SomeService(connection);
        
        var resultCount = await applicationService.DoTheImportantThing("some args", true);

        Assert.Equal(1, resultCount);
    }
}

方案3：使用IClassFixture共享检测逻辑 #

如果多个测试类都依赖SQL Server，可以通过Fixture共享检测结果，避免重复连接数据库：

public class SqlServerAvailabilityFixture : IDisposable
{
    public bool IsAvailable { get; }

    public SqlServerAvailabilityFixture()
    {
        // 异步检测转为同步执行（Fixture构造函数不支持异步）
        IsAvailable = Task.Run(async () =>
        {
            try
            {
                using var connection = await Connect();
                return true;
            }
            catch
            {
                return false;
            }
        }).GetAwaiter().GetResult();
    }

    public void Dispose()
    {
        // 按需清理资源
    }
}

测试类集成该Fixture：

public class Some_database_interaction : IClassFixture<SqlServerAvailabilityFixture>
{
    private readonly SqlServerAvailabilityFixture _fixture;

    public Some_database_interaction(SqlServerAvailabilityFixture fixture)
    {
        _fixture = fixture;
    }

    [Fact]
    [Trait("Demand", "SqlServer")]
    public async Task One_thing_is_inserted()
    {
        if (!_fixture.IsAvailable)
        {
            throw new SkipException("当前环境无法连接SQL Server，跳过测试");
        }
        
        using var connection = await Connect();
        var applicationService = new SomeService(connection);
        
        var resultCount = await applicationService.DoTheImportantThing("some args", true);

        Assert.Equal(1, resultCount);
    }
}

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