Testing & Benchmarking

# redis-benchmark — yerleşik performans aracı
redis-benchmark -h localhost -p 6379 -c 50 -n 100000 -q
# SET: 125000.00 requests per second
# GET: 142857.14 requests per second

# Belirli komut benchmark
redis-benchmark -t set,get -n 100000 -d 256 -q
# -d 256: 256 byte value

# Pipeline ile (daha gerçekçi)
redis-benchmark -t set,get -n 100000 -P 16 -q
# SET: 680000+ requests per second (pipeline=16)

# Lua script benchmark
redis-benchmark -n 100000 EVAL "return redis.call('SET',KEYS[1],ARGV[1])" 1 bench:key bench:val

# Latency baseline
redis-cli --latency -i 1    # her 1 saniye örnek
redis-cli --intrinsic-latency 5   # 5sn kernel latency ölç

// Testcontainers ile integration test
using Testcontainers.Redis;
using StackExchange.Redis;
using Xunit;

public class RedisIntegrationTests : IAsyncLifetime
{
    private readonly RedisContainer _redis = new RedisBuilder()
        .WithImage("redis:8-alpine")
        .Build();

    private IConnectionMultiplexer _mux = null!;
    private IDatabase _db = null!;

    public async Task InitializeAsync()
    {
        await _redis.StartAsync();
        _mux = await ConnectionMultiplexer.ConnectAsync(
            _redis.GetConnectionString());
        _db = _mux.GetDatabase();
    }

    public async Task DisposeAsync()
    {
        _mux.Dispose();
        await _redis.DisposeAsync();
    }

    [Fact]
    public async Task CacheService_SetAndGet_ReturnsValue()
    {
        // Arrange
        var service = new CachedProductRepository(_mux);

        // Act
        await _db.StringSetAsync("product:1",
            JsonSerializer.Serialize(new { Id = 1, Name = "Test" }),
            TimeSpan.FromMinutes(1));

        var result = await _db.StringGetAsync("product:1");

        // Assert
        Assert.True(result.HasValue);
        Assert.Contains("Test", result.ToString());
    }

    [Fact]
    public async Task DistributedLock_AcquireAndRelease()
    {
        // Arrange
        var lockService = new DistributedLockService(_mux);

        // Act
        await using var handle = await lockService.AcquireAsync(
            "test-resource", TimeSpan.FromSeconds(5));

        // Assert
        Assert.NotNull(handle);

        // Lock aktifken ikinci acquire başarısız olmalı
        var second = await lockService.AcquireAsync(
            "test-resource", TimeSpan.FromSeconds(5),
            waitTimeout: TimeSpan.FromMilliseconds(100));
        Assert.Null(second);
    }

    [Fact]
    public async Task RateLimiter_ExceedsLimit_Returns429Equivalent()
    {
        var limiter = new RateLimiterService(_mux);

        // 5 request, limit=3
        for (int i = 0; i < 3; i++)
        {
            var r = await limiter.CheckAsync("client1", 3, TimeSpan.FromMinutes(1));
            Assert.True(r.IsAllowed);
        }

        var blocked = await limiter.CheckAsync("client1", 3, TimeSpan.FromMinutes(1));
        Assert.False(blocked.IsAllowed);
    }
}

// BenchmarkDotNet ile client-side performans ölçümü
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[SimpleJob(iterationCount: 20)]
public class RedisBenchmarks
{
    private IDatabase _db = null!;
    private IConnectionMultiplexer _mux = null!;

    [GlobalSetup]
    public void Setup()
    {
        _mux = ConnectionMultiplexer.Connect("localhost:6379");
        _db = _mux.GetDatabase();
        _db.StringSet("bench:key", new string('x', 256));
    }

    [Benchmark(Baseline = true)]
    public async Task<RedisValue> StringGet()
        => await _db.StringGetAsync("bench:key");

    [Benchmark]
    public async Task StringSet()
        => await _db.StringSetAsync("bench:key", "value");

    [Benchmark]
    public async Task PipelinedGet10()
    {
        var tasks = Enumerable.Range(0, 10)
            .Select(_ => _db.StringGetAsync("bench:key")).ToArray();
        await Task.WhenAll(tasks);
    }

    [Benchmark]
    public void FireAndForget()
        => _db.StringIncrement("bench:counter", flags: CommandFlags.FireAndForget);

    [GlobalCleanup]
    public void Cleanup() => _mux.Dispose();
}

// Çalıştır: dotnet run -c Release -- --filter *RedisBenchmarks*