Files
mtusi2026lab5/internal/storage/postgres/message_repository_test.go
T
2026-10-29 23:36:12 +03:00

162 lines
3.9 KiB
Go

//go:build integration
package postgres_test
import (
"crypto/sha256"
"fmt"
"sync"
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/suite"
"mtusi-messenger/internal/domain"
)
type MessageRepositorySuite struct {
BaseSuite
}
func TestMessageRepositorySuite(t *testing.T) {
suite.Run(t, new(MessageRepositorySuite))
}
// draft builds a message draft with a fresh Idempotency-Key (lab3 contract).
func (s *MessageRepositorySuite) draft(chatID, senderID uuid.UUID, text string) domain.MessageDraft {
s.T().Helper()
key := uuid.NewString()
return domain.MessageDraft{
ChatID: chatID,
SenderID: senderID,
Text: text,
Idempotency: domain.MessageIdempotency{
Key: key,
RequestHash: sha256.Sum256([]byte(key + text)),
},
}
}
func (s *MessageRepositorySuite) TestCreateAndPagination() {
alice := s.createUser("alice")
bob := s.createUser("bob")
chat := s.createChat(alice, bob)
const total = 5
for i := range total {
message, err := s.store.Messages().Create(s.T().Context(), s.draft(chat.ID, alice.ID, fmt.Sprintf("сообщение %d", i)))
s.Require().NoError(err)
s.Equal(uuid.Version(7), message.ID.Version())
s.False(message.CreatedAt.IsZero())
}
seen := make(map[uuid.UUID]struct{}, total)
var cursor *domain.Cursor
for {
page, err := s.store.Messages().ListVisible(s.T().Context(), chat.ID, alice.ID, cursor, 2)
s.Require().NoError(err)
s.Require().NotEmpty(page.Items)
for _, message := range page.Items {
_, duplicate := seen[message.ID]
s.Require().False(duplicate, "keyset-пагинация не повторяет сообщения")
seen[message.ID] = struct{}{}
}
if page.Next == nil {
break
}
cursor = page.Next
}
s.Len(seen, total)
}
func (s *MessageRepositorySuite) TestPaginationWithSharedTimestamp() {
alice := s.createUser("alice")
chat := s.createChat(alice)
for range 5 {
_, err := s.store.Messages().Create(s.T().Context(), s.draft(chat.ID, alice.ID, "same timestamp"))
s.Require().NoError(err)
}
_, err := s.pool.Exec(s.T().Context(), "UPDATE messages 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.Messages().ListVisible(s.T().Context(), chat.ID, alice.ID, cursor, 2)
s.Require().NoError(err)
for _, message := range page.Items {
_, duplicate := seen[message.ID]
s.Require().False(duplicate)
seen[message.ID] = struct{}{}
}
if page.Next == nil {
break
}
cursor = page.Next
}
s.Len(seen, 5)
}
func (s *MessageRepositorySuite) TestAccessIsRestricted() {
alice := s.createUser("alice")
bob := s.createUser("bob")
chat := s.createChat(alice)
_, err := s.store.Messages().Create(s.T().Context(), s.draft(chat.ID, bob.ID, "чужое"))
s.Require().ErrorIs(err, domain.ErrNotFound, "не участник не может писать в чат")
_, err = s.store.Messages().ListVisible(s.T().Context(), chat.ID, bob.ID, nil, 50)
s.Require().ErrorIs(err, domain.ErrNotFound, "не участник не может читать историю")
}
func (s *MessageRepositorySuite) TestListingForMissingChatReturnsNotFound() {
alice := s.createUser("alice")
_, err := s.store.Messages().ListVisible(s.T().Context(), uuid.New(), alice.ID, nil, 50)
s.Require().ErrorIs(err, domain.ErrNotFound)
}
func (s *MessageRepositorySuite) TestFinishedMessageSurvivesConcurrentReads() {
alice := s.createUser("alice")
chat := s.createChat(alice)
const total = 20
var wg sync.WaitGroup
wg.Go(func() {
for i := range total {
_, err := s.store.Messages().Create(s.T().Context(), s.draft(chat.ID, alice.ID, fmt.Sprintf("message %d", i)))
if err != nil {
return
}
}
})
for range total {
page, err := s.store.Messages().ListVisible(s.T().Context(), chat.ID, alice.ID, nil, 100)
s.Require().NoError(err)
s.LessOrEqual(len(page.Items), total)
}
wg.Wait()
}