Files

140 lines
4.6 KiB
Go

package postgres
import (
"errors"
"sync"
"testing"
"github.com/google/uuid"
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab3/internal/model/dto"
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab3/internal/store"
)
// TestMessageRetryRace verifies concurrent attempts commit exactly one message and replay its response.
func TestMessageRetryRace(t *testing.T) {
s := testStore(t)
user := fixtureUser(t, s)
chat := fixtureChat(t, s, user)
var wg sync.WaitGroup
outcomes := make(chan dto.MessageDTO, 12)
failures := make(chan error, 12)
for range 12 {
wg.Go(func() {
message, err := s.CreateMessage(t.Context(), dto.MessageDTO{ID: uuid.New(), ChatID: chat.ID, SenderID: user.ID, Text: "same", IdempotencyKey: "retry"})
if err != nil {
failures <- err
return
}
outcomes <- message
})
}
wg.Wait()
close(failures)
close(outcomes)
for err := range failures {
t.Error(err)
}
var original dto.MessageDTO
for m := range outcomes {
if original.ID == uuid.Nil {
original = m
}
if m.ID != original.ID || m.Text != original.Text || !m.CreatedAt.Equal(original.CreatedAt) {
t.Fatal("retry returned a different result")
}
}
messages, err := s.Messages(t.Context(), chat.ID, dto.PositionDTO{}, 100)
if err != nil || len(messages) != 1 {
t.Fatalf("messages=%d error=%v", len(messages), err)
}
}
// TestMessageRetryConflict rejects a different body without publishing a second message.
func TestMessageRetryConflict(t *testing.T) {
s := testStore(t)
user := fixtureUser(t, s)
chat := fixtureChat(t, s, user)
message := dto.MessageDTO{ID: uuid.New(), ChatID: chat.ID, SenderID: user.ID, Text: "first", IdempotencyKey: "retry"}
if _, err := s.CreateMessage(t.Context(), message); err != nil {
t.Fatal(err)
}
message.ID = uuid.New()
message.Text = "different"
if _, err := s.CreateMessage(t.Context(), message); !errors.Is(err, store.ErrConflict) {
t.Fatalf("expected conflict: %v", err)
}
}
// TestMessageRetryExpiry permits reuse after the original retention window ends.
func TestMessageRetryExpiry(t *testing.T) {
s := testStore(t)
user := fixtureUser(t, s)
chat := fixtureChat(t, s, user)
message := dto.MessageDTO{ID: uuid.New(), ChatID: chat.ID, SenderID: user.ID, Text: "first", IdempotencyKey: "retry"}
if _, err := s.CreateMessage(t.Context(), message); err != nil {
t.Fatal(err)
}
if _, err := s.pool.Exec(t.Context(), "UPDATE message_idempotency SET expires_at=clock_timestamp()-interval '1 second'"); err != nil {
t.Fatal(err)
}
message.ID = uuid.New()
message.Text = "new"
if result, err := s.CreateMessage(t.Context(), message); err != nil || result.ID != message.ID {
t.Fatalf("expired result reused: %v", err)
}
}
// TestMessageRetryRollback proves failed inserts leave no poisoned idempotency result.
func TestMessageRetryRollback(t *testing.T) {
s := testStore(t)
user := fixtureUser(t, s)
chat := fixtureChat(t, s, user)
message := dto.MessageDTO{ID: uuid.New(), ChatID: chat.ID, SenderID: uuid.New(), Text: "first", IdempotencyKey: "retry"}
if _, err := s.CreateMessage(t.Context(), message); err == nil {
t.Fatal("missing sender accepted")
}
var count int
if err := s.pool.QueryRow(t.Context(), "SELECT count(*) FROM message_idempotency").Scan(&count); err != nil || count != 0 {
t.Fatalf("failed write stored a result: %d %v", count, err)
}
message.SenderID = user.ID
if _, err := s.CreateMessage(t.Context(), message); err != nil {
t.Fatal(err)
}
}
// TestSchemaCheck verifies API schema checks neither create nor upgrade tables.
func TestSchemaCheck(t *testing.T) {
s := testStore(t)
if err := s.CheckSchema(t.Context()); err != nil {
t.Fatal(err)
}
if _, err := s.pool.Exec(t.Context(), "DELETE FROM schema_migrations WHERE version=2"); err != nil {
t.Fatal(err)
}
if err := s.CheckSchema(t.Context()); err == nil {
t.Fatal("outdated schema accepted")
}
s.Close()
if err := s.CheckSchema(t.Context()); err == nil {
t.Fatal("closed connection accepted")
}
}
// TestIdempotencyMigrationFailureRollsBackVersion keeps an unsuccessful DDL change out of migration history.
func TestIdempotencyMigrationFailureRollsBackVersion(t *testing.T) {
s := testStore(t)
if _, err := s.pool.Exec(t.Context(), "DELETE FROM schema_migrations WHERE version=2"); err != nil {
t.Fatal(err)
}
// The existing table deliberately conflicts with the pending migration.
if err := s.Start(t.Context()); err == nil {
t.Fatal("conflicting DDL reported success")
}
var applied bool
if err := s.pool.QueryRow(t.Context(), "SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version=2)").Scan(&applied); err != nil || applied {
t.Fatalf("failed migration marked applied: %v", err)
}
}