Files
mtusi2026lab4/internal/storage/postgres/cache_latency_experiment_test.go
T
2026-10-15 20:45:29 +03:00

160 lines
4.0 KiB
Go

//go:build integration
package postgres_test
import (
"context"
"fmt"
"sort"
"sync/atomic"
"testing"
"time"
"github.com/google/uuid"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"mtusi-messenger/internal/domain"
"mtusi-messenger/internal/platform/cache"
storageredis "mtusi-messenger/internal/storage/redis"
"mtusi-messenger/internal/storage/redis/mocks"
)
func TestCacheLatencyExperiment(t *testing.T) {
suite := new(BaseSuite)
suite.SetT(t)
suite.SetupTest()
defer suite.TearDownTest()
ctx := context.Background()
redisConfig := cache.RedisConfig{
Host: envOr("TEST_REDIS_HOST", "localhost"),
Port: envInt("TEST_REDIS_PORT", 6379),
Password: envOr("TEST_REDIS_PASSWORD", ""),
DB: envInt("TEST_REDIS_DB", 2),
DialTimeout: 5 * time.Second,
ReadTimeout: 3 * time.Second,
WriteTimeout: 3 * time.Second,
PoolSize: 5,
}
redisCache, err := cache.NewRedis(redisConfig)
require.NoError(t, err)
defer func() { _ = redisCache.Close() }()
alice := suite.createUser("latency_alice")
for range 20 {
suite.createChat(alice)
}
realChats := suite.store.Chats()
var loads atomic.Int32
source := mocks.NewMockChatSource(t)
source.EXPECT().ListVersion(mock.Anything, mock.Anything).RunAndReturn(
func(ctx context.Context, userID uuid.UUID) (int64, error) {
return realChats.ListVersion(ctx, userID)
}).Maybe()
source.EXPECT().ListVisible(mock.Anything, mock.Anything, mock.Anything, mock.Anything).
RunAndReturn(func(ctx context.Context, callerID uuid.UUID, after *domain.Cursor, limit int) (domain.Page[domain.Chat], error) {
loads.Add(1)
return realChats.ListVisible(ctx, callerID, after, limit)
}).Maybe()
for range 50 {
_, err := source.ListVisible(ctx, alice.ID, nil, 50)
require.NoError(t, err)
}
loads.Store(0)
baseline := measureLatency(ctx, t, source.ListVisible, &loads, alice.ID, 1000)
distributed, err := cache.NewDistributed(redisCache, cache.DistributedConfig{}, nil)
require.NoError(t, err)
cached := storageredis.NewChatRepository(
source,
distributed,
time.Minute,
nil,
)
loads.Store(0)
cachedStats := measureCachedLatency(ctx, t, cached, alice.ID, 1000)
cachedStats.Loads = int(loads.Load())
require.Equal(t, 1000, baseline.Loads)
require.Equal(t, 1, cachedStats.Loads)
t.Logf("baseline: %s", formatLatency(baseline))
t.Logf("redis cache: %s", formatLatency(cachedStats))
}
func measureLatency(
ctx context.Context,
t *testing.T,
list func(context.Context, uuid.UUID, *domain.Cursor, int) (domain.Page[domain.Chat], error),
loads *atomic.Int32,
callerID uuid.UUID,
requests int,
) latencyStats {
t.Helper()
values := make([]time.Duration, 0, requests)
for range requests {
started := time.Now()
_, err := list(ctx, callerID, nil, 50)
require.NoError(t, err)
values = append(values, time.Since(started))
}
return makeLatencyStats(values, int(loads.Load()))
}
func measureCachedLatency(
ctx context.Context,
t *testing.T,
repository *storageredis.ChatRepository,
callerID uuid.UUID,
requests int,
) latencyStats {
t.Helper()
values := make([]time.Duration, 0, requests)
for range requests {
started := time.Now()
_, err := repository.ListVisible(ctx, callerID, nil, 50)
require.NoError(t, err)
values = append(values, time.Since(started))
}
return makeLatencyStats(values, 0)
}
type latencyStats struct {
Requests int
Loads int
P50 time.Duration
P95 time.Duration
P99 time.Duration
}
func makeLatencyStats(values []time.Duration, loads int) latencyStats {
sort.Slice(values, func(i, j int) bool { return values[i] < values[j] })
percentile := func(percent int) time.Duration {
index := (len(values)*percent + 99) / 100
if index > 0 {
index--
}
return values[index]
}
return latencyStats{
Requests: len(values), Loads: loads,
P50: percentile(50), P95: percentile(95), P99: percentile(99),
}
}
func formatLatency(value latencyStats) string {
return fmt.Sprintf(
"requests=%d source_loads=%d p50=%s p95=%s p99=%s",
value.Requests, value.Loads, value.P50, value.P95, value.P99,
)
}