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

209 lines
6.1 KiB
Go

package cache
import (
"context"
"errors"
"fmt"
"io"
"log/slog"
"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, _ []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 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 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", randomVersion(), "при упавшем кэше", nil)
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)
}
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("актуальный повтор должен снять запись")
}
}