Files
mtusi2026lab2/internal/httpapi/testmain_test.go
T
2026-10-08 22:06:38 +03:00

146 lines
3.9 KiB
Go

package httpapi
import (
"context"
"fmt"
"log"
"net/url"
"os"
"path/filepath"
"testing"
"time"
"github.com/golang-migrate/migrate/v4"
_ "github.com/golang-migrate/migrate/v4/database/pgx/v5"
_ "github.com/golang-migrate/migrate/v4/source/file"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
"github.com/testcontainers/testcontainers-go"
tcpostgres "github.com/testcontainers/testcontainers-go/modules/postgres"
tcredis "github.com/testcontainers/testcontainers-go/modules/redis"
"github.com/testcontainers/testcontainers-go/wait"
)
var testPool *pgxpool.Pool
var testRedis *redis.Client
// поднимает эфемерный Postgres в Docker применяет миграции даёт testPool
// всем тестам пакета и гарантированно убивает контейнер в конце прогона :)
func TestMain(m *testing.M) {
ctx := context.Background()
pgContainer, err := tcpostgres.Run(ctx,
"postgres:16.4-alpine",
tcpostgres.WithDatabase("messenger_test"),
tcpostgres.WithUsername("messenger_test"),
tcpostgres.WithPassword("messenger_test"),
testcontainers.WithWaitStrategy(
wait.ForLog("database system is ready to accept connections").
WithOccurrence(2).
WithStartupTimeout(30*time.Second),
),
)
if err != nil {
log.Fatalf("start postgres container: %v", err)
}
defer func() {
if err := pgContainer.Terminate(ctx); err != nil {
log.Printf("terminate postgres container: %v", err)
}
}()
dsn, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
if err != nil {
log.Fatalf("get connection string: %v", err)
}
if err := applyMigrations(dsn); err != nil {
log.Fatalf("apply migrations: %v", err)
}
poolCfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
log.Fatalf("parse pool config: %v", err)
}
testPool, err = pgxpool.NewWithConfig(ctx, poolCfg)
if err != nil {
log.Fatalf("create pool: %v", err)
}
defer testPool.Close()
if err := testPool.Ping(ctx); err != nil {
log.Fatalf("ping test db: %v", err)
}
redisContainer, err := tcredis.Run(ctx, "redis:7.4-alpine")
if err != nil {
log.Fatalf("start redis container: %v", err)
}
defer func() {
if err := testcontainers.TerminateContainer(redisContainer); err != nil {
log.Printf("terminate redis container: %v", err)
}
}()
redisURL, err := redisContainer.ConnectionString(ctx)
if err != nil {
log.Fatalf("get redis connection string: %v", err)
}
redisOpts, err := redis.ParseURL(redisURL)
if err != nil {
log.Fatalf("parse redis url: %v", err)
}
testRedis = redis.NewClient(redisOpts)
defer testRedis.Close()
if err := testRedis.Ping(ctx).Err(); err != nil {
log.Fatalf("ping test redis: %v", err)
}
os.Exit(m.Run())
}
// тесты запускаются из internal/httpapi/ поэтому путь на три уровня вверх
// и прогоняет все .up.sql через golang-migrate
func applyMigrations(dsn string) error {
migrationsPath, err := filepath.Abs(filepath.Join("..", "..", "migrations"))
if err != nil {
return err
}
u, err := url.Parse(dsn)
if err != nil {
return fmt.Errorf("parse dsn: %w", err)
}
u.Scheme = "pgx5"
m, err := migrate.New(
fmt.Sprintf("file://%s", migrationsPath),
u.String(),
)
if err != nil {
return fmt.Errorf("migrate.New: %w", err)
}
defer m.Close()
if err := m.Up(); err != nil && err != migrate.ErrNoChange {
return fmt.Errorf("migrate.Up: %w", err)
}
return nil
}
// truncateAll очищает все таблицы между тестами сохраняя схему
// быстрее чем пересоздавать контейнер на каждый тест
func truncateAll(t *testing.T) {
t.Helper()
ctx := context.Background()
_, err := testPool.Exec(ctx,
`TRUNCATE TABLE messages, chat_members, chats, sessions, users RESTART IDENTITY CASCADE`,
)
if err != nil {
t.Fatalf("truncate tables: %v", err)
}
}