Add example of tests with isolated schema

testingpg/testingpg.go

@@ -17,6 +17,7 @@ import (
 	"time"
 	"unicode"
 
+	_ "github.com/golang-migrate/migrate/v4/source/file"
 	_ "github.com/jackc/pgx/v5/stdlib"
 	"github.com/stretchr/testify/require"
 )
@@ -37,6 +38,10 @@ func NewWithIsolatedDatabase(t TestingT) *Postgres {
 	return newPostgres(t, defaultPostgresURL).cloneFromReference()
 }
 
+func NewWithIsolatedSchema(t TestingT) *Postgres {
+	return newPostgres(t, defaultPostgresURL).createSchema(t)
+}
+
 func NewWithTransactionalCleanup(t TestingT) interface {
 	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
 	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
@@ -108,6 +113,40 @@ func (p *Postgres) DB() *sql.DB {
 	return p.sqlDB
 }
 
+func (p *Postgres) createSchema(t TestingT) *Postgres {
+	schemaName := newUniqueHumanReadableDatabaseName(p.t)
+
+	// Unclear why, but if the scheme contains letters of different case, the
+	// tests stop working. At the moment I don't quite understand why this
+	// happens, but converting to lower case fixes the problem.
+	schemaName = strings.ToLower(schemaName)
+
+	ctx, done := context.WithCancel(context.Background())
+	t.Cleanup(done)
+
+	{
+		sql := fmt.Sprintf(`CREATE SCHEMA "%s";`, schemaName)
+
+		_, err := p.DB().ExecContext(ctx, sql)
+		require.NoError(t, err)
+	}
+
+	t.Cleanup(func() {
+		sql := fmt.Sprintf(`DROP SCHEMA "%s" CASCADE;`, schemaName)
+
+		_, err := p.DB().ExecContext(ctx, sql)
+		require.NoError(t, err)
+	})
+
+	pgurl := setSearchPath(t, p.URL(), schemaName)
+
+	return &Postgres{
+		t:   p.t,
+		ref: p.ref,
+		url: pgurl.String(),
+	}
+}
+
 func (p *Postgres) cloneFromReference() *Postgres {
 	newDBName := newUniqueHumanReadableDatabaseName(p.t)
 
@@ -220,3 +259,14 @@ func open(t TestingT, dataSourceURL string) *sql.DB {
 
 	return db
 }
+
+func setSearchPath(t TestingT, pgURL string, schemaName string) *url.URL {
+	pgurl, err := url.Parse(pgURL)
+	require.NoError(t, err)
+
+	query := pgurl.Query()
+	query.Set("search_path", schemaName)
+	pgurl.RawQuery = query.Encode()
+
+	return pgurl
+}

testingpg/testingpg_test.go

@@ -94,6 +94,86 @@ func TestNewPostgres(t *testing.T) {
 	})
 }
 
+func TestNewWithIsolatedSchema(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+
+	t.Parallel()
+
+	t.Run("Successfully connect by URL and get version", func(t *testing.T) {
+		t.Parallel()
+
+		// Arrange
+		postgres := testingpg.NewWithIsolatedSchema(t)
+
+		ctx := context.Background()
+		dbPool, err := pgxpool.New(ctx, postgres.URL())
+		require.NoError(t, err)
+
+		// Act
+		var version string
+		err = dbPool.QueryRow(ctx, "SHOW search_path;").Scan(&version)
+
+		// Assert
+		require.NoError(t, err)
+		require.NotEmpty(t, version)
+		t.Log(version)
+	})
+
+	t.Run("Successfully obtained a version using a pre-configured conn", func(t *testing.T) {
+		t.Parallel()
+
+		// Arrange
+		postgres := testingpg.NewWithIsolatedSchema(t)
+		ctx := context.Background()
+
+		// Act
+		var version string
+		err := postgres.DB().QueryRowContext(ctx, "SHOW search_path;").Scan(&version)
+
+		// Assert
+		require.NoError(t, err)
+		require.NotEmpty(t, version)
+
+		t.Log(version)
+	})
+
+	t.Run("Changes are not visible in different instances", func(t *testing.T) {
+		t.Parallel()
+
+		// Arrange
+		postgres1 := testingpg.NewWithIsolatedSchema(t)
+		postgres2 := testingpg.NewWithIsolatedSchema(t)
+
+		ctx := context.Background()
+
+		// Act
+		const sqlStr = `CREATE TABLE "no_conflict" (id integer PRIMARY KEY)`
+		_, err1 := postgres1.DB().ExecContext(ctx, sqlStr)
+		_, err2 := postgres2.DB().ExecContext(ctx, sqlStr)
+
+		// Assert
+		require.NoError(t, err1)
+		require.NoError(t, err2, "databases must be isolated for each instance")
+	})
+
+	t.Run("URL is different at different instances", func(t *testing.T) {
+		t.Parallel()
+
+		// Arrange
+		postgres1 := testingpg.NewWithIsolatedSchema(t)
+		postgres2 := testingpg.NewWithIsolatedSchema(t)
+
+		// Act
+		url1 := postgres1.URL()
+		url2 := postgres2.URL()
+
+		// Assert
+		require.NotEqual(t, url1, url2)
+	})
+}
+
 func TestNewWithTransactionalCleanup(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping test in short mode")