forked from mtusi2026/mtusi2026lab2
426 lines
13 KiB
Go
426 lines
13 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)
|
|
}
|
|
}
|
|
|
|
type fakeOutbox struct {
|
|
mu sync.Mutex
|
|
rows map[string]int64
|
|
seq int64 // как cache_invalidations_gen_seq: gen не повторяется
|
|
loadErr error
|
|
}
|
|
|
|
func (f *fakeOutbox) AddPendingInvalidation(_ context.Context, chatID string) (int64, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.seq++
|
|
f.rows[chatID] = f.seq
|
|
return f.seq, nil
|
|
}
|
|
|
|
func (f *fakeOutbox) PendingInvalidations(context.Context) (map[string]int64, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
if f.loadErr != nil {
|
|
return nil, f.loadErr
|
|
}
|
|
out := make(map[string]int64, len(f.rows))
|
|
for k, v := range f.rows {
|
|
out[k] = v
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (f *fakeOutbox) ResolvePendingInvalidation(_ context.Context, chatID string, gen int64) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
if f.rows[chatID] == gen {
|
|
delete(f.rows, chatID)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeOutbox) len() int {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return len(f.rows)
|
|
}
|
|
|
|
// Сброс версии не удался, процесс API перезапущен: новый процесс не знает о
|
|
// долге из памяти, но обязан отдать подтверждённое сообщение сразу.
|
|
func TestReadAfterWrite_InvalidationFailedThenRestart(t *testing.T) {
|
|
ctx := context.Background()
|
|
c := testClient(t)
|
|
src := &fakeSource{}
|
|
outbox := &fakeOutbox{rows: map[string]int64{}}
|
|
chat := "chat-restart"
|
|
opts := Options{
|
|
Mode: ModeSafe,
|
|
Outbox: outbox,
|
|
PageTTL: time.Minute,
|
|
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
|
|
}
|
|
|
|
warm := New(src, c, opts)
|
|
if _, err := warm.ListMessages(ctx, member, chat, "", 50); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
warm.Close()
|
|
|
|
dead := redis.NewClient(&redis.Options{
|
|
Addr: "127.0.0.1:1", DialTimeout: 50 * time.Millisecond, MaxRetries: -1,
|
|
})
|
|
t.Cleanup(func() { dead.Close() })
|
|
before := New(src, dead, opts)
|
|
msg, err := before.AddMessage(ctx, member, chat, "подтверждено 201")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before.Close() // рестарт: память процесса потеряна, старая версия в Valkey жива
|
|
if outbox.len() != 1 {
|
|
t.Fatalf("долг инвалидации не записан в Outbox")
|
|
}
|
|
|
|
after := New(src, c, opts)
|
|
t.Cleanup(after.Close)
|
|
page, err := after.ListMessages(ctx, member, chat, "", 50)
|
|
if err != nil || !contains(page, msg.ID) {
|
|
t.Fatalf("после рестарта подтверждённое сообщение не видно: err=%v", err)
|
|
}
|
|
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for outbox.len() != 0 || after.bypass(chat) {
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("отложенная инвалидация не выполнена после рестарта")
|
|
}
|
|
time.Sleep(20 * time.Millisecond)
|
|
}
|
|
for i := 0; i < 2; i++ { // промах, затем попадание с новой версией
|
|
page, err = after.ListMessages(ctx, member, chat, "", 50)
|
|
if err != nil || !contains(page, msg.ID) {
|
|
t.Fatalf("чтение через кэш после инвалидации: err=%v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBypassUntilOutboxLoaded(t *testing.T) {
|
|
outbox := &fakeOutbox{rows: map[string]int64{}, loadErr: errors.New("db down")}
|
|
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
|
|
Mode: ModeSafe,
|
|
Outbox: outbox,
|
|
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
|
|
})
|
|
defer h.Close()
|
|
time.Sleep(3 * retryInterval)
|
|
if !h.bypass("any") {
|
|
t.Fatal("пока долг из Outbox не прочитан, кэш не должен отдавать страницы")
|
|
}
|
|
outbox.mu.Lock()
|
|
outbox.loadErr = nil
|
|
outbox.mu.Unlock()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for h.bypass("any") {
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("после загрузки Outbox чтение через кэш не включилось")
|
|
}
|
|
time.Sleep(20 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
// Повтор сбросил версию и снял строку Outbox, но до того, как он снял запись
|
|
// из памяти, новая запись снова не смогла сбросить версию. Запись в памяти и
|
|
// строка Outbox должны остаться, иначе ответ 201 придёт при устаревшем кэше.
|
|
func TestRetryDoesNotDropNewerFailure(t *testing.T) {
|
|
ctx := context.Background()
|
|
outbox := &fakeOutbox{rows: map[string]int64{}}
|
|
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
|
|
Mode: ModeSafe,
|
|
Outbox: outbox,
|
|
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
|
|
})
|
|
h.Close() // повтор ведём вручную
|
|
h.loaded.Store(true)
|
|
chat := "chat-retry-race"
|
|
|
|
h.addPending(ctx, chat)
|
|
snap := h.pending[chat] // снимок повтора; DEL версии прошёл
|
|
if err := outbox.ResolvePendingInvalidation(ctx, chat, snap.gen); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h.addPending(ctx, chat) // новый сбой DEL до ответа 201
|
|
h.resolved(chat, snap)
|
|
|
|
if !h.bypass(chat) {
|
|
t.Fatal("повтор снял запись о более новом сбое")
|
|
}
|
|
if rows, _ := outbox.PendingInvalidations(ctx); rows[chat] <= snap.gen {
|
|
t.Fatalf("строка Outbox: gen=%d, ожидался новый gen > %d", rows[chat], snap.gen)
|
|
}
|
|
h.resolved(chat, h.pending[chat])
|
|
if h.bypass(chat) {
|
|
t.Fatal("актуальный повтор должен снять запись")
|
|
}
|
|
}
|