Testcontainers 集成测试

// 最小示例：启动一个 PostgreSQL 容器
public class PostgresSmokeTest : IAsyncLifetime
{
    private PostgreSqlContainer _db = null!;

    public async Task InitializeAsync()
    {
        _db = new PostgreSqlBuilder()
            .WithImage("postgres:16-alpine")
            .WithDatabase("appdb").WithUsername("app").WithPassword("secret")
            .Build();
        await _db.StartAsync();
    }

    public async Task DisposeAsync() => await _db.DisposeAsync();

    [Fact]
    public async Task 可以执行真实SQL()
    {
        await using var conn = new NpgsqlConnection(_db.GetConnectionString());
        await conn.OpenAsync();
        await using var cmd = conn.CreateCommand();
        cmd.CommandText = "SELECT version()";
        var version = (string)(await cmd.ExecuteScalarAsync())!;
        Assert.Contains("PostgreSQL", version);
    }
}

// Redis：模块自动等待 PING 就绪
var redis = new RedisBuilder().WithImage("redis:7-alpine").Build();
await redis.StartAsync();
var redisConn = redis.GetConnectionString();   // host:port

// Kafka：模块自动等待 broker 元数据可用
var kafka = new KafkaBuilder().WithImage("confluentinc/cp-kafka:7.5.0").Build();
await kafka.StartAsync();
var bootstrap = kafka.GetBootstrapAddress();

// 裸 ContainerBuilder：模块不覆盖时使用（随机宿主端口 + 健康检查就绪）
var minio = new ContainerBuilder()
    .WithImage("minio/minio:latest")
    .WithCommand("server", "/data")
    .WithEnvironment("MINIO_ROOT_USER", "minioadmin")
    .WithEnvironment("MINIO_ROOT_PASSWORD", "minioadmin")
    .WithPortBinding(9000, assignRandomHostPort: true)
    .WithWaitStrategy(Wait.ForUnixContainer()
        .UntilHttpRequestIsSucceeded(r => r.ForPort(9000).ForPath("/minio/health/live")))
    .Build();
await minio.StartAsync();
var endpoint = $"{minio.Hostname}:{minio.GetMappedPublicPort(9000)}";

public class ApiFactory : WebApplicationFactory<Program>, IAsyncLifetime
{
    private readonly PostgreSqlContainer _db = new PostgreSqlBuilder()
        .WithImage("postgres:16-alpine").Build();

    private readonly RedisContainer _redis = new RedisBuilder()
        .WithImage("redis:7-alpine").Build();

    public async Task InitializeAsync()
        // 并行启动多个容器，缩短夹具初始化时间
        => await Task.WhenAll(_db.StartAsync(), _redis.StartAsync());

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.UseEnvironment("Testing");
        builder.ConfigureAppConfiguration((_, config) =>
        {
            config.AddInMemoryCollection(new Dictionary<string, string?>
            {
                ["ConnectionStrings:Default"] = _db.GetConnectionString(),
                ["ConnectionStrings:Redis"] = _redis.GetConnectionString(),
                ["Features:UseCache"] = "true",
            });
        });

        builder.ConfigureServices(services =>
        {
            // 测试启动时跑迁移
            using var sp = services.BuildServiceProvider();
            using var scope = sp.CreateScope();
            scope.ServiceProvider.GetRequiredService<AppDbContext>().Database.Migrate();
        });
    }

    async Task IAsyncLifetime.DisposeAsync()
    {
        await _db.DisposeAsync();
        await _redis.DisposeAsync();
        await base.DisposeAsync();
    }
}

public class OrdersApiTests : IClassFixture<ApiFactory>
{
    private readonly HttpClient _client;

    public OrdersApiTests(ApiFactory factory)
        => _client = factory.CreateClient();

    [Fact]
    public async Task 创建订单后可以查询()
    {
        var create = await _client.PostAsJsonAsync("/api/orders",
            new { Title = "测试订单", Total = 99.5m });
        create.EnsureSuccessStatusCode();
        var created = await create.Content.ReadFromJsonAsync<OrderDto>();
        var fetched = await _client.GetFromJsonAsync<OrderDto>($"/api/orders/{created!.Id}");
        Assert.Equal("测试订单", fetched!.Title);
    }
}

