160 lines
4.0 KiB
Go
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,
|
|
)
|
|
}
|