forked from mtusi2026/mtusi2026lab4
184 lines
4.4 KiB
Go
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, "одно", nil, "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, "другое", nil, "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")
|
|
}
|
|
}
|