Files
mtusi2026lab5/internal/chat/service_test.go
T

393 lines
13 KiB
Go

package chat_test
import (
"context"
"errors"
"fmt"
"io"
"log/slog"
"os"
"reflect"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/google/uuid"
"messenger/internal/chat"
"messenger/internal/chat/store"
"messenger/internal/platform/apperr"
"messenger/internal/platform/ident"
"messenger/internal/testenv"
"messenger/internal/user"
userstore "messenger/internal/user/store"
)
var db *testenv.DB
func TestMain(m *testing.M) {
var err error
db, err = testenv.StartPostgres(context.Background())
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
code := m.Run()
db.Close()
os.Exit(code)
}
// countingUsers passes through to the real users service and counts the
// lookups, which proves that member checks are batched.
type countingUsers struct {
*user.Service
calls atomic.Int32
}
func (c *countingUsers) ExistingIDs(ctx context.Context, ids []uuid.UUID) ([]uuid.UUID, error) {
c.calls.Add(1)
return c.Service.ExistingIDs(ctx, ids)
}
type fixture struct {
svc *chat.Service
users *countingUsers
alice, bob uuid.UUID
eve uuid.UUID
ctx context.Context
}
func newFixture(t *testing.T) fixture {
t.Helper()
db.Reset(t)
ctx := context.Background()
users := &countingUsers{Service: user.NewService(userstore.NewUsers(db.Pool))}
register := func(name string) uuid.UUID {
u, err := users.Register(ctx, name, name, "correct-horse-battery")
if err != nil {
t.Fatal(err)
}
return u.ID
}
return fixture{
svc: chat.NewService(store.NewChats(db.Pool), store.NewMessages(db.Pool), users, time.Hour),
users: users,
alice: register("alice"),
bob: register("bob"),
eve: register("eve"),
ctx: ctx,
}
}
func TestCreateChatChecksMembersInOneCall(t *testing.T) {
f := newFixture(t)
c, err := f.svc.Create(f.ctx, f.alice, "Проект", []uuid.UUID{f.eve, f.alice, f.bob})
if err != nil {
t.Fatalf("Create error: %v", err)
}
if c.Title != "Проект" || len(c.MemberIDs) != 3 {
t.Fatalf("unexpected chat %+v", c)
}
if got := f.users.calls.Load(); got != 1 {
t.Fatalf("member existence must be checked with one batch call, got %d", got)
}
got, err := f.svc.Get(f.ctx, f.bob, c.ID)
if err != nil {
t.Fatalf("member Get error: %v", err)
}
if fmt.Sprint(got.MemberIDs) != fmt.Sprint(c.MemberIDs) || !got.CreatedAt.Equal(c.CreatedAt) || got.Title != c.Title {
t.Fatalf("Get = %+v, want what Create returned %+v", got, c)
}
}
func TestCreateChatRejectsUnknownMember(t *testing.T) {
f := newFixture(t)
_, err := f.svc.Create(f.ctx, f.alice, "t", []uuid.UUID{f.alice, ident.New()})
if apperr.KindOf(err) != apperr.KindInvalid {
t.Fatalf("kind = %v, want KindInvalid (%v)", apperr.KindOf(err), err)
}
if !strings.Contains(err.Error(), "member_ids") {
t.Fatalf("message must name the field: %v", err)
}
}
func TestCreateChatRejectsInvalidInputBeforeAnyLookup(t *testing.T) {
f := newFixture(t)
cases := map[string]struct {
title string
members []uuid.UUID
}{
"blank title": {" ", []uuid.UUID{f.alice}},
"missing creator": {"t", []uuid.UUID{f.bob}},
"duplicate": {"t", []uuid.UUID{f.alice, f.alice}},
}
for name, tc := range cases {
_, err := f.svc.Create(f.ctx, f.alice, tc.title, tc.members)
if apperr.KindOf(err) != apperr.KindInvalid {
t.Errorf("%s: kind = %v, want KindInvalid (%v)", name, apperr.KindOf(err), err)
}
}
if got := f.users.calls.Load(); got != 0 {
t.Fatalf("invalid input must be rejected before any user lookup, got %d calls", got)
}
}
func TestGetHidesForeignAndUnknownChatsAlike(t *testing.T) {
f := newFixture(t)
c, err := f.svc.Create(f.ctx, f.alice, "t", []uuid.UUID{f.alice, f.bob})
if err != nil {
t.Fatal(err)
}
_, foreign := f.svc.Get(f.ctx, f.eve, c.ID)
_, unknown := f.svc.Get(f.ctx, f.eve, ident.New())
if !errors.Is(foreign, chat.ErrNotFound) || !errors.Is(unknown, chat.ErrNotFound) {
t.Fatalf("foreign = %v, unknown = %v; want both ErrNotFound", foreign, unknown)
}
if apperr.KindOf(foreign) != apperr.KindNotFound {
t.Fatalf("ErrNotFound must carry KindNotFound, got %v", apperr.KindOf(foreign))
}
}
func TestListPagesOnlyOwnChats(t *testing.T) {
f := newFixture(t)
var mine []uuid.UUID
for range 3 {
c, err := f.svc.Create(f.ctx, f.alice, "t", []uuid.UUID{f.alice, f.bob})
if err != nil {
t.Fatal(err)
}
mine = append(mine, c.ID)
if _, err := f.svc.Create(f.ctx, f.eve, "t", []uuid.UUID{f.eve}); err != nil {
t.Fatal(err)
}
}
page, err := f.svc.List(f.ctx, f.alice, nil, 2)
if err != nil {
t.Fatal(err)
}
if len(page.Items) != 2 || page.Next == nil || *page.Next != mine[1] {
t.Fatalf("first page = %+v", page)
}
if len(page.Items[0].MemberIDs) != 2 {
t.Fatalf("listed chats must carry their members: %+v", page.Items[0])
}
rest, err := f.svc.List(f.ctx, f.alice, page.Next, 2)
if err != nil {
t.Fatal(err)
}
if len(rest.Items) != 1 || rest.Items[0].ID != mine[2] || rest.Next != nil {
t.Fatalf("second page = %+v", rest)
}
all, err := f.svc.List(f.ctx, f.bob, nil, 100)
if err != nil || len(all.Items) != 3 || all.Next != nil {
t.Fatalf("bob page = %+v, %v", all, err)
}
}
func TestSendChecksAccessBeforeValidation(t *testing.T) {
f := newFixture(t)
c, err := f.svc.Create(f.ctx, f.alice, "t", []uuid.UUID{f.alice, f.bob})
if err != nil {
t.Fatal(err)
}
_, err = f.svc.Send(f.ctx, f.eve, chat.MessagePayload{ChatID: c.ID, IdempotencyKey: "k1", Text: " "})
if !errors.Is(err, chat.ErrNotFound) {
t.Fatalf("outsider with blank text: err = %v, want ErrNotFound", err)
}
_, err = f.svc.Send(f.ctx, f.bob, chat.MessagePayload{ChatID: c.ID, IdempotencyKey: "k2", Text: " "})
if apperr.KindOf(err) != apperr.KindInvalid {
t.Fatalf("member with blank text: kind = %v, want KindInvalid", apperr.KindOf(err))
}
msg, err := f.svc.Send(f.ctx, f.bob, chat.MessagePayload{ChatID: c.ID, IdempotencyKey: "k3", Text: "Привет 👋"})
if err != nil || msg.SenderID != f.bob || msg.ChatID != c.ID || msg.Text != "Привет 👋" {
t.Fatalf("Send = %+v, %v", msg, err)
}
}
func TestHistoryPagesAndHidesForeignChat(t *testing.T) {
f := newFixture(t)
c, err := f.svc.Create(f.ctx, f.alice, "t", []uuid.UUID{f.alice, f.bob})
if err != nil {
t.Fatal(err)
}
first, _ := f.svc.Send(f.ctx, f.alice, chat.MessagePayload{ChatID: c.ID, IdempotencyKey: "k1", Text: "1"})
second, _ := f.svc.Send(f.ctx, f.bob, chat.MessagePayload{ChatID: c.ID, IdempotencyKey: "k2", Text: "2"})
page, err := f.svc.History(f.ctx, f.bob, c.ID, nil, 1)
if err != nil {
t.Fatal(err)
}
if len(page.Items) != 1 || !reflect.DeepEqual(page.Items[0], first) || page.Next == nil || *page.Next != first.ID {
t.Fatalf("first page = %+v", page)
}
rest, err := f.svc.History(f.ctx, f.alice, c.ID, page.Next, 1)
if err != nil {
t.Fatal(err)
}
if len(rest.Items) != 1 || !reflect.DeepEqual(rest.Items[0], second) || rest.Next != nil {
t.Fatalf("second page = %+v", rest)
}
if _, err := f.svc.History(f.ctx, f.eve, c.ID, nil, 10); !errors.Is(err, chat.ErrNotFound) {
t.Fatalf("outsider history: err = %v, want ErrNotFound", err)
}
empty, err := f.svc.History(f.ctx, f.alice, c.ID, &second.ID, 10)
if err != nil || empty.Items == nil || len(empty.Items) != 0 || empty.Next != nil {
t.Fatalf("page after last = %+v, %v; want empty non-nil items", empty, err)
}
}
func (f fixture) newChat(t *testing.T, members ...uuid.UUID) uuid.UUID {
t.Helper()
c, err := f.svc.Create(f.ctx, members[0], "t", members)
if err != nil {
t.Fatal(err)
}
return c.ID
}
func (f fixture) send(t *testing.T, actor, c uuid.UUID, key, text string) chat.Message {
t.Helper()
m, err := f.svc.Send(f.ctx, actor, chat.MessagePayload{ChatID: c, IdempotencyKey: key, Text: text})
if err != nil {
t.Fatal(err)
}
return m
}
func TestSendReplaysSameBody(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice, f.bob)
first := f.send(t, f.alice, c, "k", "привет")
again := f.send(t, f.alice, c, "k", "привет")
if again.ID != first.ID || !again.CreatedAt.Equal(first.CreatedAt) {
t.Fatalf("replay = %+v, want %+v", again, first)
}
}
func TestSendConflictsOnDifferentBody(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice, f.bob)
f.send(t, f.alice, c, "k", "первое")
_, err := f.svc.Send(f.ctx, f.alice, chat.MessagePayload{ChatID: c, IdempotencyKey: "k", Text: "другое"})
if !errors.Is(err, chat.ErrKeyReused) || apperr.KindOf(err) != apperr.KindConflict {
t.Fatalf("different body under a used key: err = %v, want ErrKeyReused (conflict)", err)
}
}
func TestKeysAreScopedByUserAndChat(t *testing.T) {
f := newFixture(t)
c1 := f.newChat(t, f.alice, f.bob)
c2 := f.newChat(t, f.alice, f.bob)
a1 := f.send(t, f.alice, c1, "k", "текст")
b1 := f.send(t, f.bob, c1, "k", "текст")
a2 := f.send(t, f.alice, c2, "k", "текст")
if a1.ID == b1.ID || a1.ID == a2.ID || b1.ID == a2.ID {
t.Fatalf("one key shared across users or chats: %v %v %v", a1.ID, b1.ID, a2.ID)
}
}
// A replay checks access again: an outsider presenting a member's key learns
// nothing and the key stays bound to the member's message.
func TestSendChecksAccessBeforeKey(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice, f.bob)
first := f.send(t, f.alice, c, "k", "секрет")
if _, err := f.svc.Send(f.ctx, f.eve, chat.MessagePayload{ChatID: c, IdempotencyKey: "k", Text: "секрет"}); !errors.Is(err, chat.ErrNotFound) {
t.Fatalf("outsider with a used key: err = %v, want ErrNotFound", err)
}
if again := f.send(t, f.alice, c, "k", "секрет"); again.ID != first.ID {
t.Fatalf("key rebound after the outsider: %v, want %v", again.ID, first.ID)
}
}
func TestInvalidTextWithUsedKeyIsInvalid(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice, f.bob)
f.send(t, f.alice, c, "k", "текст")
if _, err := f.svc.Send(f.ctx, f.alice, chat.MessagePayload{ChatID: c, IdempotencyKey: "k", Text: " "}); apperr.KindOf(err) != apperr.KindInvalid {
t.Fatalf("blank text under a used key: kind = %v, want KindInvalid", apperr.KindOf(err))
}
}
func TestPurgeExpiredKeysDeletesInBatches(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice, f.bob)
const expired = 2500
_, err := db.Pool.Exec(f.ctx, `
WITH m AS (
INSERT INTO messages (chat_id, id, sender_id, text, created_at)
SELECT $1, gen_random_uuid(), $2, 'old', now() FROM generate_series(1, $3)
RETURNING id)
INSERT INTO message_idempotency_keys (user_id, chat_id, key, message_id, created_at)
SELECT $2, $1, id::text, id, now() - interval '2 hours' FROM m`, c, f.alice, expired)
if err != nil {
t.Fatal(err)
}
f.send(t, f.alice, c, "fresh", "новое")
deleted, err := f.svc.PurgeExpiredKeys(f.ctx)
if err != nil || deleted != expired {
t.Fatalf("PurgeExpiredKeys = %d, %v; want %d", deleted, err, expired)
}
var left int
if err := db.Pool.QueryRow(f.ctx, `SELECT count(*) FROM message_idempotency_keys`).Scan(&left); err != nil || left != 1 {
t.Fatalf("%d keys left, %v; want the fresh one", left, err)
}
}
// A key the claim has just seen valid must survive until the replay lookup,
// so the cleanup leaves keys alone for a while after they expire.
func TestPurgeExpiredKeysWaitsAGraceAfterTTL(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice)
f.send(t, f.alice, c, "just-expired", "1")
f.send(t, f.alice, c, "long-expired", "2")
if _, err := db.Pool.Exec(f.ctx, `
UPDATE message_idempotency_keys
SET created_at = now() - interval '1 hour' - CASE key WHEN 'just-expired' THEN interval '10 seconds' ELSE interval '10 minutes' END`); err != nil {
t.Fatal(err)
}
if deleted, err := f.svc.PurgeExpiredKeys(f.ctx); err != nil || deleted != 1 {
t.Fatalf("PurgeExpiredKeys = %d, %v; want only the long expired key", deleted, err)
}
var left string
if err := db.Pool.QueryRow(f.ctx, `SELECT key FROM message_idempotency_keys`).Scan(&left); err != nil || left != "just-expired" {
t.Fatalf("left %q, %v; want just-expired", left, err)
}
}
func TestRunKeyCleanupPurgesAndStops(t *testing.T) {
f := newFixture(t)
c := f.newChat(t, f.alice)
f.send(t, f.alice, c, "old", "старое")
if _, err := db.Pool.Exec(f.ctx, `UPDATE message_idempotency_keys SET created_at = now() - interval '2 hours'`); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(f.ctx)
stopped := make(chan struct{})
go func() {
chat.RunKeyCleanup(ctx, slog.New(slog.NewTextHandler(io.Discard, nil)), f.svc, 50*time.Millisecond)
close(stopped)
}()
deadline := time.Now().Add(2 * time.Second)
for {
var left int
if err := db.Pool.QueryRow(f.ctx, `SELECT count(*) FROM message_idempotency_keys`).Scan(&left); err != nil {
t.Fatal(err)
}
if left == 0 {
break
}
if time.Now().After(deadline) {
t.Fatal("expired key was not purged within 2s")
}
time.Sleep(20 * time.Millisecond)
}
cancel()
select {
case <-stopped:
case <-time.After(time.Second):
t.Fatal("RunKeyCleanup did not return after cancel")
}
}