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) } }