393 lines
13 KiB
Go
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")
|
|
}
|
|
}
|