forked from mtusi2026/mtusi2026lab3
184 lines
4.4 KiB
Go
184 lines
4.4 KiB
Go
package cache
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log"
|
|
"testing"
|
|
|
|
"mtusi2026lab3/internal/adapter/memory"
|
|
"mtusi2026lab3/internal/adapter/redis"
|
|
"mtusi2026lab3/internal/application"
|
|
"mtusi2026lab3/internal/domain"
|
|
)
|
|
|
|
type fakeChatCache struct {
|
|
chats map[string]domain.Chat
|
|
getErr error
|
|
setErr error
|
|
sets int
|
|
}
|
|
|
|
func (c *fakeChatCache) Get(
|
|
_ context.Context,
|
|
chatID string,
|
|
) (domain.Chat, error) {
|
|
if c.getErr != nil {
|
|
return domain.Chat{}, c.getErr
|
|
}
|
|
|
|
chat, exists := c.chats[chatID]
|
|
if !exists {
|
|
return domain.Chat{}, redis.ErrMiss
|
|
}
|
|
|
|
return chat, nil
|
|
}
|
|
|
|
func (c *fakeChatCache) Set(
|
|
_ context.Context,
|
|
chat domain.Chat,
|
|
) error {
|
|
c.sets++
|
|
if c.setErr != nil {
|
|
return c.setErr
|
|
}
|
|
c.chats[chat.ID] = chat
|
|
|
|
return nil
|
|
}
|
|
|
|
type countingRepository struct {
|
|
application.Repository
|
|
getChatCalls int
|
|
}
|
|
|
|
func (r *countingRepository) GetChatByID(
|
|
ctx context.Context,
|
|
chatID string,
|
|
callerID string,
|
|
) (domain.Chat, error) {
|
|
r.getChatCalls++
|
|
return r.Repository.GetChatByID(ctx, chatID, callerID)
|
|
}
|
|
|
|
func cachedRepositoryFixture(
|
|
t *testing.T,
|
|
) (*countingRepository, *fakeChatCache, domain.User, domain.User, domain.Chat) {
|
|
t.Helper()
|
|
|
|
legacy := memory.NewMemoryStore()
|
|
member, err := legacy.CreateUser("cache_member", "Участник")
|
|
if err != nil {
|
|
t.Fatalf("create member: %v", err)
|
|
}
|
|
outsider, err := legacy.CreateUser("cache_outsider", "Посторонний")
|
|
if err != nil {
|
|
t.Fatalf("create outsider: %v", err)
|
|
}
|
|
chat, err := legacy.CreateChat("Кешируемый чат", []string{member.ID})
|
|
if err != nil {
|
|
t.Fatalf("create chat: %v", err)
|
|
}
|
|
|
|
repository := &countingRepository{
|
|
Repository: memory.NewMemoryRepository(legacy),
|
|
}
|
|
chatCache := &fakeChatCache{
|
|
chats: make(map[string]domain.Chat),
|
|
}
|
|
|
|
return repository, chatCache, member, outsider, chat
|
|
}
|
|
|
|
func TestCachedRepositoryMissThenHit(t *testing.T) {
|
|
repository, chatCache, member, _, expected := cachedRepositoryFixture(t)
|
|
cached := NewCachedRepository(
|
|
repository,
|
|
chatCache,
|
|
log.New(io.Discard, "", 0),
|
|
)
|
|
|
|
first, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
|
|
if err != nil {
|
|
t.Fatalf("first read: %v", err)
|
|
}
|
|
second, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
|
|
if err != nil {
|
|
t.Fatalf("second read: %v", err)
|
|
}
|
|
|
|
if repository.getChatCalls != 1 {
|
|
t.Fatalf("expected one source read, got %d", repository.getChatCalls)
|
|
}
|
|
if chatCache.sets != 1 {
|
|
t.Fatalf("expected one cache fill, got %d", chatCache.sets)
|
|
}
|
|
if first.ID != expected.ID || second.ID != expected.ID {
|
|
t.Fatal("cache changed chat identity")
|
|
}
|
|
}
|
|
|
|
func TestCachedRepositoryFallsBackWhenCacheUnavailable(t *testing.T) {
|
|
repository, chatCache, member, _, expected := cachedRepositoryFixture(t)
|
|
chatCache.getErr = errors.New("redis unavailable")
|
|
chatCache.setErr = errors.New("redis unavailable")
|
|
cached := NewCachedRepository(
|
|
repository,
|
|
chatCache,
|
|
log.New(io.Discard, "", 0),
|
|
)
|
|
|
|
chat, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
|
|
if err != nil {
|
|
t.Fatalf("fallback read: %v", err)
|
|
}
|
|
if chat.ID != expected.ID || repository.getChatCalls != 1 {
|
|
t.Fatal("source repository was not used after cache failure")
|
|
}
|
|
if chatCache.sets != 0 {
|
|
t.Fatal("failed cache read must not trigger another cache operation")
|
|
}
|
|
}
|
|
|
|
func TestCachedRepositoryChecksMembershipOnHit(t *testing.T) {
|
|
repository, chatCache, _, outsider, expected := cachedRepositoryFixture(t)
|
|
chatCache.chats[expected.ID] = expected
|
|
cached := NewCachedRepository(
|
|
repository,
|
|
chatCache,
|
|
log.New(io.Discard, "", 0),
|
|
)
|
|
|
|
_, err := cached.GetChatByID(context.Background(), expected.ID, outsider.ID)
|
|
if !errors.Is(err, domain.ErrNotFound) {
|
|
t.Fatalf("expected ErrNotFound for outsider, got %v", err)
|
|
}
|
|
if repository.getChatCalls != 0 {
|
|
t.Fatal("cache hit unexpectedly queried source repository")
|
|
}
|
|
}
|
|
|
|
func TestCachedRepositoryIgnoresWriteFailure(t *testing.T) {
|
|
repository, chatCache, member, _, _ := cachedRepositoryFixture(t)
|
|
chatCache.setErr = errors.New("redis unavailable")
|
|
cached := NewCachedRepository(
|
|
repository,
|
|
chatCache,
|
|
log.New(io.Discard, "", 0),
|
|
)
|
|
|
|
chat, err := cached.CreateChat(
|
|
context.Background(),
|
|
"Новый чат",
|
|
[]string{member.ID},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("create chat with unavailable cache: %v", err)
|
|
}
|
|
if chat.ID == "" || chatCache.sets != 1 {
|
|
t.Fatal("chat was not created before best-effort cache write")
|
|
}
|
|
}
|