testdb: Rename functions to avoid stuttering

The functions `testdb.NewDB()` and `testdb.GetDBConfig()` both stutter.
Rename them to `testdb.New()` and `testdb.GetConfig()`, respectively.

42 files changed, 119 insertions, 119 deletions

diff --git a/cmd/praefect/main_test.go b/cmd/praefect/main_test.go
index 82a7e0ee0..9f789bf24 100644
--- a/cmd/praefect/main_test.go
+++ b/cmd/praefect/main_test.go
@@ -190,8 +190,8 @@ func (m *mockRegisterer) Gather() ([]*dto.MetricFamily, error) {
 func TestExcludeDatabaseMetricsFromDefaultMetrics(t *testing.T) {
 	t.Parallel()
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	conf := config.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
diff --git a/cmd/praefect/subcmd_accept_dataloss_test.go b/cmd/praefect/subcmd_accept_dataloss_test.go
index 348cb6c27..8ebc3927a 100644
--- a/cmd/praefect/subcmd_accept_dataloss_test.go
+++ b/cmd/praefect/subcmd_accept_dataloss_test.go
@@ -35,7 +35,7 @@ func TestAcceptDatalossSubcommand(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := datastore.NewPostgresRepositoryStore(db, conf.StorageNames())
 	startingGenerations := map[string]int{st1: 1, st2: 0, st3: datastore.GenerationUnknown}
 
diff --git a/cmd/praefect/subcmd_dataloss_test.go b/cmd/praefect/subcmd_dataloss_test.go
index 0e73e829f..b46bef8dd 100644
--- a/cmd/praefect/subcmd_dataloss_test.go
+++ b/cmd/praefect/subcmd_dataloss_test.go
@@ -41,7 +41,7 @@ func TestDatalossSubcommand(t *testing.T) {
 		},
 	}
 
-	tx := testdb.NewDB(t).Begin(t)
+	tx := testdb.New(t).Begin(t)
 	defer tx.Rollback(t)
 
 	ctx, cancel := testhelper.Context()
diff --git a/cmd/praefect/subcmd_list_untracked_repositories_test.go b/cmd/praefect/subcmd_list_untracked_repositories_test.go
index 9a714c388..c54ecd9ea 100644
--- a/cmd/praefect/subcmd_list_untracked_repositories_test.go
+++ b/cmd/praefect/subcmd_list_untracked_repositories_test.go
@@ -64,10 +64,10 @@ func TestListUntrackedRepositories_Exec(t *testing.T) {
 	g1Addr := testserver.RunGitalyServer(t, g1Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 	g2Addr := testserver.RunGitalyServer(t, g2Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	var database string
 	require.NoError(t, db.QueryRow(`SELECT current_database()`).Scan(&database))
-	dbConf := testdb.GetDBConfig(t, database)
+	dbConf := testdb.GetConfig(t, database)
 
 	conf := config.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
diff --git a/cmd/praefect/subcmd_metadata_test.go b/cmd/praefect/subcmd_metadata_test.go
index 24c859fe2..3432457cf 100644
--- a/cmd/praefect/subcmd_metadata_test.go
+++ b/cmd/praefect/subcmd_metadata_test.go
@@ -22,7 +22,7 @@ func TestMetadataSubcommand(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	tx := testdb.NewDB(t).Begin(t)
+	tx := testdb.New(t).Begin(t)
 	defer tx.Rollback(t)
 
 	testdb.SetHealthyNodes(t, ctx, tx, map[string]map[string][]string{
diff --git a/cmd/praefect/subcmd_remove_repository_test.go b/cmd/praefect/subcmd_remove_repository_test.go
index 30c77a92c..a1a4f6cbc 100644
--- a/cmd/praefect/subcmd_remove_repository_test.go
+++ b/cmd/praefect/subcmd_remove_repository_test.go
@@ -75,8 +75,8 @@ func TestRemoveRepository_Exec(t *testing.T) {
 	g1Addr := testserver.RunGitalyServer(t, g1Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 	g2Srv := testserver.StartGitalyServer(t, g2Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	conf := config.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
@@ -259,7 +259,7 @@ func TestRemoveRepository_removeReplicationEvents(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	queue := datastore.NewPostgresReplicationEventQueue(db)
 
diff --git a/cmd/praefect/subcmd_set_replication_factor_test.go b/cmd/praefect/subcmd_set_replication_factor_test.go
index b26daeeb0..03c469844 100644
--- a/cmd/praefect/subcmd_set_replication_factor_test.go
+++ b/cmd/praefect/subcmd_set_replication_factor_test.go
@@ -17,7 +17,7 @@ import (
 
 func TestSetReplicationFactorSubcommand(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc   string
diff --git a/cmd/praefect/subcmd_track_repository_test.go b/cmd/praefect/subcmd_track_repository_test.go
index dd1e6fe43..e1e08a3c3 100644
--- a/cmd/praefect/subcmd_track_repository_test.go
+++ b/cmd/praefect/subcmd_track_repository_test.go
@@ -86,8 +86,8 @@ func TestAddRepository_Exec(t *testing.T) {
 
 	g1Addr := g1Srv.Address()
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	virtualStorageName := "praefect"
 	conf := config.Config{
diff --git a/internal/backup/backup_test.go b/internal/backup/backup_test.go
index b1e602edb..65abe05f8 100644
--- a/internal/backup/backup_test.go
+++ b/internal/backup/backup_test.go
@@ -285,8 +285,8 @@ func TestManager_Restore_praefect(t *testing.T) {
 
 	gitalyAddr := testserver.RunGitalyServer(t, gitalyCfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	conf := praefectConfig.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
diff --git a/internal/praefect/auth_test.go b/internal/praefect/auth_test.go
index 71b21f7b3..4dfd6ad8a 100644
--- a/internal/praefect/auth_test.go
+++ b/internal/praefect/auth_test.go
@@ -149,7 +149,7 @@ func runServer(t *testing.T, token string, required bool) (*grpc.Server, string,
 		},
 	}
 	logEntry := testhelper.NewDiscardingLogEntry(t)
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 
 	nodeMgr, err := nodes.NewManager(logEntry, conf, nil, nil, promtest.NewMockHistogramVec(), protoregistry.GitalyProtoPreregistered, nil, nil, nil)
 	require.NoError(t, err)
diff --git a/internal/praefect/checks_test.go b/internal/praefect/checks_test.go
index aa7aa7a3a..c259db08d 100644
--- a/internal/praefect/checks_test.go
+++ b/internal/praefect/checks_test.go
@@ -71,8 +71,8 @@ func TestPraefectMigrations_success(t *testing.T) {
 			defer cancel()
 
 			var cfg config.Config
-			db := testdb.NewDB(t)
-			cfg.DB = testdb.GetDBConfig(t, db.Name)
+			db := testdb.New(t)
+			cfg.DB = testdb.GetConfig(t, db.Name)
 
 			require.NoError(t, tc.prepare(cfg))
 
@@ -364,7 +364,7 @@ func TestPostgresReadWriteCheck(t *testing.T) {
 		{
 			desc: "read and write work",
 			setup: func(t *testing.T, db testdb.DB) config.DB {
-				return testdb.GetDBConfig(t, db.Name)
+				return testdb.GetConfig(t, db.Name)
 			},
 			expectedLog: "successfully read from database\nsuccessfully wrote to database\n",
 		},
@@ -385,7 +385,7 @@ func TestPostgresReadWriteCheck(t *testing.T) {
 					require.NoError(t, err)
 				})
 
-				dbCfg := testdb.GetDBConfig(t, db.Name)
+				dbCfg := testdb.GetConfig(t, db.Name)
 				dbCfg.User = role
 				dbCfg.Password = ""
 
@@ -401,7 +401,7 @@ func TestPostgresReadWriteCheck(t *testing.T) {
 			ctx, cancel := testhelper.Context()
 			defer cancel()
 
-			db := testdb.NewDB(t)
+			db := testdb.New(t)
 			t.Cleanup(func() { require.NoError(t, db.Close()) })
 
 			dbConf := tc.setup(t, db)
@@ -474,8 +474,8 @@ func TestNewUnavailableReposCheck(t *testing.T) {
 			ctx, cancel := testhelper.Context()
 			defer cancel()
 
-			db := testdb.NewDB(t)
-			dbCfg := testdb.GetDBConfig(t, db.Name)
+			db := testdb.New(t)
+			dbCfg := testdb.GetConfig(t, db.Name)
 			conf.DB = dbCfg
 
 			rs := datastore.NewPostgresRepositoryStore(db, nil)
diff --git a/internal/praefect/coordinator_pg_test.go b/internal/praefect/coordinator_pg_test.go
index d8acd2ed4..ee7a5e6ab 100644
--- a/internal/praefect/coordinator_pg_test.go
+++ b/internal/praefect/coordinator_pg_test.go
@@ -153,7 +153,7 @@ func TestStreamDirectorMutator_Transaction(t *testing.T) {
 		},
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range testcases {
 		t.Run(tc.desc, func(t *testing.T) {
diff --git a/internal/praefect/coordinator_test.go b/internal/praefect/coordinator_test.go
index 89482e432..31b913c60 100644
--- a/internal/praefect/coordinator_test.go
+++ b/internal/praefect/coordinator_test.go
@@ -64,7 +64,7 @@ func TestSecondaryRotation(t *testing.T) {
 
 func TestStreamDirectorReadOnlyEnforcement(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		desc     string
 		readOnly bool
@@ -156,7 +156,7 @@ func TestStreamDirectorMutator(t *testing.T) {
 			},
 		},
 	}
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	targetRepo := gitalypb.Repository{
 		StorageName:  "praefect",
@@ -333,7 +333,7 @@ func TestStreamDirectorMutator_StopTransaction(t *testing.T) {
 	txMgr := transactions.NewManager(conf)
 
 	coordinator := NewCoordinator(
-		datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)),
+		datastore.NewPostgresReplicationEventQueue(testdb.New(t)),
 		rs,
 		NewNodeManagerRouter(nodeMgr, rs),
 		txMgr,
@@ -426,7 +426,7 @@ func TestStreamDirectorAccessor(t *testing.T) {
 		},
 	}
 
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 
 	targetRepo := gitalypb.Repository{
 		StorageName:  "praefect",
@@ -533,7 +533,7 @@ func TestCoordinatorStreamDirector_distributesReads(t *testing.T) {
 		},
 	}
 
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 
 	targetRepo := gitalypb.Repository{
 		StorageName:  "praefect",
@@ -820,7 +820,7 @@ func TestRewrittenRepositoryMessage(t *testing.T) {
 func TestStreamDirector_repo_creation(t *testing.T) {
 	t.Parallel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc              string
@@ -1096,7 +1096,7 @@ func TestAbsentCorrelationID(t *testing.T) {
 		},
 	}
 
-	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	queueInterceptor.OnEnqueue(func(ctx context.Context, event datastore.ReplicationEvent, queue datastore.ReplicationEventQueue) (datastore.ReplicationEvent, error) {
 		assert.True(t, len(queueInterceptor.GetEnqueued()) < 2, "expected only one event to be created")
 		return queue.Enqueue(ctx, event)
diff --git a/internal/praefect/datastore/assignment_test.go b/internal/praefect/datastore/assignment_test.go
index 0337e92a6..3de909a37 100644
--- a/internal/praefect/datastore/assignment_test.go
+++ b/internal/praefect/datastore/assignment_test.go
@@ -20,7 +20,7 @@ func TestAssignmentStore_GetHostAssignments(t *testing.T) {
 		storage        string
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	configuredStorages := []string{"storage-1", "storage-2", "storage-3"}
 	for _, tc := range []struct {
@@ -131,7 +131,7 @@ func TestAssignmentStore_SetReplicationFactor(t *testing.T) {
 		}
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc                  string
diff --git a/internal/praefect/datastore/collector_test.go b/internal/praefect/datastore/collector_test.go
index b296e2d53..7afb09cd0 100644
--- a/internal/praefect/datastore/collector_test.go
+++ b/internal/praefect/datastore/collector_test.go
@@ -35,7 +35,7 @@ func TestRepositoryStoreCollector(t *testing.T) {
 		replicas     replicas
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc         string
diff --git a/internal/praefect/datastore/glsql/postgres_test.go b/internal/praefect/datastore/glsql/postgres_test.go
index 6b3eee103..c5f551695 100644
--- a/internal/praefect/datastore/glsql/postgres_test.go
+++ b/internal/praefect/datastore/glsql/postgres_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestOpenDB(t *testing.T) {
-	dbCfg := testdb.GetDBConfig(t, "postgres")
+	dbCfg := testdb.GetConfig(t, "postgres")
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
@@ -78,7 +78,7 @@ func TestUint64Provider(t *testing.T) {
 
 func TestScanAll(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	var ids glsql.Uint64Provider
 	notEmptyRows, err := db.Query("SELECT id FROM (VALUES (1), (200), (300500)) AS t(id)")
diff --git a/internal/praefect/datastore/listener_postgres_test.go b/internal/praefect/datastore/listener_postgres_test.go
index 179709c25..26013ebd6 100644
--- a/internal/praefect/datastore/listener_postgres_test.go
+++ b/internal/praefect/datastore/listener_postgres_test.go
@@ -86,13 +86,13 @@ func (mlh mockListenHandler) Connected() {
 
 func TestPostgresListener_Listen(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	logger := testhelper.NewDiscardingLogger(t)
 
 	newOpts := func() PostgresListenerOpts {
 		opts := DefaultPostgresListenerOpts
-		opts.Addr = glsql.DSN(testdb.GetDBConfig(t, db.Name), true)
+		opts.Addr = glsql.DSN(testdb.GetConfig(t, db.Name), true)
 		opts.MinReconnectInterval = time.Nanosecond
 		opts.MaxReconnectInterval = time.Minute
 		return opts
@@ -368,7 +368,7 @@ func requireEqualNotificationEntries(t *testing.T, d string, entries []notificat
 
 func TestPostgresListener_Listen_repositories_delete(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const channel = "repositories_updates"
 
@@ -401,7 +401,7 @@ func TestPostgresListener_Listen_repositories_delete(t *testing.T) {
 
 func TestPostgresListener_Listen_storage_repositories_insert(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const channel = "storage_repositories_updates"
 
@@ -433,7 +433,7 @@ func TestPostgresListener_Listen_storage_repositories_insert(t *testing.T) {
 
 func TestPostgresListener_Listen_storage_repositories_update(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const channel = "storage_repositories_updates"
 
@@ -461,7 +461,7 @@ func TestPostgresListener_Listen_storage_repositories_update(t *testing.T) {
 
 func TestPostgresListener_Listen_storage_empty_notification(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const channel = "storage_repositories_updates"
 
@@ -480,7 +480,7 @@ func TestPostgresListener_Listen_storage_empty_notification(t *testing.T) {
 
 func TestPostgresListener_Listen_storage_repositories_delete(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const channel = "storage_repositories_updates"
 
@@ -524,7 +524,7 @@ func testListener(t *testing.T, dbName, channel string, setup func(t *testing.T)
 	}
 
 	opts := DefaultPostgresListenerOpts
-	opts.Addr = glsql.DSN(testdb.GetDBConfig(t, dbName), true)
+	opts.Addr = glsql.DSN(testdb.GetConfig(t, dbName), true)
 	opts.Channels = []string{channel}
 
 	handler := mockListenHandler{OnNotification: callback, OnConnected: func() { close(readyChan) }}
diff --git a/internal/praefect/datastore/postgres_test.go b/internal/praefect/datastore/postgres_test.go
index 128e9a778..f1a8f7237 100644
--- a/internal/praefect/datastore/postgres_test.go
+++ b/internal/praefect/datastore/postgres_test.go
@@ -10,10 +10,10 @@ import (
 
 func TestMigrateStatus(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	config := config.Config{
-		DB: testdb.GetDBConfig(t, db.Name),
+		DB: testdb.GetConfig(t, db.Name),
 	}
 
 	_, err := db.Exec("INSERT INTO schema_migrations VALUES ('2020_01_01_test', NOW())")
diff --git a/internal/praefect/datastore/queue_bm_test.go b/internal/praefect/datastore/queue_bm_test.go
index dd11bcb2d..fd44b8167 100644
--- a/internal/praefect/datastore/queue_bm_test.go
+++ b/internal/praefect/datastore/queue_bm_test.go
@@ -31,7 +31,7 @@ func BenchmarkPostgresReplicationEventQueue_Acknowledge(b *testing.B) {
 }
 
 func benchmarkPostgresReplicationEventQueueAcknowledge(b *testing.B, setup map[JobState]int) {
-	db := testdb.NewDB(b)
+	db := testdb.New(b)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
diff --git a/internal/praefect/datastore/queue_test.go b/internal/praefect/datastore/queue_test.go
index 906925b46..64a73c71f 100644
--- a/internal/praefect/datastore/queue_test.go
+++ b/internal/praefect/datastore/queue_test.go
@@ -14,7 +14,7 @@ import (
 
 func TestPostgresReplicationEventQueue_DeleteReplicaUniqueIndex(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		desc        string
 		existingJob *ReplicationEvent
@@ -142,7 +142,7 @@ func TestPostgresReplicationEventQueue_DeleteReplicaUniqueIndex(t *testing.T) {
 
 func TestPostgresReplicationEventQueue_Enqueue(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -189,7 +189,7 @@ func TestPostgresReplicationEventQueue_Enqueue(t *testing.T) {
 
 func TestPostgresReplicationEventQueue_DeleteReplicaInfiniteAttempts(t *testing.T) {
 	t.Parallel()
-	queue := NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := NewPostgresReplicationEventQueue(testdb.New(t))
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -240,7 +240,7 @@ func TestPostgresReplicationEventQueue_DeleteReplicaInfiniteAttempts(t *testing.
 
 func TestPostgresReplicationEventQueue_EnqueueMultiple(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -374,7 +374,7 @@ func TestPostgresReplicationEventQueue_EnqueueMultiple(t *testing.T) {
 
 func TestPostgresReplicationEventQueue_Dequeue(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -423,7 +423,7 @@ func TestPostgresReplicationEventQueue_Dequeue(t *testing.T) {
 // expected results are listed as literals on purpose to be more explicit about what is going on with data
 func TestPostgresReplicationEventQueue_DequeueMultiple(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -533,7 +533,7 @@ func TestPostgresReplicationEventQueue_DequeueMultiple(t *testing.T) {
 
 func TestPostgresReplicationEventQueue_DequeueSameStorageOtherRepository(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -596,7 +596,7 @@ func TestPostgresReplicationEventQueue_DequeueSameStorageOtherRepository(t *test
 
 func TestPostgresReplicationEventQueue_Acknowledge(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -640,7 +640,7 @@ func TestPostgresReplicationEventQueue_Acknowledge(t *testing.T) {
 
 func TestPostgresReplicationEventQueue_AcknowledgeMultiple(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
@@ -829,7 +829,7 @@ func TestPostgresReplicationEventQueue_StartHealthUpdate(t *testing.T) {
 	eventType4 := eventType1
 	eventType4.Job.TargetNodeStorage = "s-2"
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	t.Run("no events is valid", func(t *testing.T) {
 		// 'qc' is not initialized, so the test will fail if there will be an attempt to make SQL operation
@@ -976,7 +976,7 @@ func TestPostgresReplicationEventQueue_AcknowledgeStale(t *testing.T) {
 	eventType4 := eventType3
 	eventType4.Job.TargetNodeStorage = "gitaly-3"
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	t.Run("no stale jobs yet", func(t *testing.T) {
 		db.TruncateAll(t)
diff --git a/internal/praefect/datastore/repository_store_bm_test.go b/internal/praefect/datastore/repository_store_bm_test.go
index 78d12d37c..b0ffbbfad 100644
--- a/internal/praefect/datastore/repository_store_bm_test.go
+++ b/internal/praefect/datastore/repository_store_bm_test.go
@@ -38,7 +38,7 @@ func BenchmarkPostgresRepositoryStore_GetConsistentStorages(b *testing.B) {
 }
 
 func benchmarkGetConsistentStorages(b *testing.B, nstorages, nrepositories int) {
-	db := testdb.NewDB(b)
+	db := testdb.New(b)
 
 	ctx, cancel := testhelper.Context()
 	defer cancel()
diff --git a/internal/praefect/datastore/repository_store_test.go b/internal/praefect/datastore/repository_store_test.go
index d424f4328..7692a4779 100644
--- a/internal/praefect/datastore/repository_store_test.go
+++ b/internal/praefect/datastore/repository_store_test.go
@@ -116,7 +116,7 @@ FROM storage_repositories
 }
 
 func TestRepositoryStore_Postgres(t *testing.T) {
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	testRepositoryStore(t, func(t *testing.T, storages map[string][]string) (RepositoryStore, requireStateFunc) {
 		db.TruncateAll(t)
 		gs := NewPostgresRepositoryStore(db, storages)
@@ -129,7 +129,7 @@ func TestRepositoryStore_Postgres(t *testing.T) {
 }
 
 func TestRepositoryStore_incrementGenerationConcurrently(t *testing.T) {
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	type call struct {
 		primary     string
@@ -1191,7 +1191,7 @@ func testRepositoryStore(t *testing.T, newStore repositoryStoreFactory) {
 
 func TestPostgresRepositoryStore_GetRepositoryMetadata(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		desc                  string
 		nonExistentRepository bool
diff --git a/internal/praefect/datastore/storage_cleanup_test.go b/internal/praefect/datastore/storage_cleanup_test.go
index facd2f0db..77ee0dd22 100644
--- a/internal/praefect/datastore/storage_cleanup_test.go
+++ b/internal/praefect/datastore/storage_cleanup_test.go
@@ -14,7 +14,7 @@ func TestStorageCleanup_Populate(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := testhelper.Context()
 	defer cancel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	storageCleanup := NewStorageCleanup(db.DB)
 
 	require.NoError(t, storageCleanup.Populate(ctx, "praefect", "gitaly-1"))
@@ -37,7 +37,7 @@ func TestStorageCleanup_AcquireNextStorage(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := testhelper.Context()
 	defer cancel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	storageCleanup := NewStorageCleanup(db.DB)
 
 	t.Run("ok", func(t *testing.T) {
@@ -179,7 +179,7 @@ func TestStorageCleanup_Exists(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	repoStore := NewPostgresRepositoryStore(db.DB, nil)
 	require.NoError(t, repoStore.CreateRepository(ctx, 0, "vs", "p/1", "replica-path-1", "g1", []string{"g2", "g3"}, nil, false, false))
diff --git a/internal/praefect/datastore/storage_provider_test.go b/internal/praefect/datastore/storage_provider_test.go
index 3d0690fda..8c0fd2fd9 100644
--- a/internal/praefect/datastore/storage_provider_test.go
+++ b/internal/praefect/datastore/storage_provider_test.go
@@ -22,7 +22,7 @@ import (
 func TestCachingStorageProvider_GetSyncedNodes(t *testing.T) {
 	t.Parallel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := NewPostgresRepositoryStore(db, nil)
 
 	t.Run("unknown virtual storage", func(t *testing.T) {
diff --git a/internal/praefect/helper_test.go b/internal/praefect/helper_test.go
index 9172d0319..d9eed5a81 100644
--- a/internal/praefect/helper_test.go
+++ b/internal/praefect/helper_test.go
@@ -119,7 +119,7 @@ func withMockBackends(t testing.TB, backends map[string]mock.SimpleServiceServer
 }
 
 func defaultQueue(t testing.TB) datastore.ReplicationEventQueue {
-	return datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	return datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 }
 
 func defaultTxMgr(conf config.Config) *transactions.Manager {
diff --git a/internal/praefect/info_service_test.go b/internal/praefect/info_service_test.go
index 4a9f59a8a..8e270b87b 100644
--- a/internal/praefect/info_service_test.go
+++ b/internal/praefect/info_service_test.go
@@ -64,7 +64,7 @@ func TestInfoService_RepositoryReplicas(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	tx := testdb.NewDB(t).Begin(t)
+	tx := testdb.New(t).Begin(t)
 	defer tx.Rollback(t)
 
 	testdb.SetHealthyNodes(t, ctx, tx, map[string]map[string][]string{
diff --git a/internal/praefect/nodes/health_manager_test.go b/internal/praefect/nodes/health_manager_test.go
index 3eee256e5..9dd4e3da8 100644
--- a/internal/praefect/nodes/health_manager_test.go
+++ b/internal/praefect/nodes/health_manager_test.go
@@ -61,7 +61,7 @@ func TestHealthManager(t *testing.T) {
 		HealthConsensus map[string][]string
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc         string
@@ -559,7 +559,7 @@ func TestHealthManager_databaseTimeout(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	blockingTx := db.Begin(t)
 	defer blockingTx.Rollback(t)
@@ -619,7 +619,7 @@ func predateHealthChecks(t testing.TB, db testdb.DB, amount time.Duration) {
 // This test case ensures the record updates are done in an ordered manner to avoid concurrent writes
 // deadlocking. Issue: https://gitlab.com/gitlab-org/gitaly/-/issues/3907
 func TestHealthManager_orderedWrites(t *testing.T) {
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	tx1 := db.Begin(t).Tx
 	defer func() { _ = tx1.Rollback() }()
diff --git a/internal/praefect/nodes/per_repository_test.go b/internal/praefect/nodes/per_repository_test.go
index a69f17309..74a9915b8 100644
--- a/internal/praefect/nodes/per_repository_test.go
+++ b/internal/praefect/nodes/per_repository_test.go
@@ -46,7 +46,7 @@ func TestPerRepositoryElector(t *testing.T) {
 		primary      matcher
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc         string
diff --git a/internal/praefect/nodes/sql_elector_test.go b/internal/praefect/nodes/sql_elector_test.go
index d072c7d03..9050d7287 100644
--- a/internal/praefect/nodes/sql_elector_test.go
+++ b/internal/praefect/nodes/sql_elector_test.go
@@ -30,7 +30,7 @@ var shardName = "test-shard-0"
 
 func TestGetPrimaryAndSecondaries(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	logger := testhelper.NewDiscardingLogger(t).WithField("test", t.Name())
 	praefectSocket := testhelper.GetTemporaryGitalySocketFileName(t)
@@ -75,7 +75,7 @@ func TestGetPrimaryAndSecondaries(t *testing.T) {
 
 func TestSqlElector_slow_execution(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	praefectSocket := "unix://" + testhelper.GetTemporaryGitalySocketFileName(t)
 	logger := testhelper.NewDiscardingLogger(t).WithField("test", t.Name())
@@ -114,7 +114,7 @@ func TestSqlElector_slow_execution(t *testing.T) {
 
 func TestBasicFailover(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	logger := testhelper.NewDiscardingLogger(t).WithField("test", t.Name())
 	praefectSocket := testhelper.GetTemporaryGitalySocketFileName(t)
@@ -225,7 +225,7 @@ func TestBasicFailover(t *testing.T) {
 
 func TestElectDemotedPrimary(t *testing.T) {
 	t.Parallel()
-	tx := testdb.NewDB(t).Begin(t)
+	tx := testdb.New(t).Begin(t)
 	defer tx.Rollback(t)
 
 	node := config.Node{Storage: "gitaly-0"}
@@ -291,7 +291,7 @@ func predateElection(t testing.TB, ctx context.Context, db glsql.Querier, shardN
 
 func TestElectNewPrimary(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	ns := []*nodeStatus{{
 		node: config.Node{
@@ -463,7 +463,7 @@ func TestConnectionMultiplexing(t *testing.T) {
 
 	go srv.Serve(ln)
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	mgr, err := NewManager(
 		testhelper.NewDiscardingLogEntry(t),
 		config.Config{
diff --git a/internal/praefect/reconciler/reconciler_benchmark_test.go b/internal/praefect/reconciler/reconciler_benchmark_test.go
index dec8db261..4c11630b8 100644
--- a/internal/praefect/reconciler/reconciler_benchmark_test.go
+++ b/internal/praefect/reconciler/reconciler_benchmark_test.go
@@ -31,7 +31,7 @@ func benchmarkReconcile(b *testing.B, numRepositories int, worstCase bool) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(b)
+	db := testdb.New(b)
 
 	behind := 0
 	if worstCase {
diff --git a/internal/praefect/reconciler/reconciler_test.go b/internal/praefect/reconciler/reconciler_test.go
index c18d49a4d..54b9e7b93 100644
--- a/internal/praefect/reconciler/reconciler_test.go
+++ b/internal/praefect/reconciler/reconciler_test.go
@@ -82,7 +82,7 @@ func TestReconciler(t *testing.T) {
 		return out
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc                string
@@ -1176,7 +1176,7 @@ func TestReconciler_renames(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	for _, tc := range []struct {
 		desc          string
diff --git a/internal/praefect/remove_repository_test.go b/internal/praefect/remove_repository_test.go
index 844787287..d2a0e9629 100644
--- a/internal/praefect/remove_repository_test.go
+++ b/internal/praefect/remove_repository_test.go
@@ -41,7 +41,7 @@ func testRemoveRepositoryHandler(t *testing.T, ctx context.Context) {
 		errNotFound = helper.ErrNotFoundf("repository does not exist")
 	}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		desc          string
 		routeToGitaly bool
diff --git a/internal/praefect/replicator_pg_test.go b/internal/praefect/replicator_pg_test.go
index ab1491eaf..025597a0b 100644
--- a/internal/praefect/replicator_pg_test.go
+++ b/internal/praefect/replicator_pg_test.go
@@ -49,7 +49,7 @@ func TestReplicatorInvalidSourceRepository(t *testing.T) {
 	require.NoError(t, err)
 	defer testhelper.MustClose(t, targetCC)
 
-	rs := datastore.NewPostgresRepositoryStore(testdb.NewDB(t), nil)
+	rs := datastore.NewPostgresRepositoryStore(testdb.New(t), nil)
 
 	require.NoError(t, rs.CreateRepository(ctx, 1, "virtual-storage-1", "relative-path-1", "relative-path-1", "gitaly-1", nil, nil, true, false))
 
@@ -76,7 +76,7 @@ func TestReplicatorInvalidSourceRepository(t *testing.T) {
 
 func TestReplicatorDestroy(t *testing.T) {
 	t.Parallel()
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		change datastore.ChangeType
 		error  error
diff --git a/internal/praefect/replicator_test.go b/internal/praefect/replicator_test.go
index 4f9351763..3d13b2c3c 100644
--- a/internal/praefect/replicator_test.go
+++ b/internal/praefect/replicator_test.go
@@ -150,7 +150,7 @@ func TestReplMgr_ProcessBacklog(t *testing.T) {
 	logger := testhelper.NewDiscardingLogger(t)
 	loggerHook := test.NewLocal(logger)
 
-	queue := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queue := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	queue.OnAcknowledge(func(ctx context.Context, state datastore.JobState, ids []uint64, queue datastore.ReplicationEventQueue) ([]uint64, error) {
 		cancel() // when it is called we know that replication is finished
 		return queue.Acknowledge(ctx, state, ids)
@@ -160,7 +160,7 @@ func TestReplMgr_ProcessBacklog(t *testing.T) {
 	_, err = queue.Enqueue(ctx, events[0])
 	require.NoError(t, err)
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := datastore.NewPostgresRepositoryStore(db, conf.StorageNames())
 	require.NoError(t, rs.CreateRepository(ctx, repositoryID, conf.VirtualStorages[0].Name, testRepo.GetRelativePath(), testRepo.GetRelativePath(), shard.Primary.GetStorage(), nil, nil, true, false))
 
@@ -311,7 +311,7 @@ func TestReplicator_PropagateReplicationJob(t *testing.T) {
 	// unlinkat /tmp/gitaly-222007427/381349228/storages.d/internal-gitaly-1/+gitaly/state/path/to/repo: directory not empty
 	// By using WaitGroup we are sure the test cleanup will be started after all replication
 	// requests are completed, so no running cache IO operations happen.
-	queue := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queue := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	var wg sync.WaitGroup
 	queue.OnEnqueue(func(ctx context.Context, event datastore.ReplicationEvent, queue datastore.ReplicationEventQueue) (datastore.ReplicationEvent, error) {
 		wg.Add(1)
@@ -688,7 +688,7 @@ func TestProcessBacklog_FailedJobs(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 
 	// this job exists to verify that replication works
 	okJob := datastore.ReplicationJob{
@@ -717,7 +717,7 @@ func TestProcessBacklog_FailedJobs(t *testing.T) {
 	nodeMgr.Start(0, time.Hour)
 	defer nodeMgr.Stop()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := datastore.NewPostgresRepositoryStore(db, conf.StorageNames())
 	require.NoError(t, rs.CreateRepository(ctx, okJob.RepositoryID, okJob.VirtualStorage, okJob.RelativePath, okJob.RelativePath, okJob.SourceNodeStorage, nil, nil, true, false))
 
@@ -795,7 +795,7 @@ func TestProcessBacklog_Success(t *testing.T) {
 		},
 	}
 
-	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	queueInterceptor.OnAcknowledge(func(ctx context.Context, state datastore.JobState, ids []uint64, queue datastore.ReplicationEventQueue) ([]uint64, error) {
 		ackIDs, err := queue.Acknowledge(ctx, state, ids)
 		if len(ids) > 0 {
@@ -874,7 +874,7 @@ func TestProcessBacklog_Success(t *testing.T) {
 	nodeMgr.Start(0, time.Hour)
 	defer nodeMgr.Stop()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := datastore.NewPostgresRepositoryStore(db, conf.StorageNames())
 	require.NoError(t, rs.CreateRepository(ctx, eventType1.Job.RepositoryID, eventType1.Job.VirtualStorage, eventType1.Job.VirtualStorage, eventType1.Job.RelativePath, eventType1.Job.SourceNodeStorage, nil, nil, true, false))
 
@@ -921,7 +921,7 @@ func TestReplMgrProcessBacklog_OnlyHealthyNodes(t *testing.T) {
 
 	var mtx sync.Mutex
 	expStorages := map[string]bool{conf.VirtualStorages[0].Nodes[0].Storage: true, conf.VirtualStorages[0].Nodes[2].Storage: true}
-	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	queueInterceptor.OnDequeue(func(_ context.Context, virtualStorageName string, storageName string, _ int, _ datastore.ReplicationEventQueue) ([]datastore.ReplicationEvent, error) {
 		select {
 		case <-ctx.Done():
@@ -1004,7 +1004,7 @@ func TestProcessBacklog_ReplicatesToReadOnlyPrimary(t *testing.T) {
 		},
 	}
 
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 	_, err := queue.Enqueue(ctx, datastore.ReplicationEvent{
 		Job: datastore.ReplicationJob{
 			RepositoryID:      1,
@@ -1017,7 +1017,7 @@ func TestProcessBacklog_ReplicatesToReadOnlyPrimary(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	rs := datastore.NewPostgresRepositoryStore(db, conf.StorageNames())
 	require.NoError(t, rs.CreateRepository(ctx, repositoryID, virtualStorage, "ignored", "ignored", primaryStorage, []string{secondaryStorage}, nil, true, false))
 
diff --git a/internal/praefect/repocleaner/repository_test.go b/internal/praefect/repocleaner/repository_test.go
index 2c5396d46..7acf5f142 100644
--- a/internal/praefect/repocleaner/repository_test.go
+++ b/internal/praefect/repocleaner/repository_test.go
@@ -48,8 +48,8 @@ func TestRunner_Run(t *testing.T) {
 	g2Addr := testserver.RunGitalyServer(t, g2Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 	g3Addr := testserver.RunGitalyServer(t, g3Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	conf := config.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
@@ -197,8 +197,8 @@ func TestRunner_Run_noAvailableStorages(t *testing.T) {
 	g1Cfg := testcfg.Build(t, testcfg.WithStorages(storage1))
 	g1Addr := testserver.RunGitalyServer(t, g1Cfg, nil, setup.RegisterAll, testserver.WithDisablePraefect())
 
-	db := testdb.NewDB(t)
-	dbConf := testdb.GetDBConfig(t, db.Name)
+	db := testdb.New(t)
+	dbConf := testdb.GetConfig(t, db.Name)
 
 	conf := config.Config{
 		SocketPath: testhelper.GetTemporaryGitalySocketFileName(t),
diff --git a/internal/praefect/repository_exists_test.go b/internal/praefect/repository_exists_test.go
index 78edae92c..af688dc32 100644
--- a/internal/praefect/repository_exists_test.go
+++ b/internal/praefect/repository_exists_test.go
@@ -23,7 +23,7 @@ func TestRepositoryExistsHandler(t *testing.T) {
 	t.Parallel()
 	errServedByGitaly := status.Error(codes.Unknown, "request passed to Gitaly")
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	for _, tc := range []struct {
 		desc          string
 		routeToGitaly bool
diff --git a/internal/praefect/router_per_repository_test.go b/internal/praefect/router_per_repository_test.go
index 62d73809b..ca2079639 100644
--- a/internal/praefect/router_per_repository_test.go
+++ b/internal/praefect/router_per_repository_test.go
@@ -115,7 +115,7 @@ func TestPerRepositoryRouter_RouteStorageAccessor(t *testing.T) {
 func TestPerRepositoryRouter_RouteRepositoryAccessor(t *testing.T) {
 	t.Parallel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const relativePath = "repository"
 
@@ -268,7 +268,7 @@ func TestPerRepositoryRouter_RouteRepositoryAccessor(t *testing.T) {
 func TestPerRepositoryRouter_RouteRepositoryMutator(t *testing.T) {
 	t.Parallel()
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	configuredNodes := map[string][]string{
 		"virtual-storage-1": {"primary", "secondary-1", "secondary-2"},
@@ -481,7 +481,7 @@ func TestPerRepositoryRouter_RouteRepositoryCreation(t *testing.T) {
 	secondary1Conn := &grpc.ClientConn{}
 	secondary2Conn := &grpc.ClientConn{}
 
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 
 	const relativePath = "relative-path"
 
diff --git a/internal/praefect/server_factory_test.go b/internal/praefect/server_factory_test.go
index 5003e7820..d3563f1ef 100644
--- a/internal/praefect/server_factory_test.go
+++ b/internal/praefect/server_factory_test.go
@@ -71,7 +71,7 @@ func TestServerFactory(t *testing.T) {
 	revision := text.ChompBytes(gittest.Exec(t, cfg, "-C", repoPath, "rev-parse", "HEAD"))
 
 	logger := testhelper.NewDiscardingLogEntry(t)
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 
 	rs := datastore.MockRepositoryStore{}
 	txMgr := transactions.NewManager(conf)
diff --git a/internal/praefect/server_test.go b/internal/praefect/server_test.go
index 4730b6d46..61d718f03 100644
--- a/internal/praefect/server_test.go
+++ b/internal/praefect/server_test.go
@@ -535,7 +535,7 @@ func testRemoveRepository(t *testing.T, ctx context.Context) {
 
 	verifyReposExistence(t, codes.OK)
 
-	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	queueInterceptor := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 	repoStore := defaultRepoStore(praefectCfg)
 	txMgr := defaultTxMgr(praefectCfg)
 	nodeMgr, err := nodes.NewManager(testhelper.NewDiscardingLogEntry(t), praefectCfg, nil,
@@ -632,9 +632,9 @@ func TestRenameRepository(t *testing.T) {
 		repoPaths[i] = filepath.Join(gitalyCfg.Storages[0].Path, relativePath)
 	}
 
-	evq := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t)))
+	evq := datastore.NewReplicationEventQueueInterceptor(datastore.NewPostgresReplicationEventQueue(testdb.New(t)))
 
-	tx := testdb.NewDB(t).Begin(t)
+	tx := testdb.New(t).Begin(t)
 	defer tx.Rollback(t)
 
 	rs := datastore.NewPostgresRepositoryStore(tx, nil)
@@ -833,7 +833,7 @@ func TestProxyWrites(t *testing.T) {
 		},
 	}
 
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 	entry := testhelper.NewDiscardingLogEntry(t)
 
 	nodeMgr, err := nodes.NewManager(entry, conf, nil, nil, promtest.NewMockHistogramVec(), protoregistry.GitalyProtoPreregistered, nil, nil, nil)
@@ -969,7 +969,7 @@ func TestErrorThreshold(t *testing.T) {
 	ctx, cancel := testhelper.Context()
 	defer cancel()
 
-	queue := datastore.NewPostgresReplicationEventQueue(testdb.NewDB(t))
+	queue := datastore.NewPostgresReplicationEventQueue(testdb.New(t))
 	entry := testhelper.NewDiscardingLogEntry(t)
 
 	testCases := []struct {
diff --git a/internal/testhelper/testdb/db.go b/internal/testhelper/testdb/db.go
index 8abc9f27c..c3d855425 100644
--- a/internal/testhelper/testdb/db.go
+++ b/internal/testhelper/testdb/db.go
@@ -120,7 +120,7 @@ func (db DB) Close() error {
 	return nil
 }
 
-// NewDB returns a wrapper around the database connection pool.
+// New returns a wrapper around the database connection pool.
 // Must be used only for testing.
 // The new database with empty relations will be created for each call of this function.
 // It uses env vars:
@@ -128,15 +128,15 @@ func (db DB) Close() error {
 //   PGPORT - required, binding port
 //   PGUSER - optional, user - `$ whoami` would be used if not provided
 // Once the test is completed the database will be dropped on test cleanup execution.
-func NewDB(t testing.TB) DB {
+func New(t testing.TB) DB {
 	t.Helper()
 	database := "praefect_" + strings.ReplaceAll(uuid.New().String(), "-", "")
-	return DB{DB: initPraefectTestDB(t, database), Name: database}
+	return DB{DB: initPraefectDB(t, database), Name: database}
 }
 
-// GetDBConfig returns the database configuration determined by
+// GetConfig returns the database configuration determined by
 // environment variables.  See NewDB() for the list of variables.
-func GetDBConfig(t testing.TB, database string) config.DB {
+func GetConfig(t testing.TB, database string) config.DB {
 	env := getDatabaseEnvironment(t)
 
 	require.Contains(t, env, "PGHOST", "PGHOST env var expected to be provided to connect to Postgres database")
@@ -202,10 +202,10 @@ func requireTerminateAllConnections(t testing.TB, db *sql.DB, database string) {
 	}, 20*time.Second, 10*time.Millisecond, "wait for all connections to be terminated")
 }
 
-func initPraefectTestDB(t testing.TB, database string) *sql.DB {
+func initPraefectDB(t testing.TB, database string) *sql.DB {
 	t.Helper()
 
-	dbCfg := GetDBConfig(t, "postgres")
+	dbCfg := GetConfig(t, "postgres")
 	// We require a direct connection to the Postgres instance and not through the PgBouncer
 	// because we use transaction pool mood for it and it doesn't work well for system advisory locks.
 	postgresDB := requireSQLOpen(t, dbCfg, true)
@@ -227,7 +227,7 @@ func initPraefectTestDB(t testing.TB, database string) *sql.DB {
 		require.NoErrorf(t, err, "failed to create %q database", praefectTemplateDatabase)
 	}
 
-	templateDBConf := GetDBConfig(t, praefectTemplateDatabase)
+	templateDBConf := GetConfig(t, praefectTemplateDatabase)
 	templateDB := requireSQLOpen(t, templateDBConf, true)
 	defer func() {
 		require.NoErrorf(t, templateDB.Close(), "release connection to the %q database", templateDBConf.DBName)
diff --git a/internal/testhelper/testdb/db_test.go b/internal/testhelper/testdb/db_test.go
index b9a1725b1..a3687d977 100644
--- a/internal/testhelper/testdb/db_test.go
+++ b/internal/testhelper/testdb/db_test.go
@@ -8,7 +8,7 @@ import (
 
 func TestDB_Truncate(t *testing.T) {
 	t.Parallel()
-	db := NewDB(t)
+	db := New(t)
 
 	_, err := db.Exec("CREATE TABLE truncate_tbl(id BIGSERIAL PRIMARY KEY)")
 	require.NoError(t, err)
diff --git a/internal/testhelper/testserver/gitaly.go b/internal/testhelper/testserver/gitaly.go
index f6cf6d2fc..0e48d6622 100644
--- a/internal/testhelper/testserver/gitaly.go
+++ b/internal/testhelper/testserver/gitaly.go
@@ -85,7 +85,7 @@ func StartGitalyServer(t testing.TB, cfg config.Cfg, rubyServer *rubyserver.Serv
 
 // createDatabase create a new database with randomly generated name and returns it back to the caller.
 func createDatabase(t testing.TB) string {
-	db := testdb.NewDB(t)
+	db := testdb.New(t)
 	return db.Name
 }
 
@@ -113,7 +113,7 @@ func runPraefectProxy(t testing.TB, cfg config.Cfg, gitalyAddr, praefectBinPath
 		Auth: auth.Config{
 			Token: cfg.Auth.Token,
 		},
-		DB: testdb.GetDBConfig(t, dbName),
+		DB: testdb.GetConfig(t, dbName),
 		Failover: praefectconfig.Failover{
 			Enabled:          true,
 			ElectionStrategy: praefectconfig.ElectionStrategyLocal,