Files
mtusi2026lab3/internal/store/postgres_test.go
T
iDizZ d065cffb4e Добавить две реплики API за HAProxy и проверку отказа одной из них.
Общие сессии и ключ идемпотентности позволяют продолжать чтение и запись, когда одна реплика остановлена.
2026-11-06 17:31:40 +03:00

184 lines
4.4 KiB
Go

package store
import (
"context"
"errors"
"os"
"sync"
"testing"
"time"
"messenger/internal/migrate"
)
func openIntegration(t *testing.T) *PG {
t.Helper()
raw := os.Getenv("DATABASE_URL")
if raw == "" {
t.Skip("DATABASE_URL is not set")
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
pg, err := Open(ctx, raw, 10)
if err != nil {
t.Fatal(err)
}
t.Cleanup(pg.Close)
if err := migrate.Apply(ctx, pg.Pool()); err != nil {
t.Fatal(err)
}
return pg
}
func TestIntegrationMigrationRerunKeepsRows(t *testing.T) {
pg := openIntegration(t)
ctx := context.Background()
name := "mig_" + newID()[:8]
if _, err := pg.CreateUser(ctx, name, "Миграция", "hash"); err != nil {
t.Fatal(err)
}
var before int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&before); err != nil {
t.Fatal(err)
}
if err := migrate.Apply(ctx, pg.Pool()); err != nil {
t.Fatal(err)
}
var after int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&after); err != nil {
t.Fatal(err)
}
if before != after {
t.Fatalf("migration rerun changed users %d -> %d", before, after)
}
}
func TestIntegrationUsernameRace(t *testing.T) {
pg := openIntegration(t)
ctx := context.Background()
name := "race_" + newID()[:8]
const n = 32
var wg sync.WaitGroup
wins := make(chan struct{}, n)
fails := make(chan error, n)
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
defer wg.Done()
_, err := pg.CreateUser(ctx, name, "Гонка", "hash")
if err == nil {
wins <- struct{}{}
return
}
fails <- err
}()
}
wg.Wait()
close(wins)
close(fails)
got := 0
for range wins {
got++
}
if got != 1 {
t.Fatalf("winners = %d, want 1", got)
}
for err := range fails {
if !errors.Is(err, ErrConflict) {
t.Fatal(err)
}
}
}
func TestIntegrationChatRollback(t *testing.T) {
pg := openIntegration(t)
ctx := context.Background()
u, err := pg.CreateUser(ctx, "rb_"+newID()[:8], "Откат", "hash")
if err != nil {
t.Fatal(err)
}
var before int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before); err != nil {
t.Fatal(err)
}
_, err = pg.CreateChat(ctx, "не должен сохраниться", []string{u.ID, "99999999-9999-4999-8999-999999999999"}, u.ID)
if !errors.Is(err, ErrInvalid) {
t.Fatalf("want invalid, got %v", err)
}
var after int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after); err != nil {
t.Fatal(err)
}
if before != after {
t.Fatalf("rolled-back chat stayed: %d -> %d", before, after)
}
var members int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE user_id = $1`, u.ID).Scan(&members); err != nil {
t.Fatal(err)
}
if members != 0 {
t.Fatalf("rolled-back membership stayed: %d", members)
}
}
func TestIntegrationIdempotencyRace(t *testing.T) {
pg := openIntegration(t)
ctx := context.Background()
u, err := pg.CreateUser(ctx, "idm_"+newID()[:8], "Ключ", "hash")
if err != nil {
t.Fatal(err)
}
chat, err := pg.CreateChat(ctx, "идемпотентность", []string{u.ID}, u.ID)
if err != nil {
t.Fatal(err)
}
const n = 16
var wg sync.WaitGroup
ids := make(chan string, n)
errs := make(chan error, n)
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
defer wg.Done()
msg, err := pg.AddMessage(ctx, chat.ID, u.ID, "одно", "key-1", "одно")
if err != nil {
errs <- err
return
}
ids <- msg.ID
}()
}
wg.Wait()
close(ids)
close(errs)
for err := range errs {
t.Fatal(err)
}
seen := map[string]struct{}{}
for id := range ids {
seen[id] = struct{}{}
}
if len(seen) != 1 {
t.Fatalf("concurrent key created %d messages", len(seen))
}
if _, err := pg.AddMessage(ctx, chat.ID, u.ID, "другое", "key-1", "другое"); !errors.Is(err, ErrIdempotencyMismatch) {
t.Fatalf("mismatch: %v", err)
}
var count int
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM messages WHERE chat_id = $1`, chat.ID).Scan(&count); err != nil {
t.Fatal(err)
}
if count != 1 {
t.Fatalf("messages = %d, want 1", count)
}
}
func TestPostgresUnreachable(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
_, err := Open(ctx, "postgres://messenger:secret@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1", 1)
if err == nil {
t.Fatal("closed port was accepted")
}
}