تست نویسی با دیتابیس واقعی

public class RedisCacheRepository : ICacheRepository
{
    private readonly IDatabase _datebase;
    public RedisCacheRepository(IConnectionMultiplexer connectionMultiplexer)
    {
        _datebase = connectionMultiplexer.GetDatabase();
    }

    public async Task<T> GetAsync<T>(string key)
    {
        var redisValue = await _datebase.StringGetAsync(key);

        if (string.IsNullOrWhiteSpace(redisValue))
            return default;

        return JsonConvert.DeserializeObject<T>(redisValue);
    }

    public async Task SetAsync<T>(string key, T value,  TimeSpan expireTime)
    {
        var redisValue = JsonConvert.SerializeObject(value);

        await _datebase.StringSetAsync(key, redisValue, expireTime);
    }
}

public class RedisInitializer : IAsyncLifetime
{
    private readonly RedisTestcontainer _redisTestcontainer;

    public IConnectionMultiplexer RedisConnection { get; private set; }
    public RedisInitializer()
    {
        _redisTestcontainer = new TestcontainersBuilder<RedisTestcontainer>()
           .WithDatabase(new RedisTestcontainerConfiguration
           {
               Port = 6379
           })
           .WithImage("redis:5.0.14")
           .WithCleanUp(true)
           .WithExposedPort(6379)
           .WithPortBinding(6379, true)
           .Build();
    }
    public async Task DisposeAsync()
    {
        await _redisTestcontainer.StopAsync();
    }

    public async Task InitializeAsync()
    {
        await _redisTestcontainer.StartAsync();

        RedisConnection = ConnectionMultiplexer
            .Connect(_redisTestcontainer.ConnectionString);
    }
}

[Collection("Sequential")]
public class RedisCacheRepositoryTest : IClassFixture<RedisInitializer>
{
    private readonly ICacheRepository _cacheRepository;

    public RedisCacheRepositoryTest(RedisInitializer redisInitializer)
    {
        _cacheRepository = new RedisCacheRepository(redisInitializer.RedisConnection);
    }

    [Fact]
    public async Task When_CacheKeyIsNotExist_Then_ForReferenceTypesNullShouldReturned()
    {
        var invalidCacheKey = "invalidCacheKey";

        var result = await _cacheRepository.GetAsync<UserModel>(invalidCacheKey);

        Assert.Null(result);
    }

    [Fact]
    public async Task When_CacheTimeIsExpired_Then_CacheRepositoryShouldReturnDefaultValue()
    {
        var cacheKey = "Test";

        var data = 10;

        var expireTime = TimeSpan.FromSeconds(10);

        await _cacheRepository.SetAsync(cacheKey, data, expireTime);

        var cacheValue = await _cacheRepository.GetAsync<int>(cacheKey);

        Assert.Equal(data, cacheValue);

        await Task.Delay(expireTime);// wait to expire cache

        cacheValue = await _cacheRepository.GetAsync<int>(cacheKey);

        Assert.Equal(0, cacheValue);
    }
}