Files
mtusi2026lab2/internal/platform/postgres/postgres_test.go
T

182 lines
5.5 KiB
Go

package postgres_test
import (
"context"
"errors"
"fmt"
"io"
"net"
"os"
"testing"
"github.com/jackc/pgx/v5/pgconn"
"messenger/internal/platform/apperr"
"messenger/internal/platform/postgres"
"messenger/internal/testenv"
)
var db *testenv.DB
func TestMain(m *testing.M) {
var err error
db, err = testenv.StartPostgres(context.Background())
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
code := m.Run()
db.Close()
os.Exit(code)
}
func TestMigrateIsRepeatable(t *testing.T) {
ctx := context.Background()
applied, err := postgres.Migrate(ctx, db.Pool)
if err != nil {
t.Fatalf("second migrate: %v", err)
}
if len(applied) != 0 {
t.Fatalf("second migrate applied %v, want nothing", applied)
}
var version int64
if err := db.Pool.QueryRow(ctx, `SELECT max(version_id) FROM goose_db_version`).Scan(&version); err != nil {
t.Fatal(err)
}
if version != 1 {
t.Fatalf("schema version = %d, want 1", version)
}
for _, table := range []string{"users", "chats", "chat_members", "messages"} {
var exists bool
if err := db.Pool.QueryRow(ctx, `SELECT to_regclass('public.' || $1) IS NOT NULL`, table).Scan(&exists); err != nil {
t.Fatal(err)
}
if !exists {
t.Fatalf("table %s is missing", table)
}
}
}
func TestPoolAppliesLimitsAndTimeouts(t *testing.T) {
if got := db.Pool.Config().MaxConns; got != 10 {
t.Fatalf("MaxConns = %d, want 10", got)
}
ctx := context.Background()
for setting, want := range map[string]string{
"statement_timeout": "5s",
"idle_in_transaction_session_timeout": "10s",
} {
var got string
if err := db.Pool.QueryRow(ctx, "SHOW "+setting).Scan(&got); err != nil {
t.Fatal(err)
}
if got != want {
t.Fatalf("%s = %q, want %q", setting, got, want)
}
}
}
func TestResetEmptiesEveryTableButKeepsSchemaVersion(t *testing.T) {
ctx := context.Background()
_, err := db.Pool.Exec(ctx, `
WITH u AS (
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('0190f1d2-0000-7000-8000-000000000001', 'reset_check', 'Reset', 'x', now())
RETURNING id
), c AS (
INSERT INTO chats (id, title, created_at)
VALUES ('0190f1d2-0000-7000-8000-000000000002', 'Reset', now())
RETURNING id
), m AS (
INSERT INTO chat_members (chat_id, user_id) SELECT c.id, u.id FROM c, u
)
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT '0190f1d2-0000-7000-8000-000000000003', c.id, u.id, 'hi', now() FROM c, u`)
if err != nil {
t.Fatal(err)
}
db.Reset(t)
for _, table := range []string{"users", "chats", "chat_members", "messages"} {
var n int
if err := db.Pool.QueryRow(ctx, "SELECT count(*) FROM "+table).Scan(&n); err != nil {
t.Fatal(err)
}
if n != 0 {
t.Fatalf("%s has %d rows after Reset", table, n)
}
}
var versions int
if err := db.Pool.QueryRow(ctx, `SELECT count(*) FROM goose_db_version`).Scan(&versions); err != nil {
t.Fatal(err)
}
if versions == 0 {
t.Fatal("Reset wiped the schema version table")
}
}
func TestIsUniqueViolation(t *testing.T) {
db.Reset(t)
ctx := context.Background()
insert := `INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, 'taken', 'Taken', 'x', now())`
if _, err := db.Pool.Exec(ctx, insert, "0190f1d2-0000-7000-8000-000000000011"); err != nil {
t.Fatal(err)
}
_, dup := db.Pool.Exec(ctx, insert, "0190f1d2-0000-7000-8000-000000000012")
if dup == nil {
t.Fatal("duplicate username was accepted")
}
if !postgres.IsUniqueViolation(dup, "users_username_key") {
t.Fatalf("not recognised as a username violation: %v", dup)
}
if postgres.IsUniqueViolation(dup, "some_other_key") {
t.Fatal("matched a different constraint")
}
if postgres.IsUniqueViolation(fmt.Errorf("wrapped: %w", dup), "users_username_key") == false {
t.Fatal("wrapped error not recognised")
}
if postgres.IsUniqueViolation(errors.New("plain"), "users_username_key") || postgres.IsUniqueViolation(nil, "users_username_key") {
t.Fatal("non-database error recognised as a violation")
}
}
func TestClassifyMarksUnreachableDatabaseAsUnavailable(t *testing.T) {
unavailable := map[string]error{
"admin shutdown": &pgconn.PgError{Code: "57P01"},
"statement timeout": &pgconn.PgError{Code: "57014"},
"connection failure": &pgconn.PgError{Code: "08006"},
"too many connections": &pgconn.PgError{Code: "53300"},
"deadline": fmt.Errorf("query: %w", context.DeadlineExceeded),
"network": &net.OpError{Op: "read", Net: "tcp", Err: errors.New("connection reset")},
"unexpected eof": fmt.Errorf("read: %w", io.ErrUnexpectedEOF),
}
for name, err := range unavailable {
got := postgres.Classify(err)
if apperr.KindOf(got) != apperr.KindUnavailable || !errors.Is(got, err) {
t.Errorf("%s: Classify = %v (kind %v), want KindUnavailable keeping the cause", name, got, apperr.KindOf(got))
}
}
for name, err := range map[string]error{
"unique violation": &pgconn.PgError{Code: "23505"},
"plain": errors.New("boom"),
"nil": nil,
} {
if got := postgres.Classify(err); got != err {
t.Errorf("%s: Classify = %v, want the error unchanged", name, got)
}
}
}
func TestClassifyRealConnectFailure(t *testing.T) {
_, err := postgres.NewPool(context.Background(), "postgres://u:p@127.0.0.1:1/db?connect_timeout=1")
if err == nil {
t.Fatal("NewPool to a closed port must fail")
}
if apperr.KindOf(postgres.Classify(err)) != apperr.KindUnavailable {
t.Fatalf("connect failure classified as %v: %v", apperr.KindOf(postgres.Classify(err)), err)
}
}