Files
mtusi2026lab4/internal/storage/postgres/chat_repository_test.go
T
2026-10-15 20:45:29 +03:00

240 lines
5.6 KiB
Go

//go:build integration
package postgres_test
import (
"fmt"
"slices"
"sync"
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/suite"
"mtusi-messenger/internal/domain"
)
type ChatRepositorySuite struct {
BaseSuite
}
func TestChatRepositorySuite(t *testing.T) {
suite.Run(t, new(ChatRepositorySuite))
}
func (s *ChatRepositorySuite) TestCreateRejectsUnknownMemberAtomically() {
alice := s.createUser("alice")
_, err := s.store.Chats().Create(s.T().Context(), domain.ChatDraft{
Title: "С неизвестным участником",
MemberIDs: []uuid.UUID{alice.ID, uuid.New()},
CallerID: alice.ID,
})
s.Require().ErrorIs(err, domain.ErrUnknownMember)
var chats int
s.Require().NoError(s.pool.QueryRow(s.T().Context(), "SELECT count(*) FROM chats").Scan(&chats))
s.Zero(chats, "неуспешное создание чата не оставляет строк")
var members int
s.Require().NoError(s.pool.QueryRow(s.T().Context(), "SELECT count(*) FROM chat_members").Scan(&members))
s.Zero(members)
}
func (s *ChatRepositorySuite) TestCreateRejectsDuplicateMembers() {
alice := s.createUser("alice")
_, err := s.store.Chats().Create(s.T().Context(), domain.ChatDraft{
Title: "Дубликаты",
MemberIDs: []uuid.UUID{alice.ID, alice.ID},
CallerID: alice.ID,
})
s.Require().ErrorIs(err, domain.ErrConflict)
}
func (s *ChatRepositorySuite) TestCreateBumpsMemberListVersions() {
ctx := s.T().Context()
alice := s.createUser("alice")
bob := s.createUser("bob")
carol := s.createUser("carol")
s.createChat(alice, bob)
aliceVersion, err := s.store.Chats().ListVersion(ctx, alice.ID)
s.Require().NoError(err)
s.Equal(int64(1), aliceVersion, "creator version must be bumped")
bobVersion, err := s.store.Chats().ListVersion(ctx, bob.ID)
s.Require().NoError(err)
s.Equal(int64(1), bobVersion, "member version must be bumped")
carolVersion, err := s.store.Chats().ListVersion(ctx, carol.ID)
s.Require().NoError(err)
s.Zero(carolVersion, "non-member version must stay unchanged")
s.createChat(alice, carol)
aliceVersion, err = s.store.Chats().ListVersion(ctx, alice.ID)
s.Require().NoError(err)
s.Equal(int64(2), aliceVersion, "version must grow monotonically")
carolVersion, err = s.store.Chats().ListVersion(ctx, carol.ID)
s.Require().NoError(err)
s.Equal(int64(1), carolVersion)
}
func (s *ChatRepositorySuite) TestConcurrentCreateNoDeadlock() {
ctx := s.T().Context()
users := make([]domain.User, 0, 8)
for i := range 8 {
users = append(users, s.createUser(fmt.Sprintf("member%d", i)))
}
const workers = 16
var wg sync.WaitGroup
errs := make(chan error, workers)
wg.Add(workers)
for w := range workers {
go func(w int) {
defer wg.Done()
ids := []uuid.UUID{
users[w%len(users)].ID,
users[(w+1)%len(users)].ID,
users[(w+2)%len(users)].ID,
}
if w%2 == 1 {
slices.Reverse(ids)
}
_, err := s.store.Chats().Create(ctx, domain.ChatDraft{
Title: fmt.Sprintf("chat-%d", w),
MemberIDs: ids,
CallerID: ids[0],
})
if err != nil {
errs <- err
}
}(w)
}
wg.Wait()
close(errs)
for err := range errs {
s.Require().NoError(err)
}
}
func (s *ChatRepositorySuite) TestCreateStoresAllMembers() {
alice := s.createUser("alice")
bob := s.createUser("bob")
eve := s.createUser("eve")
chat := s.createChat(alice, bob, eve)
s.Equal(uuid.Version(7), chat.ID.Version())
s.False(chat.CreatedAt.IsZero())
visible, err := s.store.Chats().GetVisible(s.T().Context(), chat.ID, bob.ID)
s.Require().NoError(err)
s.ElementsMatch([]uuid.UUID{alice.ID, bob.ID, eve.ID}, visible.MemberIDs)
}
func (s *ChatRepositorySuite) TestVisibility() {
alice := s.createUser("alice")
bob := s.createUser("bob")
eve := s.createUser("eve")
chat := s.createChat(alice, bob)
visible, err := s.store.Chats().GetVisible(s.T().Context(), chat.ID, bob.ID)
s.Require().NoError(err)
s.Equal(chat.ID, visible.ID)
s.ElementsMatch([]uuid.UUID{alice.ID, bob.ID}, visible.MemberIDs)
_, err = s.store.Chats().GetVisible(s.T().Context(), chat.ID, eve.ID)
s.Require().ErrorIs(err, domain.ErrNotFound)
page, err := s.store.Chats().ListVisible(s.T().Context(), eve.ID, nil, 50)
s.Require().NoError(err)
s.Empty(page.Items)
page, err = s.store.Chats().ListVisible(s.T().Context(), alice.ID, nil, 50)
s.Require().NoError(err)
s.Require().Len(page.Items, 1)
s.ElementsMatch([]uuid.UUID{alice.ID, bob.ID}, page.Items[0].MemberIDs)
s.Nil(page.Next)
}
func (s *ChatRepositorySuite) TestListPagination() {
alice := s.createUser("alice")
const total = 5
for range total {
s.createChat(alice)
}
seen := make(map[uuid.UUID]struct{}, total)
var cursor *domain.Cursor
for {
page, err := s.store.Chats().ListVisible(s.T().Context(), alice.ID, cursor, 2)
s.Require().NoError(err)
s.Require().NotEmpty(page.Items)
for _, chat := range page.Items {
_, duplicate := seen[chat.ID]
s.Require().False(duplicate)
seen[chat.ID] = struct{}{}
}
if page.Next == nil {
break
}
cursor = page.Next
}
s.Len(seen, total)
}
func (s *ChatRepositorySuite) TestListPaginationWithSharedTimestamp() {
alice := s.createUser("alice")
for range 5 {
s.createChat(alice)
}
_, err := s.pool.Exec(s.T().Context(), "UPDATE chats SET created_at = '2026-01-01 00:00:00+00'")
s.Require().NoError(err)
seen := make(map[uuid.UUID]struct{}, 5)
var cursor *domain.Cursor
for {
page, err := s.store.Chats().ListVisible(s.T().Context(), alice.ID, cursor, 2)
s.Require().NoError(err)
for _, chat := range page.Items {
_, duplicate := seen[chat.ID]
s.Require().False(duplicate)
seen[chat.ID] = struct{}{}
}
if page.Next == nil {
break
}
cursor = page.Next
}
s.Len(seen, 5)
}