internal/store/postgres/channel_dialog_cache_test.go
Rama main · réplica de lectura del repositorio original.
package postgres
import (
"context"
"fmt"
"sync"
"sync/atomic"
"testing"
"time"
"telesrv/internal/domain"
)
func TestChannelDialogCacheNilDisabled(t *testing.T) {
if c := NewChannelDialogCache(0); c != nil {
t.Fatalf("max<=0 should return nil (disabled), got %v", c)
}
var nilCache *ChannelDialogCache
nilCache.put(domain.ChannelDialog{UserID: 1, ChannelID: 2})
nilCache.delete(1, 2)
nilCache.deleteChannel(2)
nilCache.flush()
if _, ok := nilCache.get(1, 2); ok {
t.Fatalf("nil cache get must return ok=false")
}
}
func TestChannelDialogCachePutGetDeleteFlushAndClone(t *testing.T) {
c := NewChannelDialogCache(16)
dialog := domain.ChannelDialog{
UserID: 10,
ChannelID: 20,
FolderID: 1,
TopMessageID: 9,
TopMessageDate: 100,
ReadInboxMaxID: 7,
ReadOutboxMaxID: 8,
UnreadCount: 2,
Pinned: true,
ViewForumAsMessages: true,
DefaultSendAs: &domain.Peer{Type: domain.PeerTypeUser, ID: 10},
}
if _, ok := c.get(10, 20); ok {
t.Fatalf("an empty cache should not hit")
}
c.put(dialog)
dialog.DefaultSendAs.ID = 99
got, ok := c.get(10, 20)
if !ok || got.UserID != 10 || got.ChannelID != 20 || got.DefaultSendAs == nil || got.DefaultSendAs.ID != 10 {
t.Fatalf("put/get round trip or write clone failed: %+v ok=%v", got, ok)
}
got.DefaultSendAs.ID = 77
again, ok := c.get(10, 20)
if !ok || again.DefaultSendAs == nil || again.DefaultSendAs.ID != 10 {
t.Fatalf("the read result must be cloned to keep callers from polluting the cache: %+v ok=%v", again, ok)
}
c.delete(10, 20)
if _, ok := c.get(10, 20); ok {
t.Fatalf("should not hit after delete")
}
c.put(dialog)
c.flush()
if _, ok := c.get(10, 20); ok {
t.Fatalf("should not hit after flush")
}
}
func TestChannelDialogCacheSeparatesAuthoritativeListProjection(t *testing.T) {
c := NewChannelDialogCache(16)
dialog := domain.ChannelDialog{UserID: 10, ChannelID: 20, TopMessageID: 9}
c.put(dialog)
if _, ok := c.getListProjection(10, 20); ok {
t.Fatal("single-channel cache entry without active-list proof must not enter getDialogs")
}
epoch := c.cacheEpoch()
c.putListProjectionIfEpoch(dialog, true, true, true, epoch)
entry, ok := c.getListProjection(10, 20)
if !ok || !entry.listVisible || !entry.topMentioned || !entry.topMediaUnread || !entry.topUnreadProjected {
t.Fatalf("list projection = %+v,%v", entry, ok)
}
entry.dialog.TopMessageID = 99
again, ok := c.getListProjection(10, 20)
if !ok || again.dialog.TopMessageID != 9 {
t.Fatalf("list projection clone isolation = %+v,%v", again, ok)
}
}
func TestChannelDialogCacheDeleteChannelAndCap(t *testing.T) {
c := NewChannelDialogCache(2)
c.put(domain.ChannelDialog{UserID: 1, ChannelID: 10, TopMessageID: 1})
c.put(domain.ChannelDialog{UserID: 2, ChannelID: 10, TopMessageID: 2})
c.put(domain.ChannelDialog{UserID: 1, ChannelID: 11, TopMessageID: 3})
c.deleteChannel(10)
if _, ok := c.get(1, 10); ok {
t.Fatalf("deleteChannel should invalidate user 1 for the same channel")
}
if _, ok := c.get(2, 10); ok {
t.Fatalf("deleteChannel should invalidate user 2 for the same channel")
}
if got, ok := c.get(1, 11); !ok || got.TopMessageID != 3 {
t.Fatalf("other channels should not be invalidated: %+v ok=%v", got, ok)
}
c.put(domain.ChannelDialog{UserID: 1, ChannelID: 12, TopMessageID: 4})
c.put(domain.ChannelDialog{UserID: 1, ChannelID: 13, TopMessageID: 5}) // over cap=2: LRU evicts the oldest (1,11)
if _, ok := c.get(1, 11); ok {
t.Fatalf("over the limit the oldest entry (1,11) should be evicted")
}
if got, ok := c.get(1, 12); !ok || got.TopMessageID != 4 {
t.Fatalf("single-entry LRU eviction should keep the next-newest entry (1,12), proving it is not a whole-table flush: %+v ok=%v", got, ok)
}
if got, ok := c.get(1, 13); !ok || got.TopMessageID != 5 {
t.Fatalf("the newest entry (1,13) should be present: %+v ok=%v", got, ok)
}
}
func TestChannelDialogCacheSingleflightsColdLoad(t *testing.T) {
c := NewChannelDialogCache(16)
var calls atomic.Int32
started := make(chan struct{})
release := make(chan struct{})
var once sync.Once
load := func() (domain.ChannelDialog, error) {
calls.Add(1)
once.Do(func() { close(started) })
<-release
return domain.ChannelDialog{UserID: 7, ChannelID: 100, TopMessageID: 11}, nil
}
const goroutines = 16
var wg sync.WaitGroup
errs := make(chan error, goroutines)
wg.Add(goroutines)
for i := 0; i < goroutines; i++ {
go func() {
defer wg.Done()
dialog, err := c.getOrLoad(context.Background(), 7, 100, load)
if err != nil {
errs <- err
return
}
if dialog.UserID != 7 || dialog.ChannelID != 100 || dialog.TopMessageID != 11 {
errs <- fmt.Errorf("dialog = %+v, want 7/100/top11", dialog)
}
}()
}
<-started
time.Sleep(20 * time.Millisecond)
close(release)
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
if got := calls.Load(); got != 1 {
t.Fatalf("load calls = %d, want 1", got)
}
if _, err := c.getOrLoad(context.Background(), 7, 100, load); err != nil {
t.Fatalf("cached getOrLoad: %v", err)
}
if got := calls.Load(); got != 1 {
t.Fatalf("cache hit called load again: calls=%d", got)
}
}
func TestReadModelChangeListenerInvalidatesChannelDialogCache(t *testing.T) {
dialogs := NewChannelDialogCache(16)
dialogs.put(domain.ChannelDialog{UserID: 100, ChannelID: 7, TopMessageID: 1})
dialogs.put(domain.ChannelDialog{UserID: 100, ChannelID: 8, TopMessageID: 2})
dialogs.put(domain.ChannelDialog{UserID: 200, ChannelID: 7, TopMessageID: 3})
listener := NewReadModelChangeListener("", ReadModelCacheSet{ChannelDialogs: dialogs}, nil)
listener.handlePayload(`{"model":"dialog_light","owner_user_id":100,"peer_type":"channel","peer_id":7}`)
if _, ok := dialogs.get(100, 7); ok {
t.Fatalf("a dialog_light event should invalidate the exact viewer/channel")
}
if got, ok := dialogs.get(100, 8); !ok || got.TopMessageID != 2 {
t.Fatalf("other channels should not be invalidated: %+v ok=%v", got, ok)
}
if got, ok := dialogs.get(200, 7); !ok || got.TopMessageID != 3 {
t.Fatalf("other viewers should not be invalidated: %+v ok=%v", got, ok)
}
listener.handlePayload(`{"model":"channel_member","owner_user_id":200,"peer_type":"channel","peer_id":7}`)
if _, ok := dialogs.get(200, 7); ok {
t.Fatalf("a channel_member event should invalidate the corresponding viewer/channel")
}
listener.handlePayload(`{"model":"channel_base","owner_user_id":0,"peer_type":"channel","peer_id":8}`)
if _, ok := dialogs.get(100, 8); ok {
t.Fatalf("a channel_base event should invalidate all viewer dialogs of that channel")
}
}