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) } } }