استفاده از Docker Image برای تست‌ها

public class MyTest : IAsyncLifetime
{
    private MsSqlContainer _sqlContainer = null!;
    private RedisContainer _redisContainer = null!;
    private IConnectionMultiplexer _redisConnection = null!;
    private SqlConnection _sqlConnection = null!;

    public async Task InitializeAsync()
    {
        string sqlConnectionString;
        string redisConnectionString;

        // Check if we're in GitHub Actions or local development
        var isCi = Environment.GetEnvironmentVariable("CI") == "true";

        if (isCi)
        {
            // GitHub Actions: Use Docker containers defined in the workflow
            sqlConnectionString = StaticData.SqlConnectionOnRunCi;
            redisConnectionString = StaticData.RedisConnectionOnRunCi;
        }
        else
        {
            var sqlTask = Task.Run(async () =>
            {
                _sqlContainer = new MsSqlBuilder()
                    .WithImage(StaticData.SqlImage)
                    .WithDockerEndpoint(StaticData.DockerEndPoint)
                    .WithPassword(StaticData.DbPassword)
                    .WithAutoRemove(true)
                    .WithCleanUp(true)
                    .WithEnvironment("ACCEPT_EULA", "Y")
                    .WithEnvironment("SA_PASSWORD", StaticData.DbPassword)
                    .WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(StaticData.SqlPort))
                    .Build();

                await _sqlContainer.StartAsync();
            });

            var redisTask = Task.Run(async () =>
            {
                _redisContainer = new RedisBuilder()
                    .WithImage(StaticData.RedisImage)
                    .WithDockerEndpoint(StaticData.DockerEndPoint)
                    .WithAutoRemove(true)
                    .WithCleanUp(true)
                    .WithPortBinding(StaticData.RedisPort, true)
                    .WithWaitStrategy(Wait.ForUnixContainer().UntilPortIsAvailable(StaticData.RedisPort))
                    .Build();

                await _redisContainer.StartAsync();
            });

            await Task.WhenAll(sqlTask, redisTask);

            sqlConnectionString = _sqlContainer.GetConnectionString();
            redisConnectionString = _redisContainer.GetConnectionString();
        }

        // Initialize Redis Connection
        _redisConnection = await ConnectionMultiplexer.ConnectAsync(redisConnectionString);

        // Initialize SQL Connection
        _sqlConnection = new SqlConnection(sqlConnectionString);
        await _sqlConnection.OpenAsync();

        // Ensure database setup
        await _sqlConnection.ExecuteAsync(StaticData.QueryToCreateTable);
    }

    public async Task DisposeAsync()
    {
        if (_sqlContainer is not null)
        {
            _sqlConnection.Dispose();

            await _sqlContainer.StopAsync();
            await _sqlContainer.DisposeAsync();
        }

        if (_redisContainer is not null)
        {
            _redisConnection.Dispose();

            await _redisContainer.StopAsync();
            await _redisContainer.DisposeAsync();
        }
    }
}