Files
mtusi2026lab5/internal/chat/store/postgres_test.go
T

322 lines
8.5 KiB
Go

package store_test
import (
"bytes"
"context"
"errors"
"fmt"
"os"
"reflect"
"sync"
"testing"
"time"
"github.com/google/uuid"
"messenger/internal/chat"
"messenger/internal/chat/store"
"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)
}
type fixture struct {
ctx context.Context
chats *store.Chats
messages *store.Messages
}
func newFixture(t *testing.T) fixture {
t.Helper()
db.Reset(t)
return fixture{ctx: context.Background(), chats: store.NewChats(db.Pool), messages: store.NewMessages(db.Pool)}
}
// mustUser stores a user row: chats and messages reference users by FK.
func (f fixture) mustUser(t *testing.T) uuid.UUID {
t.Helper()
id := ident.New()
u, err := user.New(id, "u"+id.String()[24:], "User")
if err != nil {
t.Fatal(err)
}
u.PasswordHash = "x"
if err := userstore.NewUsers(db.Pool).Create(f.ctx, u); err != nil {
t.Fatal(err)
}
return id
}
func (f fixture) mustChat(t *testing.T, members ...uuid.UUID) chat.Chat {
t.Helper()
c, err := chat.NewChat(ident.New(), "title")
if err != nil {
t.Fatal(err)
}
if err := f.chats.Create(f.ctx, c, members); err != nil {
t.Fatal(err)
}
return c
}
func (f fixture) newMessage(t *testing.T, chatID, sender uuid.UUID) chat.Message {
t.Helper()
m, err := chat.NewMessage(ident.New(), chatID, sender, "text")
if err != nil {
t.Fatal(err)
}
return m
}
// appendErr stores m under a key of its own, as every send now carries one.
func (f fixture) appendErr(m chat.Message) error {
_, err := f.messages.AppendOnce(f.ctx, m, m.ID.String(), time.Hour)
return err
}
func TestChatCreateThenGetForMember(t *testing.T) {
f := newFixture(t)
alice, bob := f.mustUser(t), f.mustUser(t)
c := f.mustChat(t, alice, bob)
got, err := f.chats.GetForMember(f.ctx, c.ID, bob)
if err != nil {
t.Fatal(err)
}
if got.Chat != c || len(got.MemberIDs) != 2 || got.MemberIDs[0] != alice || got.MemberIDs[1] != bob {
t.Fatalf("GetForMember = %+v, want %+v with members [alice bob]", got, c)
}
if _, err := f.chats.GetForMember(f.ctx, c.ID, f.mustUser(t)); !errors.Is(err, chat.ErrNotFound) {
t.Fatalf("outsider must get ErrNotFound, got %v", err)
}
for who, want := range map[uuid.UUID]bool{alice: true, bob: true, ident.New(): false} {
ok, err := f.chats.IsMember(f.ctx, c.ID, who)
if err != nil || ok != want {
t.Fatalf("IsMember(%s) = %v, %v; want %v", who, ok, err, want)
}
}
}
// The chat row and its members are written in one transaction: a failing
// member insert must leave no chat behind.
func TestCreateRollsBackWhenMemberInsertFails(t *testing.T) {
f := newFixture(t)
alice := f.mustUser(t)
c, err := chat.NewChat(ident.New(), "half-made")
if err != nil {
t.Fatal(err)
}
if err := f.chats.Create(f.ctx, c, []uuid.UUID{alice, ident.New()}); err == nil {
t.Fatal("Create with an unknown member must fail")
}
var chats, members int
if err := db.Pool.QueryRow(f.ctx, `SELECT (SELECT count(*) FROM chats), (SELECT count(*) FROM chat_members)`).Scan(&chats, &members); err != nil {
t.Fatal(err)
}
if chats != 0 || members != 0 {
t.Fatalf("chats = %d, members = %d after a failed create; want 0 and 0", chats, members)
}
}
func TestChatUnknownID(t *testing.T) {
f := newFixture(t)
if _, err := f.chats.GetForMember(f.ctx, ident.New(), ident.New()); !errors.Is(err, chat.ErrNotFound) {
t.Fatalf("GetForMember err = %v, want ErrNotFound", err)
}
if ok, err := f.chats.IsMember(f.ctx, ident.New(), ident.New()); err != nil || ok {
t.Fatalf("IsMember on unknown chat = %v, %v; want false, nil", ok, err)
}
}
func TestListByMemberFiltersOrdersAndPages(t *testing.T) {
f := newFixture(t)
alice, bob := f.mustUser(t), f.mustUser(t)
var mine []chat.Chat
for range 5 {
c, err := chat.NewChat(ident.New(), "title")
if err != nil {
t.Fatal(err)
}
mine = append(mine, c)
// A chat without alice must never show up in her listing.
f.mustChat(t, bob)
}
// Insert the oldest chat last to prove the store sorts, not appends.
for _, c := range append(mine[1:], mine[0]) {
if err := f.chats.Create(f.ctx, c, []uuid.UUID{alice, bob}); err != nil {
t.Fatal(err)
}
}
page, err := f.chats.ListByMember(f.ctx, alice, nil, 3)
if err != nil {
t.Fatal(err)
}
if len(page) != 3 || page[0].ID != mine[0].ID || page[2].ID != mine[2].ID {
t.Fatalf("first page mismatch: %v", page)
}
if len(page[0].MemberIDs) != 2 || page[0].MemberIDs[0] != alice {
t.Fatalf("listing must carry members in id order: %+v", page[0])
}
last := page[2].ID
rest, err := f.chats.ListByMember(f.ctx, alice, &last, 10)
if err != nil {
t.Fatal(err)
}
if len(rest) != 2 || rest[0].ID != mine[3].ID || rest[1].ID != mine[4].ID {
t.Fatalf("second page mismatch: %v", rest)
}
none, err := f.chats.ListByMember(f.ctx, ident.New(), nil, 10)
if err != nil {
t.Fatal(err)
}
if none == nil || len(none) != 0 {
t.Fatalf("unknown member must get an empty non-nil slice, got %#v", none)
}
}
func TestListByChatUnknownChatIsEmpty(t *testing.T) {
f := newFixture(t)
got, err := f.messages.ListByChat(f.ctx, ident.New(), nil, 10)
if err != nil {
t.Fatal(err)
}
if got == nil || len(got) != 0 {
t.Fatalf("want empty non-nil slice, got %#v", got)
}
}
func TestAppendOutOfOrderIsListedByID(t *testing.T) {
f := newFixture(t)
alice := f.mustUser(t)
c := f.mustChat(t, alice)
first, second, third := f.newMessage(t, c.ID, alice), f.newMessage(t, c.ID, alice), f.newMessage(t, c.ID, alice)
for _, m := range []chat.Message{third, first, second} {
if err := f.appendErr(m); err != nil {
t.Fatal(err)
}
}
got, err := f.messages.ListByChat(f.ctx, c.ID, nil, 10)
if err != nil {
t.Fatal(err)
}
if len(got) != 3 || !reflect.DeepEqual(got[0], first) || !reflect.DeepEqual(got[1], second) || !reflect.DeepEqual(got[2], third) {
t.Fatalf("history must be ordered by id and round-trip every field, got %+v", got)
}
}
func TestPagingWalksWholeHistoryWithoutGapsOrDuplicates(t *testing.T) {
f := newFixture(t)
alice := f.mustUser(t)
c := f.mustChat(t, alice)
const total = 250
var expected []uuid.UUID
for range total {
m := f.newMessage(t, c.ID, alice)
expected = append(expected, m.ID)
if err := f.appendErr(m); err != nil {
t.Fatal(err)
}
}
// Another chat's history must not leak into this one.
other := f.mustChat(t, alice)
if err := f.appendErr(f.newMessage(t, other.ID, alice)); err != nil {
t.Fatal(err)
}
for _, limit := range []int{1, 7, 100} {
var seen []uuid.UUID
var after *uuid.UUID
for {
page, err := f.messages.ListByChat(f.ctx, c.ID, after, limit)
if err != nil {
t.Fatal(err)
}
if len(page) == 0 {
break
}
if len(page) > limit {
t.Fatalf("limit %d: page has %d items", limit, len(page))
}
for _, m := range page {
seen = append(seen, m.ID)
}
last := page[len(page)-1].ID
after = &last
}
if len(seen) != total {
t.Fatalf("limit %d: walked %d messages, want %d", limit, len(seen), total)
}
for i := range seen {
if seen[i] != expected[i] {
t.Fatalf("limit %d: position %d has %s, want %s", limit, i, seen[i], expected[i])
}
}
}
}
func TestAfterUnknownIDStartsAtNextGreater(t *testing.T) {
f := newFixture(t)
alice := f.mustUser(t)
c := f.mustChat(t, alice)
a := f.newMessage(t, c.ID, alice)
gap := ident.New() // never stored, but sorts between a and b
b := f.newMessage(t, c.ID, alice)
for _, m := range []chat.Message{a, b} {
if err := f.appendErr(m); err != nil {
t.Fatal(err)
}
}
got, err := f.messages.ListByChat(f.ctx, c.ID, &gap, 10)
if err != nil {
t.Fatal(err)
}
if len(got) != 1 || got[0].ID != b.ID {
t.Fatalf("want only b after the gap id, got %v", got)
}
}
func TestConcurrentAppendsKeepEveryMessage(t *testing.T) {
f := newFixture(t)
alice := f.mustUser(t)
c := f.mustChat(t, alice)
const clients, perClient = 10, 10
var wg sync.WaitGroup
for range clients {
wg.Go(func() {
for range perClient {
if err := f.appendErr(f.newMessage(t, c.ID, alice)); err != nil {
t.Error(err)
}
}
})
}
wg.Wait()
got, err := f.messages.ListByChat(f.ctx, c.ID, nil, clients*perClient+1)
if err != nil {
t.Fatal(err)
}
if len(got) != clients*perClient {
t.Fatalf("stored %d messages, want %d", len(got), clients*perClient)
}
for i := 1; i < len(got); i++ {
if bytes.Compare(got[i-1].ID[:], got[i].ID[:]) >= 0 {
t.Fatalf("history out of order at %d", i)
}
}
}