Files
mtusi2026lab4/internal/postgres/store_integration_test.go
2026-10-02 17:49:28 +03:00

311 lines
9.4 KiB
Go

package postgres_test
import (
"context"
"errors"
"os"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/stretchr/testify/suite"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/database"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model"
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/postgres"
)
type PostgresSuite struct {
suite.Suite
pool *pgxpool.Pool
store *postgres.Store
}
func TestPostgresSuite(t *testing.T) {
suite.Run(t, new(PostgresSuite))
}
func (s *PostgresSuite) SetupSuite() {
s.pool = openTestDatabase(s.T())
s.store = postgres.New(s.pool)
}
func (s *PostgresSuite) TearDownSuite() {
if s.pool != nil {
s.pool.Close()
}
}
func (s *PostgresSuite) TestConcurrentUsernameCreation() {
t := s.T()
store := s.store
username := "race_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16]
const workers = 8
results := make(chan error, workers)
var group sync.WaitGroup
for range workers {
group.Add(1)
go func() {
defer group.Done()
_, err := store.CreateUser(context.Background(), username, "Race user", "password-hash")
results <- err
}()
}
group.Wait()
close(results)
var created, conflicts int
for err := range results {
switch {
case err == nil:
created++
case errors.Is(err, postgres.ErrConflict):
conflicts++
default:
t.Fatalf("CreateUser() error = %v", err)
}
}
if created != 1 || conflicts != workers-1 {
t.Fatalf("created = %d, conflicts = %d", created, conflicts)
}
}
func (s *PostgresSuite) TestCreateChatRollsBackForUnknownMember() {
t := s.T()
pool := s.pool
store := s.store
owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash")
if err != nil {
t.Fatalf("CreateUser() error = %v", err)
}
before := chatCount(t, pool)
_, err = store.CreateChat(context.Background(), "Invalid chat", []string{owner.ID, uuid.NewString()}, owner.ID)
if !errors.Is(err, postgres.ErrInvalidMembers) {
t.Fatalf("CreateChat() error = %v, want ErrInvalidMembers", err)
}
if after := chatCount(t, pool); after != before {
t.Fatalf("chat count changed from %d to %d", before, after)
}
}
func (s *PostgresSuite) TestMessageIdempotencyReplayAndConflict() {
t := s.T()
pool := s.pool
store := s.store
owner, chatID := createOwnerAndChat(t, store)
key := uuid.NewString()
first, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour)
if err != nil || replay {
t.Fatalf("first CreateMessage() = (%v, %t, %v)", first, replay, err)
}
second, replay, err := store.CreateMessage(context.Background(), chatID, owner.ID, "same body", key, 24*time.Hour)
if err != nil || !replay {
t.Fatalf("replay CreateMessage() = (%v, %t, %v)", second, replay, err)
}
if first != second {
t.Fatalf("replay message = %v, want %v", second, first)
}
if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "different body", key, 24*time.Hour); !errors.Is(err, postgres.ErrIdempotencyConflict) {
t.Fatalf("conflicting CreateMessage() error = %v, want ErrIdempotencyConflict", err)
}
if count := messageCount(t, pool, chatID); count != 1 {
t.Fatalf("message count = %d, want 1", count)
}
}
func (s *PostgresSuite) TestConcurrentMessageIdempotency() {
t := s.T()
pool := s.pool
stores := []*postgres.Store{postgres.New(pool), postgres.New(pool)}
owner, chatID := createOwnerAndChat(t, stores[0])
key := uuid.NewString()
const workers = 8
type result struct {
message model.Message
replay bool
err error
}
results := make(chan result, workers)
var group sync.WaitGroup
for worker := range workers {
group.Add(1)
go func() {
defer group.Done()
message, replay, err := stores[worker%len(stores)].CreateMessage(
context.Background(), chatID, owner.ID, "concurrent body", key, 24*time.Hour,
)
results <- result{message: message, replay: replay, err: err}
}()
}
group.Wait()
close(results)
var messageID string
var created int
for result := range results {
if result.err != nil {
t.Fatalf("CreateMessage() error = %v", result.err)
}
if messageID == "" {
messageID = result.message.ID
}
if result.message.ID != messageID {
t.Fatalf("message ID = %s, want %s", result.message.ID, messageID)
}
if !result.replay {
created++
}
}
if created != 1 {
t.Fatalf("new message results = %d, want 1", created)
}
if count := messageCount(t, pool, chatID); count != 1 {
t.Fatalf("message count = %d, want 1", count)
}
}
func (s *PostgresSuite) TestMessageIdempotencyScopeAndExpiry() {
t := s.T()
pool := s.pool
store := s.store
owner, chatID := createOwnerAndChat(t, store)
second, err := store.CreateUser(context.Background(), uniqueUsername(), "Second", "password-hash")
if err != nil {
t.Fatalf("CreateUser() error = %v", err)
}
chat, err := store.CreateChat(context.Background(), "Shared", []string{owner.ID, second.ID}, owner.ID)
if err != nil {
t.Fatalf("CreateChat() error = %v", err)
}
key := uuid.NewString()
if _, _, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "owner", key, 24*time.Hour); err != nil {
t.Fatalf("owner CreateMessage() error = %v", err)
}
if _, _, err := store.CreateMessage(context.Background(), chat.ID, second.ID, "second", key, 24*time.Hour); err != nil {
t.Fatalf("second user CreateMessage() error = %v", err)
}
if _, _, err := store.CreateMessage(context.Background(), chatID, owner.ID, "other chat", key, 24*time.Hour); err != nil {
t.Fatalf("other chat CreateMessage() error = %v", err)
}
if _, err := pool.Exec(context.Background(), `
UPDATE message_idempotency
SET created_at = clock_timestamp() - INTERVAL '2 days',
expires_at = clock_timestamp() - INTERVAL '1 day'
WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chat.ID, key); err != nil {
t.Fatalf("expire idempotency key: %v", err)
}
message, replay, err := store.CreateMessage(context.Background(), chat.ID, owner.ID, "after expiry", key, 24*time.Hour)
if err != nil || replay || message.Text != "after expiry" {
t.Fatalf("expired CreateMessage() = (%v, %t, %v)", message, replay, err)
}
}
func (s *PostgresSuite) TestExpiredIdempotencyRecordsAreCleanedOnNewMessages() {
t := s.T()
owner, chatID := createOwnerAndChat(t, s.store)
expiredKey := uuid.NewString()
if _, _, err := s.store.CreateMessage(context.Background(), chatID, owner.ID, "expired", expiredKey, 24*time.Hour); err != nil {
t.Fatalf("create expired message: %v", err)
}
if _, err := s.pool.Exec(context.Background(), `
UPDATE message_idempotency
SET created_at = clock_timestamp() - INTERVAL '2 days',
expires_at = clock_timestamp() - INTERVAL '1 day'
WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey); err != nil {
t.Fatalf("expire idempotency key: %v", err)
}
if _, _, err := s.store.CreateMessage(
context.Background(), chatID, owner.ID, "new message", uuid.NewString(), 24*time.Hour,
); err != nil {
t.Fatalf("create new message: %v", err)
}
var remaining int
if err := s.pool.QueryRow(context.Background(), `
SELECT count(*)
FROM message_idempotency
WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey).Scan(&remaining); err != nil {
t.Fatalf("count expired idempotency records: %v", err)
}
if remaining != 0 {
t.Fatalf("expired idempotency records = %d, want 0", remaining)
}
}
func createOwnerAndChat(t *testing.T, store *postgres.Store) (model.User, string) {
t.Helper()
owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash")
if err != nil {
t.Fatalf("CreateUser() error = %v", err)
}
chat, err := store.CreateChat(context.Background(), "Chat", []string{owner.ID}, owner.ID)
if err != nil {
t.Fatalf("CreateChat() error = %v", err)
}
return owner, chat.ID
}
func messageCount(t *testing.T, pool *pgxpool.Pool, chatID string) int {
t.Helper()
var count int
if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM messages WHERE chat_id = $1", chatID).Scan(&count); err != nil {
t.Fatalf("count messages: %v", err)
}
return count
}
func openTestDatabase(t *testing.T) *pgxpool.Pool {
t.Helper()
url := testSecret(t, "TEST_DATABASE_URL", "TEST_DATABASE_URL_FILE")
pool, err := database.Open(context.Background(), database.Config{
URL: url, MinConnections: 0, MaxConnections: 10,
MaxConnectionAge: time.Minute, MaxConnectionIdle: time.Minute,
HealthCheckPeriod: time.Minute, ConnectTimeout: 5 * time.Second,
})
if err != nil {
t.Fatalf("database.Open() error = %v", err)
}
if err := database.Migrate(context.Background(), pool, 30*time.Second); err != nil {
pool.Close()
t.Fatalf("database.Migrate() error = %v", err)
}
return pool
}
func testSecret(t *testing.T, valueName, fileName string) string {
t.Helper()
if value := strings.TrimSpace(os.Getenv(valueName)); value != "" {
return value
}
path := strings.TrimSpace(os.Getenv(fileName))
if path == "" {
t.Skipf("set %s or %s to run integration tests", valueName, fileName)
}
data, err := os.ReadFile(path)
if err != nil {
t.Fatalf("read %s: %v", fileName, err)
}
return strings.TrimSpace(string(data))
}
func uniqueUsername() string {
return "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:20]
}
func chatCount(t *testing.T, pool *pgxpool.Pool) int {
t.Helper()
var count int
if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM chats").Scan(&count); err != nil {
t.Fatalf("count chats: %v", err)
}
return count
}