182 lines
5.1 KiB
Go
182 lines
5.1 KiB
Go
// Package testenv starts disposable PostgreSQL and Valkey containers for tests
|
|
// that exercise the real stores. Only _test files import it, so it never
|
|
// reaches the server binary. The images match compose.yaml.
|
|
package testenv
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"runtime"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"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"
|
|
tcvalkey "github.com/testcontainers/testcontainers-go/modules/valkey"
|
|
|
|
"messenger/internal/platform/postgres"
|
|
"messenger/internal/platform/valkey"
|
|
)
|
|
|
|
const (
|
|
PostgresImage = "postgres:18.6-alpine3.24@sha256:77f585114c32fbca283dc835b0596f4e52b51b4c6662d7810b2f4084f60a1873"
|
|
ValkeyImage = "valkey/valkey:9.1.2-alpine3.24@sha256:48332870af354a799964c0012ae1194a0bf2bf894eb508f945810596dc2d8d11"
|
|
)
|
|
|
|
// useDockerDesktopPipe names the Docker Desktop engine pipe explicitly on
|
|
// Windows. Without DOCKER_HOST, testcontainers probes the pipe with a file
|
|
// stat, which fails while the pipe is busy; with several test packages
|
|
// starting containers at once that probe fails spuriously and the run panics.
|
|
// Dialling the named host instead waits for a free pipe instance.
|
|
var useDockerDesktopPipe = sync.OnceFunc(func() {
|
|
if runtime.GOOS == "windows" && os.Getenv("DOCKER_HOST") == "" {
|
|
_ = os.Setenv("DOCKER_HOST", "npipe:////./pipe/docker_engine")
|
|
}
|
|
})
|
|
|
|
// DB is a migrated PostgreSQL instance.
|
|
type DB struct {
|
|
Pool *pgxpool.Pool
|
|
DSN string
|
|
container *tcpostgres.PostgresContainer
|
|
}
|
|
|
|
func StartPostgres(ctx context.Context) (*DB, error) {
|
|
useDockerDesktopPipe()
|
|
c, err := tcpostgres.Run(ctx, PostgresImage,
|
|
tcpostgres.WithDatabase("messenger"),
|
|
tcpostgres.WithUsername("messenger"),
|
|
tcpostgres.WithPassword("messenger"),
|
|
tcpostgres.BasicWaitStrategies(),
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("start postgres: %w", err)
|
|
}
|
|
db := &DB{container: c}
|
|
db.DSN, err = c.ConnectionString(ctx, "sslmode=disable")
|
|
if err != nil {
|
|
db.Close()
|
|
return nil, fmt.Errorf("postgres address: %w", err)
|
|
}
|
|
db.Pool, err = postgres.NewPool(ctx, db.DSN, 10)
|
|
if err != nil {
|
|
db.Close()
|
|
return nil, err
|
|
}
|
|
if _, err := postgres.Migrate(ctx, db.Pool); err != nil {
|
|
db.Close()
|
|
return nil, err
|
|
}
|
|
return db, nil
|
|
}
|
|
|
|
// Reset empties every application table, so each test starts from an empty
|
|
// schema. The table list comes from the catalog: a table added by a later
|
|
// migration cannot be forgotten here.
|
|
func (d *DB) Reset(t testing.TB) {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
var tables string
|
|
err := d.Pool.QueryRow(ctx, `
|
|
SELECT coalesce(string_agg(format('%I.%I', schemaname, tablename), ', '), '')
|
|
FROM pg_tables
|
|
WHERE schemaname = 'public' AND tablename <> 'goose_db_version'`).Scan(&tables)
|
|
if err != nil {
|
|
t.Fatalf("list tables: %v", err)
|
|
}
|
|
if tables == "" {
|
|
return
|
|
}
|
|
if _, err := d.Pool.Exec(ctx, "TRUNCATE "+tables+" CASCADE"); err != nil {
|
|
t.Fatalf("truncate: %v", err)
|
|
}
|
|
}
|
|
|
|
// Stop stops the container, as when the database goes down.
|
|
func (d *DB) Stop(ctx context.Context) error {
|
|
timeout := 5 * time.Second
|
|
return d.container.Stop(ctx, &timeout)
|
|
}
|
|
|
|
// Pause freezes the server: connections stay open but nothing answers, as
|
|
// with a hung database.
|
|
func (d *DB) Pause(ctx context.Context) error {
|
|
return withDocker(ctx, func(cli *testcontainers.DockerClient) error {
|
|
return cli.ContainerPause(ctx, d.container.GetContainerID())
|
|
})
|
|
}
|
|
|
|
func (d *DB) Unpause(ctx context.Context) error {
|
|
return withDocker(ctx, func(cli *testcontainers.DockerClient) error {
|
|
return cli.ContainerUnpause(ctx, d.container.GetContainerID())
|
|
})
|
|
}
|
|
|
|
func withDocker(ctx context.Context, fn func(cli *testcontainers.DockerClient) error) error {
|
|
cli, err := testcontainers.NewDockerClientWithOpts(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer cli.Close()
|
|
return fn(cli)
|
|
}
|
|
|
|
func (d *DB) Close() {
|
|
if d.Pool != nil {
|
|
d.Pool.Close()
|
|
}
|
|
_ = testcontainers.TerminateContainer(d.container)
|
|
}
|
|
|
|
// KV is a Valkey instance without persistence or password.
|
|
type KV struct {
|
|
Client *redis.Client
|
|
URL string
|
|
container *tcvalkey.ValkeyContainer
|
|
}
|
|
|
|
func StartValkey(ctx context.Context) (*KV, error) {
|
|
useDockerDesktopPipe()
|
|
c, err := tcvalkey.Run(ctx, ValkeyImage)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("start valkey: %w", err)
|
|
}
|
|
kv := &KV{container: c}
|
|
kv.URL, err = c.ConnectionString(ctx)
|
|
if err != nil {
|
|
kv.Close()
|
|
return nil, fmt.Errorf("valkey address: %w", err)
|
|
}
|
|
// The production client, so outage tests see its fail-fast settings.
|
|
kv.Client, err = valkey.NewClient(ctx, kv.URL)
|
|
if err != nil {
|
|
kv.Close()
|
|
return nil, err
|
|
}
|
|
return kv, nil
|
|
}
|
|
|
|
func (k *KV) Reset(t testing.TB) {
|
|
t.Helper()
|
|
if err := k.Client.FlushDB(context.Background()).Err(); err != nil {
|
|
t.Fatalf("flushdb: %v", err)
|
|
}
|
|
}
|
|
|
|
// Stop stops the container, as when the session store goes down.
|
|
func (k *KV) Stop(ctx context.Context) error {
|
|
timeout := 5 * time.Second
|
|
return k.container.Stop(ctx, &timeout)
|
|
}
|
|
|
|
func (k *KV) Close() {
|
|
if k.Client != nil {
|
|
_ = k.Client.Close()
|
|
}
|
|
_ = testcontainers.TerminateContainer(k.container)
|
|
}
|