// 集合夹具：多个测试类共享一套容器
[CollectionDefinition("Database")]
public class DatabaseCollection : ICollectionFixture<DatabaseFixture> { }

public class DatabaseFixture : IAsyncLifetime
{
    public PostgreSqlContainer Db { get; private set; } = null!;

    public async Task InitializeAsync()
    {
        Db = new PostgreSqlBuilder().WithImage("postgres:16-alpine").Build();
        await Db.StartAsync();
    }

    public async Task DisposeAsync() => await Db.DisposeAsync();
}

[Collection("Database")]
public class OrderRepositoryTests
{
    private readonly DatabaseFixture _fx;
    public OrderRepositoryTests(DatabaseFixture fx) => _fx = fx;

    [Fact]
    public async Task 可以保存订单() { /* 使用 _fx.Db，同类共享一个容器 */ }
}

// 策略一：事务回滚——每个测试开事务，Dispose 时回滚，数据不落盘
public class TransactionalTest : IAsyncLifetime
{
    private NpgsqlConnection _conn = null!;
    private NpgsqlTransaction _tx = null!;

    public async Task InitializeAsync()
    {
        _conn = new NpgsqlConnection(_connString);
        await _conn.OpenAsync();
        _tx = await _conn.BeginTransactionAsync();
    }

    public async Task DisposeAsync()
    {
        await _tx.RollbackAsync();
        await _conn.DisposeAsync();
    }
}

// 策略二：Respawn——保留表结构，只清空数据
// 建好 Respawner 后，每个测试前调用一次即可：
_respawner = await Respawner.CreateAsync(conn, new RespawnerOptions
{
    DbAdapter = DbAdapter.Postgres,
    TablesToIgnore = new[] { new Table("__EFMigrationsHistory") },
    SchemasToInclude = new[] { "public" },
});

await _respawner.ResetAsync(conn);   // 清空数据但保留表结构

name: tests
on: [push]
jobs:
  integration:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'
      - name: 预热镜像
        run: |
          docker pull postgres:16-alpine
          docker pull redis:7-alpine
          docker pull confluentinc/cp-kafka:7.5.0
      - name: 运行测试
        run: dotnet test --no-build -c Release --logger "trx;LogFileName=results.trx"
      - name: 失败时导出容器日志
        if: failure()
        run: docker ps -a --format '{{.Names}}' | xargs -I{} sh -c 'docker logs {} > logs-{}.txt 2>&1 || true'

// AssemblyInfo.cs：用 xUnit 集合控制并行度，避免容器数量爆炸
[assembly: CollectionBehavior(MaxParallelThreads = 4)]

// 给容器设资源上限，避免 CI 内存耗尽
var db = new PostgreSqlBuilder()
    .WithImage("postgres:16-alpine")
    .WithResourceMapping(new FileInfo("init.sql"), "/docker-entrypoint-initdb.d/")
    .WithCreateParameterModifier(p => p.HostConfig.Memory = 512 * 1024 * 1024)
    .Build();

// 完整的就绪与超时配置
var container = new ContainerBuilder()
    .WithImage("myapp/api:1.0.0")
    .WithPortBinding(8080, true)
    .WithEnvironment("ASPNETCORE_ENVIRONMENT", "Testing")
    .WithWaitStrategy(Wait.ForUnixContainer()
        .UntilHttpRequestIsSucceeded(r => r
            .ForPort(8080)
            .ForPath("/health/ready")
            .WithTimeout(TimeSpan.FromSeconds(5)))
        .UntilMessageIsLogged("Application started"))
    .WithStartupTimeout(TimeSpan.FromMinutes(2))
    .Build();

// 诊断：把容器日志接到测试输出
public static void DumpLogs(IContainer c, ITestOutputHelper output)
{
    var (stdout, stderr) = c.GetLogsAsync().GetAwaiter().GetResult();
    output.WriteLine(stdout);
    if (!string.IsNullOrEmpty(stderr)) output.WriteLine(stderr);
}