322 lines
8.5 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|