forked from mtusi2026/mtusi2026lab3
140 lines
4.6 KiB
Go
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)
|
|
}
|
|
}
|