test.go

package database

import (
	"context"
	"database/sql"
	"os"
	"testing"

	"github.com/golang-migrate/migrate/v4/source"
	"github.com/jmoiron/sqlx"
)

var (
	dbtablenames []string
)

const dbLockID = 15104

func clearDB(t *testing.T, dsn string) {
	// Drop all tables, and reinit
	db, err := Open(dsn, 0)
	if err != nil {
		t.Fatal(err)
	}
	defer db.Close()
	if _, err := db.Exec("DROP SCHEMA IF EXISTS public CASCADE"); err != nil {
		t.Fatal(err)
	}
	if _, err := db.Exec("CREATE SCHEMA public"); err != nil {
		t.Fatal(err)
	}
}

// TestDB is a sqlx.DB wrapper that release a global lock on close
type TestDB struct {
	*sqlx.DB
	tb       testing.TB
	lockConn *sql.Conn
}

// GetTestDB creates a db and returns it. It must be closed within the test.
// If it fails, t.Fatal() is called
func GetTestDB(t *testing.T, sourceDriver source.Driver) *TestDB {
	dsn := os.Getenv("TEST_DB_DSN")
	if dsn == "" {
		t.Fatal("Please define a TEST_DB_DSN environment variable")
	}
	if len(dbtablenames) == 0 {
		clearDB(t, dsn)

		m, err := NewMigrate(dsn, sourceDriver)
		if err != nil {
			t.Fatal(err)
		}
		if err := m.Up(); err != nil {
			t.Fatal(err)
		}
		if srcErr, dbErr := m.Close(); srcErr != nil || dbErr != nil {
			t.Fatal(srcErr, dbErr)
		}
	}
	db, err := Open(dsn, 0)
	if err != nil {
		t.Fatal(err)
	}
	if len(dbtablenames) == 0 {
		if err := db.Select(&dbtablenames,
			"SELECT tablename "+
				"FROM pg_catalog.pg_tables "+
				"WHERE schemaname = 'public'",
		); err != nil {
			t.Fatal(err)
		}
	} else {
		for _, name := range dbtablenames {
			if _, err := db.Exec(
				"ALTER TABLE " + name + " DISABLE TRIGGER ALL",
			); err != nil {
				t.Fatal(err)
				return nil
			}
		}
		for _, name := range dbtablenames {
			if _, err := db.Exec(
				"DELETE FROM " + name, //nolint:gosec
			); err != nil {
				t.Fatal(err)
				return nil
			}
		}
		for _, name := range dbtablenames {
			if _, err := db.Exec(
				"ALTER TABLE " + name + " ENABLE TRIGGER ALL",
			); err != nil {
				t.Fatal(err)
				return nil
			}
		}
	}

	c, err := db.Conn(context.Background())

	if err != nil {
		_ = db.Close()
		t.Fatal(err)
	}

	if _, err := c.ExecContext(
		context.Background(),
		"SELECT pg_advisory_lock($1)", dbLockID,
	); err != nil {
		_ = db.Close()
		t.Fatal(err)
	}

	return &TestDB{db, t, c}
}

// Close the lock connection, then the database
func (db *TestDB) Close() error {
	if err := db.lockConn.Close(); err != nil {
		db.tb.Error("lockConn.Close() failed", err)
	}

	return db.DB.Close()
}