209 lines
6.3 KiB
Go
209 lines
6.3 KiB
Go
package postgres_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"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 TestPoolScansTimestamptzInUTC(t *testing.T) {
|
|
var got time.Time
|
|
if err := db.Pool.QueryRow(context.Background(), `SELECT now()`).Scan(&got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got.Location() != time.UTC {
|
|
t.Fatalf("timestamptz scanned in %v, want UTC", got.Location())
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
if got := db.Pool.Config().ConnConfig.ConnectTimeout; got != time.Second {
|
|
t.Fatalf("ConnectTimeout = %v, want 1s", 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
// The pool size is an experiment variable of the scaling study, so it is
|
|
// passed in rather than fixed.
|
|
func TestNewPoolUsesTheRequestedSize(t *testing.T) {
|
|
pool, err := postgres.NewPool(context.Background(), db.DSN, 3)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer pool.Close()
|
|
if got := pool.Config().MaxConns; got != 3 {
|
|
t.Fatalf("MaxConns = %d, want 3", got)
|
|
}
|
|
}
|
|
|
|
func TestClassifyRealConnectFailure(t *testing.T) {
|
|
_, err := postgres.NewPool(context.Background(), "postgres://u:p@127.0.0.1:1/db?connect_timeout=1", 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)
|
|
}
|
|
}
|