Files
mtusi2026lab2/app/internal/cache/history_test.go
T

267 lines
7.5 KiB
Go

package cache
import (
"context"
"errors"
"fmt"
"io"
"log/slog"
"os"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/redis/go-redis/v9"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
const member = "alice"
type fakeSource struct {
mu sync.Mutex
msgs []domain.Message
queryDelay time.Duration
pageCalls atomic.Int64
}
func (f *fakeSource) AddMessage(_ context.Context, callerID, chatID, text string) (domain.Message, error) {
f.mu.Lock()
defer f.mu.Unlock()
m := domain.Message{
ID: fmt.Sprintf("m%04d", len(f.msgs)),
ChatID: chatID,
AuthorID: callerID,
Text: text,
CreatedAt: time.Now().UTC(),
}
f.msgs = append(f.msgs, m)
return m, nil
}
func (f *fakeSource) IsMember(_ context.Context, _, userID string) (bool, error) {
return userID == member, nil
}
func (f *fakeSource) HistoryPage(context.Context, string, string, int) (domain.Page[domain.Message], error) {
f.pageCalls.Add(1)
f.mu.Lock()
snapshot := append([]domain.Message(nil), f.msgs...)
f.mu.Unlock()
time.Sleep(f.queryDelay)
return domain.Page[domain.Message]{Items: snapshot}, nil
}
func (f *fakeSource) ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if ok, _ := f.IsMember(ctx, chatID, callerID); !ok {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
return f.HistoryPage(ctx, chatID, cursor, limit)
}
func testClient(t *testing.T) *redis.Client {
t.Helper()
url := os.Getenv("TEST_HISTORY_CACHE_URL")
if url == "" {
t.Skip("TEST_HISTORY_CACHE_URL не задан (scripts/integration-tests.sh)")
}
opts, err := redis.ParseURL(url)
if err != nil {
t.Fatal("bad TEST_HISTORY_CACHE_URL")
}
opts.DB = 15
c := redis.NewClient(opts)
t.Cleanup(func() { c.Close() })
if err := c.FlushDB(context.Background()).Err(); err != nil {
t.Fatalf("flushdb: %v", err)
}
return c
}
func newCache(t *testing.T, c *redis.Client, mode string, src *fakeSource, fillDelay time.Duration) *Messages {
t.Helper()
m := New(src, c, Options{
Mode: mode,
PageTTL: time.Minute,
FillDelay: fillDelay,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
t.Cleanup(m.Close)
return m
}
func contains(p domain.Page[domain.Message], id string) bool {
for _, m := range p.Items {
if m.ID == id {
return true
}
}
return false
}
func TestReadAfterWrite_FillRace(t *testing.T) {
ctx := context.Background()
for _, tc := range []struct {
mode string
wantStale bool
}{
{ModeNaive, true},
{ModeSafe, false},
} {
t.Run(tc.mode, func(t *testing.T) {
c := testClient(t)
src := &fakeSource{}
h := newCache(t, c, tc.mode, src, 100*time.Millisecond)
chat := "chat-raw-" + tc.mode
if _, err := h.AddMessage(ctx, member, chat, "old"); err != nil {
t.Fatal(err)
}
readerDone := make(chan struct{})
go func() {
defer close(readerDone)
_, _ = h.ListMessages(ctx, member, chat, "", 50) // промах → снимок без "new" → пауза → SET
}()
time.Sleep(30 * time.Millisecond) // читатель уже внутри окна FillDelay
msg, err := h.AddMessage(ctx, member, chat, "new")
if err != nil {
t.Fatal(err)
}
<-readerDone
page, err := h.ListMessages(ctx, member, chat, "", 50)
if err != nil {
t.Fatal(err)
}
stale := !contains(page, msg.ID)
if stale != tc.wantStale {
t.Fatalf("%s: stale=%v, ожидалось %v", tc.mode, stale, tc.wantStale)
}
t.Logf("%s: чтение после подтверждённой записи stale=%v", tc.mode, stale)
})
}
}
func TestStampede_SQLCount(t *testing.T) {
ctx := context.Background()
const readers = 50
results := map[string]int64{}
for _, mode := range []string{ModeNaive, ModeSafe} {
t.Run(mode, func(t *testing.T) {
c := testClient(t)
src := &fakeSource{queryDelay: 20 * time.Millisecond}
h := newCache(t, c, mode, src, 0)
chat := "chat-stampede-" + mode
if _, err := h.ListMessages(ctx, member, chat, "", 50); err != nil {
t.Fatal(err)
}
warmPool(t, c, readers)
msg, _ := h.AddMessage(ctx, member, chat, "invalidate")
before := src.pageCalls.Load()
var wg sync.WaitGroup
var stale atomic.Int64
start := make(chan struct{})
for i := 0; i < readers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
<-start
p, err := h.ListMessages(ctx, member, chat, "", 50)
if err != nil || !contains(p, msg.ID) {
stale.Add(1)
}
}()
}
close(start)
wg.Wait()
calls := src.pageCalls.Load() - before
results[mode] = calls
if stale.Load() != 0 {
t.Fatalf("%d читателей не увидели подтверждённое сообщение", stale.Load())
}
t.Logf("%s: %d одновременных промахов → %d запросов страницы в БД", mode, readers, calls)
if mode == ModeSafe && calls != 1 {
t.Fatalf("safe: ожидался 1 запрос в БД, было %d", calls)
}
if mode == ModeNaive && calls < readers/2 {
t.Fatalf("naive: ожидался stampede (≥%d запросов), было %d", readers/2, calls)
}
})
}
}
func warmPool(t *testing.T, c *redis.Client, n int) {
t.Helper()
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
defer wg.Done()
_ = c.Do(context.Background(), "DEBUG", "SLEEP", "0.05").Err()
}()
}
wg.Wait()
}
func TestAccessCheckedBeforeCache(t *testing.T) {
ctx := context.Background()
c := testClient(t)
h := newCache(t, c, ModeSafe, &fakeSource{}, 0)
if _, err := h.ListMessages(ctx, member, "chat-acl", "", 50); err != nil {
t.Fatal(err)
}
if _, err := h.ListMessages(ctx, "mallory", "chat-acl", "", 50); !errors.Is(err, domain.ErrNotFound) {
t.Fatalf("посторонний: err = %v, want ErrNotFound", err)
}
}
func TestCacheLossIsOnlyMiss(t *testing.T) {
ctx := context.Background()
c := testClient(t)
src := &fakeSource{}
h := newCache(t, c, ModeSafe, src, 0)
chat := "chat-loss"
if _, err := h.ListMessages(ctx, member, chat, "", 50); err != nil {
t.Fatal(err)
}
if err := c.Del(ctx, verKey(chat)).Err(); err != nil {
t.Fatal(err)
}
msg, _ := src.AddMessage(ctx, member, chat, "написано в обход кэша")
before := src.pageCalls.Load()
page, err := h.ListMessages(ctx, member, chat, "", 50)
if err != nil {
t.Fatal(err)
}
if !contains(page, msg.ID) || src.pageCalls.Load() != before+1 {
t.Fatalf("после потери версии ожидался промах и свежая страница")
}
}
func TestCacheDown_Bypass(t *testing.T) {
ctx := context.Background()
dead := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:1", DialTimeout: 50 * time.Millisecond, MaxRetries: -1,
})
t.Cleanup(func() { dead.Close() })
src := &fakeSource{}
h := newCache(t, dead, ModeSafe, src, 0)
msg, err := h.AddMessage(ctx, member, "chat-down", "при упавшем кэше")
if err != nil {
t.Fatalf("запись при упавшем кэше: %v", err)
}
page, err := h.ListMessages(ctx, member, "chat-down", "", 50)
if err != nil || !contains(page, msg.ID) {
t.Fatalf("чтение при упавшем кэше: err=%v", err)
}
if !h.bypass("chat-down") {
t.Fatal("чат с несброшенной версией должен читаться мимо кэша")
}
if _, err := h.ListMessages(ctx, "mallory", "chat-down", "", 50); !errors.Is(err, domain.ErrNotFound) {
t.Fatalf("обход кэша не должен пропускать постороннего: %v", err)
}
}