From bb4a18541281e596a76193ea1de48ef0edf582e1 Mon Sep 17 00:00:00 2001
From: Todd Knight <T.Alan.Knight@gmail.com>
Date: Mon, 6 Jul 2020 10:15:01 -0700
Subject: [PATCH] Pushing test db cleanup up to where the database objects are
 created using t.Cleanup. (#166)

---
 internal/auth/db_test.go                      |  26 +---
 internal/db/domains_test.go                   |  52 +-------
 internal/db/read_writer_test.go               | 126 +++---------------
 internal/db/testing.go                        |  13 +-
 internal/db/testing_test.go                   |  20 +--
 internal/host/static/repository_test.go       |  55 +-------
 internal/host/static/static_test.go           |  41 +-----
 internal/iam/auth_account_test.go             |  24 +---
 internal/iam/group_test.go                    |  49 +------
 internal/iam/repository_group_test.go         |  32 +----
 internal/iam/repository_role_test.go          |  32 +----
 internal/iam/repository_scope_test.go         |  59 +-------
 internal/iam/repository_test.go               |  32 +----
 internal/iam/repository_user_test.go          |  43 +-----
 internal/iam/resource_test.go                 |   8 +-
 internal/iam/role_test.go                     |  49 +------
 internal/iam/scope_test.go                    |  40 +-----
 internal/iam/testing_test.go                  |  42 +-----
 internal/iam/user_test.go                     |  50 +------
 .../handlers/groups/group_service_test.go     |  20 +--
 .../host_catalog_service_test.go              |  10 +-
 .../organization_service_test.go              |  20 +--
 .../handlers/projects/project_service_test.go |  20 +--
 .../handlers/roles/role_service_test.go       |  20 +--
 .../handlers/users/user_service_test.go       |  20 +--
 25 files changed, 110 insertions(+), 793 deletions(-)

diff --git a/internal/auth/db_test.go b/internal/auth/db_test.go
index 082c4a749..979779a52 100644
--- a/internal/auth/db_test.go
+++ b/internal/auth/db_test.go
@@ -40,18 +40,7 @@ select count(*) from test_auth_method where public_id = $1;
 
 	assert, require := assert.New(t), require.New(t)
 
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	db := conn.DB()
 	_, err := db.Exec(createTable)
 	require.NoError(err)
@@ -115,18 +104,7 @@ values
 
 	assert, require := assert.New(t), require.New(t)
 
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	db := conn.DB()
 	_, err := db.Exec(createTable)
 	require.NoError(err)
diff --git a/internal/db/domains_test.go b/internal/db/domains_test.go
index 8803b525b..de6f3b1aa 100644
--- a/internal/db/domains_test.go
+++ b/internal/db/domains_test.go
@@ -25,17 +25,7 @@ returning id;
 `
 	)
 
-	cleanup, conn, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := TestSetup(t, "postgres")
 	db := conn.DB()
 	if _, err := db.Exec(createTable); err != nil {
 		t.Fatalf("query: \n%s\n error: %s", createTable, err)
@@ -92,17 +82,7 @@ returning id;
 `
 	)
 
-	cleanup, conn, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := TestSetup(t, "postgres")
 	db := conn.DB()
 	if _, err := db.Exec(createTable); err != nil {
 		t.Fatalf("query: \n%s\n error: %s", createTable, err)
@@ -168,16 +148,7 @@ set create_time = null;
 `
 	)
 
-	cleanup, conn, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := TestSetup(t, "postgres")
 	db := conn.DB()
 	_, err := db.Exec(createTable)
 	assert.NoError(err)
@@ -265,16 +236,7 @@ set update_time = null;
 `
 	)
 
-	cleanup, conn, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := TestSetup(t, "postgres")
 	db := conn.DB()
 	_, err := db.Exec(createTable)
 	assert.NoError(err)
@@ -344,12 +306,8 @@ returning public_id;
 
 		search = `select version from test_table_wt_version where public_id = $1`
 	)
-	cleanup, conn, _ := TestSetup(t, "postgres")
+	conn, _ := TestSetup(t, "postgres")
 	assert, require := assert.New(t), require.New(t)
-	defer func() {
-		assert.NoError(conn.Close())
-		assert.NoError(cleanup())
-	}()
 
 	db := conn.DB()
 	_, err := db.Exec(createTable)
diff --git a/internal/db/read_writer_test.go b/internal/db/read_writer_test.go
index de2c9c372..1e3b64bcf 100644
--- a/internal/db/read_writer_test.go
+++ b/internal/db/read_writer_test.go
@@ -24,16 +24,10 @@ import (
 )
 
 func TestDb_Update(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
+	db, _ := TestSetup(t, "postgres")
 	now := &timestamp.Timestamp{Timestamp: ptypes.TimestampNow()}
 	publicId, err := NewPublicId("testuser")
 	require.NoError(t, err)
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
 	id := testId(t)
 	type args struct {
 		i              *db_test.TestUser
@@ -508,13 +502,7 @@ func (u *testUserWithVet) VetForWrite(ctx context.Context, r Reader, opType OpTy
 
 func TestDb_Create(t *testing.T) {
 	// intentionally not run with t.Parallel so we don't need to use DoTx for the Create tests
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("simple", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := Db{underlying: db}
@@ -689,13 +677,7 @@ func TestDb_Create(t *testing.T) {
 
 func TestDb_LookupByName(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("simple", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := Db{underlying: db}
@@ -751,13 +733,7 @@ func TestDb_LookupByName(t *testing.T) {
 
 func TestDb_LookupByPublicId(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("simple", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := Db{underlying: db}
@@ -812,13 +788,7 @@ func TestDb_LookupByPublicId(t *testing.T) {
 
 func TestDb_LookupWhere(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("simple", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := Db{underlying: db}
@@ -870,13 +840,7 @@ func TestDb_LookupWhere(t *testing.T) {
 
 func TestDb_SearchWhere(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	knownUser := testUser(t, db, "", "", "")
 
 	type args struct {
@@ -986,14 +950,7 @@ func TestDb_SearchWhere(t *testing.T) {
 
 func TestDb_DB(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		require := require.New(t)
-		err := cleanup()
-		require.NoError(err)
-		err = db.Close()
-		require.NoError(err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("valid", func(t *testing.T) {
 		require := require.New(t)
 		w := Db{underlying: db}
@@ -1015,14 +972,7 @@ func TestDb_DB(t *testing.T) {
 
 func TestDb_DoTx(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		require := require.New(t)
-		err := cleanup()
-		require.NoError(err)
-		err = db.Close()
-		require.NoError(err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("valid-with-10-retries", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := &Db{underlying: db}
@@ -1191,14 +1141,7 @@ func TestDb_DoTx(t *testing.T) {
 }
 
 func TestDb_Delete(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		require := require.New(t)
-		err := cleanup()
-		require.NoError(err)
-		err = db.Close()
-		require.NoError(err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	newUser := func() *db_test.TestUser {
 		w := &Db{
 			underlying: db,
@@ -1415,14 +1358,7 @@ func TestDb_Delete(t *testing.T) {
 
 func TestDb_ScanRows(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		require := require.New(t)
-		err := cleanup()
-		require.NoError(err)
-		err = db.Close()
-		require.NoError(err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	t.Run("valid", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := Db{underlying: db}
@@ -1451,13 +1387,7 @@ func TestDb_ScanRows(t *testing.T) {
 }
 
 func TestDb_CreateItems(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	testOplogResourceId := testId(t)
 
 	createFn := func() []interface{} {
@@ -1671,14 +1601,7 @@ func TestDb_CreateItems(t *testing.T) {
 }
 
 func TestDb_DeleteItems(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
-
+	db, _ := TestSetup(t, "postgres")
 	testOplogResourceId := testId(t)
 
 	createFn := func() []interface{} {
@@ -1944,13 +1867,7 @@ func testScooter(t *testing.T, conn *gorm.DB, model string, mpg int32) *db_test.
 
 func TestDb_LookupById(t *testing.T) {
 	t.Parallel()
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	scooter := testScooter(t, db, "", 0)
 	user := testUser(t, db, "", "", "")
 	type args struct {
@@ -2055,13 +1972,7 @@ func TestDb_LookupById(t *testing.T) {
 }
 
 func TestDb_GetTicket(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
+	db, _ := TestSetup(t, "postgres")
 	type notReplayable struct{}
 	tests := []struct {
 		name          string
@@ -2122,14 +2033,7 @@ func TestDb_GetTicket(t *testing.T) {
 }
 
 func TestDb_WriteOplogEntryWith(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = db.Close()
-		assert.NoError(t, err)
-	}()
-
+	db, _ := TestSetup(t, "postgres")
 	w := Db{underlying: db}
 
 	ticket, err := w.GetTicket(&db_test.TestUser{})
diff --git a/internal/db/testing.go b/internal/db/testing.go
index a29e582f4..960edf0ec 100644
--- a/internal/db/testing.go
+++ b/internal/db/testing.go
@@ -13,19 +13,26 @@ import (
 	"github.com/hashicorp/watchtower/internal/oplog"
 	"github.com/hashicorp/watchtower/internal/oplog/store"
 	"github.com/jinzhu/gorm"
+	"github.com/stretchr/testify/assert"
 )
 
-// setup the tests (initialize the database one-time and intialized testDatabaseURL)
-func TestSetup(t *testing.T, dialect string) (func() error, *gorm.DB, string) {
+// setup the tests (initialize the database one-time and intialized testDatabaseURL). Do not close the returned db.
+func TestSetup(t *testing.T, dialect string) (*gorm.DB, string) {
 	cleanup, url, _, err := InitDbInDocker(dialect)
 	if err != nil {
 		t.Fatal(err)
 	}
+	t.Cleanup(func() {
+		assert.NoError(t, cleanup(), "Got error cleaning up db in docker.")
+	})
 	db, err := gorm.Open(dialect, url)
 	if err != nil {
 		t.Fatal(err)
 	}
-	return cleanup, db, url
+	t.Cleanup(func() {
+		assert.NoError(t, db.Close(), "Got error closing gorm db.")
+	})
+	return db, url
 }
 
 // TestWrapper initializes an AEAD wrapping.Wrapper for testing the oplog
diff --git a/internal/db/testing_test.go b/internal/db/testing_test.go
index 5ae181eb7..a99fa3a4a 100644
--- a/internal/db/testing_test.go
+++ b/internal/db/testing_test.go
@@ -15,31 +15,15 @@ import (
 
 func Test_Utils(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	_, _ = TestSetup(t, "postgres")
 	t.Run("nothing", func(t *testing.T) {
 
 	})
 }
 
 func TestVerifyOplogEntry(t *testing.T) {
-	cleanup, db, _ := TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
+	db, _ := TestSetup(t, "postgres")
 	assert := assert.New(t)
-	defer db.Close()
 
 	t.Run("valid", func(t *testing.T) {
 		rw := Db{underlying: db}
diff --git a/internal/host/static/repository_test.go b/internal/host/static/repository_test.go
index 77cfd8216..6ca043094 100644
--- a/internal/host/static/repository_test.go
+++ b/internal/host/static/repository_test.go
@@ -17,17 +17,7 @@ import (
 )
 
 func TestRepository_New(t *testing.T) {
-
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 
@@ -115,15 +105,7 @@ func TestRepository_New(t *testing.T) {
 }
 
 func TestRepository_CreateCatalog(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 
@@ -282,16 +264,7 @@ func assertPublicId(t *testing.T, prefix, actual string) {
 }
 
 func TestRepository_UpdateCatalog(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 
@@ -674,16 +647,7 @@ func TestRepository_UpdateCatalog(t *testing.T) {
 }
 
 func TestRepository_LookupCatalog(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	cat := testCatalog(t, conn)
 	badId, err := newHostCatalogId()
 	assert.NoError(t, err)
@@ -743,16 +707,7 @@ func TestRepository_LookupCatalog(t *testing.T) {
 }
 
 func TestRepository_DeleteCatalog(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	cat := testCatalog(t, conn)
 	badId, err := newHostCatalogId()
 	assert.NoError(t, err)
diff --git a/internal/host/static/static_test.go b/internal/host/static/static_test.go
index ea6d06f2e..8c03313aa 100644
--- a/internal/host/static/static_test.go
+++ b/internal/host/static/static_test.go
@@ -13,16 +13,7 @@ import (
 )
 
 func TestHostCatalog_New(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	_, prj := iam.TestScopes(t, conn)
 
 	type args struct {
@@ -145,15 +136,7 @@ func testCatalog(t *testing.T, conn *gorm.DB) *HostCatalog {
 }
 
 func TestHost_New(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	cat := testCatalog(t, conn)
 
 	conn.LogMode(false)
@@ -296,15 +279,7 @@ func TestHost_New(t *testing.T) {
 }
 
 func TestHostSet_New(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	cat := testCatalog(t, conn)
 
 	conn.LogMode(false)
@@ -445,15 +420,7 @@ func testSets(t *testing.T, conn *gorm.DB, catalogId string, count int) []*HostS
 }
 
 func TestHostSetMember_New(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		if err := cleanup(); err != nil {
-			t.Error(err)
-		}
-		if err := conn.Close(); err != nil {
-			t.Error(err)
-		}
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	conn.LogMode(false)
 
 	cats := testCatalogs(t, conn, 2)
diff --git a/internal/iam/auth_account_test.go b/internal/iam/auth_account_test.go
index 7e1523824..101ff7d98 100644
--- a/internal/iam/auth_account_test.go
+++ b/internal/iam/auth_account_test.go
@@ -18,13 +18,7 @@ import (
 // relies on.
 func Test_AuthAccountUpdate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	rw := db.New(conn)
 	t.Run("simple-update", func(t *testing.T) {
@@ -49,13 +43,7 @@ func Test_AuthAccountUpdate(t *testing.T) {
 
 func TestAuthAccount_GetScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 
 	t.Run("valid-org", func(t *testing.T) {
@@ -72,13 +60,7 @@ func TestAuthAccount_GetScope(t *testing.T) {
 
 func TestAuthAccount_Clone(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	t.Run("valid", func(t *testing.T) {
 		assert := assert.New(t)
diff --git a/internal/iam/group_test.go b/internal/iam/group_test.go
index ef3d5e370..1e538f97b 100644
--- a/internal/iam/group_test.go
+++ b/internal/iam/group_test.go
@@ -18,13 +18,7 @@ import (
 
 func TestNewGroup(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 	id := testId(t)
 
@@ -100,13 +94,7 @@ func TestNewGroup(t *testing.T) {
 
 func Test_GroupCreate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 	type args struct {
 		group *Group
@@ -215,13 +203,7 @@ func Test_GroupCreate(t *testing.T) {
 
 func Test_GroupUpdate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	id := testId(t)
 	org, proj := TestScopes(t, conn)
 	rw := db.New(conn)
@@ -391,14 +373,7 @@ func Test_GroupUpdate(t *testing.T) {
 
 func Test_GroupDelete(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	id := testId(t)
 	org, _ := TestScopes(t, conn)
@@ -467,13 +442,7 @@ func TestGroup_ResourceType(t *testing.T) {
 
 func TestGroup_GetScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 
 	t.Run("valid-org", func(t *testing.T) {
@@ -496,13 +465,7 @@ func TestGroup_GetScope(t *testing.T) {
 
 func TestGroup_Clone(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 
 	t.Run("valid", func(t *testing.T) {
diff --git a/internal/iam/repository_group_test.go b/internal/iam/repository_group_test.go
index 75ae58df2..4801af932 100644
--- a/internal/iam/repository_group_test.go
+++ b/internal/iam/repository_group_test.go
@@ -17,13 +17,7 @@ import (
 
 func TestRepository_CreateGroup(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -178,13 +172,7 @@ func TestRepository_CreateGroup(t *testing.T) {
 
 func TestRepository_UpdateGroup(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	a := assert.New(t)
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
@@ -453,13 +441,7 @@ func TestRepository_UpdateGroup(t *testing.T) {
 
 func TestRepository_DeleteGroup(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	a := assert.New(t)
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
@@ -543,13 +525,7 @@ func TestRepository_DeleteGroup(t *testing.T) {
 
 func TestRepository_ListGroups(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	const testLimit = 10
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
diff --git a/internal/iam/repository_role_test.go b/internal/iam/repository_role_test.go
index c3f7fc301..6a96e8728 100644
--- a/internal/iam/repository_role_test.go
+++ b/internal/iam/repository_role_test.go
@@ -17,13 +17,7 @@ import (
 
 func TestRepository_CreateRole(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -178,13 +172,7 @@ func TestRepository_CreateRole(t *testing.T) {
 
 func TestRepository_UpdateRole(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -453,13 +441,7 @@ func TestRepository_UpdateRole(t *testing.T) {
 
 func TestRepository_DeleteRole(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -542,13 +524,7 @@ func TestRepository_DeleteRole(t *testing.T) {
 
 func TestRepository_ListRoles(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	const testLimit = 10
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
diff --git a/internal/iam/repository_scope_test.go b/internal/iam/repository_scope_test.go
index 11fd43759..64d6fc204 100644
--- a/internal/iam/repository_scope_test.go
+++ b/internal/iam/repository_scope_test.go
@@ -19,14 +19,7 @@ import (
 
 func Test_Repository_CreateScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		rw := db.New(conn)
@@ -125,14 +118,7 @@ func Test_Repository_CreateScope(t *testing.T) {
 
 func Test_Repository_UpdateScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		rw := db.New(conn)
@@ -196,14 +182,7 @@ func Test_Repository_UpdateScope(t *testing.T) {
 
 func Test_Repository_LookupScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("found-and-not-found", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		rw := db.New(conn)
@@ -229,13 +208,7 @@ func Test_Repository_LookupScope(t *testing.T) {
 
 func Test_Repository_DeleteScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -272,15 +245,9 @@ func Test_Repository_DeleteScope(t *testing.T) {
 }
 
 func TestRepository_UpdateScope(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
+	conn, _ := db.TestSetup(t, "postgres")
 	now := &timestamp.Timestamp{Timestamp: ptypes.TimestampNow()}
 	id := testId(t)
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	publicId := testPublicId(t, "o")
@@ -497,13 +464,7 @@ func TestRepository_UpdateScope(t *testing.T) {
 
 func TestRepository_ListProjects(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	const testLimit = 10
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
@@ -583,13 +544,7 @@ func TestRepository_ListProjects(t *testing.T) {
 
 func TestRepository_ListOrganizations(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	const testLimit = 10
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
diff --git a/internal/iam/repository_test.go b/internal/iam/repository_test.go
index 5e7c8aa52..582d7c2f7 100644
--- a/internal/iam/repository_test.go
+++ b/internal/iam/repository_test.go
@@ -21,13 +21,7 @@ import (
 
 func TestNewRepository(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	type args struct {
@@ -107,13 +101,7 @@ func TestNewRepository(t *testing.T) {
 }
 func Test_Repository_create(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		rw := db.New(conn)
@@ -159,13 +147,7 @@ func Test_Repository_create(t *testing.T) {
 
 func Test_Repository_delete(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-org", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		rw := db.New(conn)
@@ -196,15 +178,9 @@ func Test_Repository_delete(t *testing.T) {
 }
 
 func TestRepository_update(t *testing.T) {
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
+	conn, _ := db.TestSetup(t, "postgres")
 	now := &timestamp.Timestamp{Timestamp: ptypes.TimestampNow()}
 	id := testId(t)
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	publicId := testPublicId(t, "o")
diff --git a/internal/iam/repository_user_test.go b/internal/iam/repository_user_test.go
index d016d2947..d7148a8a5 100644
--- a/internal/iam/repository_user_test.go
+++ b/internal/iam/repository_user_test.go
@@ -18,14 +18,7 @@ import (
 
 func TestRepository_CreateUser(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -117,14 +110,7 @@ func TestRepository_CreateUser(t *testing.T) {
 
 func TestRepository_UpdateUser(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -358,14 +344,7 @@ func TestRepository_UpdateUser(t *testing.T) {
 
 func TestRepository_DeleteUser(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -448,13 +427,7 @@ func TestRepository_DeleteUser(t *testing.T) {
 
 func TestRepository_ListUsers(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	const testLimit = 10
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
@@ -534,13 +507,7 @@ func TestRepository_ListUsers(t *testing.T) {
 
 func TestRepository_LookupUserWithLogin(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
diff --git a/internal/iam/resource_test.go b/internal/iam/resource_test.go
index 525e1e470..1d7870f8e 100644
--- a/internal/iam/resource_test.go
+++ b/internal/iam/resource_test.go
@@ -12,13 +12,7 @@ import (
 
 func Test_LookupScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := db.New(conn)
diff --git a/internal/iam/role_test.go b/internal/iam/role_test.go
index caf688a32..1b8e07ffd 100644
--- a/internal/iam/role_test.go
+++ b/internal/iam/role_test.go
@@ -18,13 +18,7 @@ import (
 
 func TestNewRole(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 	id := testId(t)
 
@@ -100,13 +94,7 @@ func TestNewRole(t *testing.T) {
 
 func Test_RoleCreate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 	type args struct {
 		role *Role
@@ -215,13 +203,7 @@ func Test_RoleCreate(t *testing.T) {
 
 func Test_RoleUpdate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	id := testId(t)
 	org, proj := TestScopes(t, conn)
 	rw := db.New(conn)
@@ -389,14 +371,7 @@ func Test_RoleUpdate(t *testing.T) {
 
 func Test_RoleDelete(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	id := testId(t)
 	org, _ := TestScopes(t, conn)
@@ -465,13 +440,7 @@ func TestRole_ResourceType(t *testing.T) {
 
 func TestRole_GetScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, proj := TestScopes(t, conn)
 
 	t.Run("valid-org", func(t *testing.T) {
@@ -494,13 +463,7 @@ func TestRole_GetScope(t *testing.T) {
 
 func TestRole_Clone(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	t.Run("valid", func(t *testing.T) {
 		assert := assert.New(t)
diff --git a/internal/iam/scope_test.go b/internal/iam/scope_test.go
index b02028fbb..8cce62057 100644
--- a/internal/iam/scope_test.go
+++ b/internal/iam/scope_test.go
@@ -15,13 +15,7 @@ import (
 
 func Test_NewScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-org-with-project", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := db.New(conn)
@@ -58,13 +52,7 @@ func Test_NewScope(t *testing.T) {
 }
 func Test_ScopeCreate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := db.New(conn)
@@ -106,13 +94,7 @@ func Test_ScopeCreate(t *testing.T) {
 
 func Test_ScopeUpdate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := db.New(conn)
@@ -136,13 +118,7 @@ func Test_ScopeUpdate(t *testing.T) {
 }
 func Test_ScopeGetScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
 		w := db.New(conn)
@@ -187,13 +163,7 @@ func TestScope_ResourceType(t *testing.T) {
 
 func TestScope_Clone(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	t.Run("valid", func(t *testing.T) {
 		assert := assert.New(t)
 		s, _ := TestScopes(t, conn)
diff --git a/internal/iam/testing_test.go b/internal/iam/testing_test.go
index b347a47a5..b18d89f05 100644
--- a/internal/iam/testing_test.go
+++ b/internal/iam/testing_test.go
@@ -11,14 +11,7 @@ import (
 
 func Test_testOrg(t *testing.T) {
 	assert := assert.New(t)
-
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(err)
-		err = conn.Close()
-		assert.NoError(err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	id := testId(t)
 
 	org := testOrg(t, conn, id, id)
@@ -30,13 +23,7 @@ func Test_testOrg(t *testing.T) {
 func Test_testProj(t *testing.T) {
 	assert := assert.New(t)
 
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(err)
-		err = conn.Close()
-		assert.NoError(err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	id := testId(t)
 
 	org := testOrg(t, conn, id, id)
@@ -59,14 +46,7 @@ func Test_testPublicId(t *testing.T) {
 }
 func Test_TestScopes(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(err)
-		err = conn.Close()
-		assert.NoError(err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	org, prj := TestScopes(t, conn)
 
 	require.NotNil(org)
@@ -78,13 +58,7 @@ func Test_TestScopes(t *testing.T) {
 func Test_TestUser(t *testing.T) {
 	t.Helper()
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(err)
-		err = conn.Close()
-		assert.NoError(err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 
 	require.NotNil(org)
@@ -98,13 +72,7 @@ func Test_TestUser(t *testing.T) {
 func Test_TestRole(t *testing.T) {
 	t.Helper()
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(err)
-		err = conn.Close()
-		assert.NoError(err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	id := testId(t)
 	org, proj := TestScopes(t, conn)
 	role := TestRole(t, conn, org.PublicId, WithDescription(id), WithName(id))
diff --git a/internal/iam/user_test.go b/internal/iam/user_test.go
index 884a31149..4ef750920 100644
--- a/internal/iam/user_test.go
+++ b/internal/iam/user_test.go
@@ -15,13 +15,7 @@ import (
 
 func TestNewUser(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	id := testId(t)
 
@@ -81,13 +75,7 @@ func TestNewUser(t *testing.T) {
 
 func Test_UserCreate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	id := testId(t)
 	t.Run("valid-user", func(t *testing.T) {
@@ -124,14 +112,7 @@ func Test_UserCreate(t *testing.T) {
 
 func Test_UserUpdate(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
 	repo, err := NewRepository(rw, rw, wrapper)
@@ -242,13 +223,7 @@ func Test_UserUpdate(t *testing.T) {
 
 func Test_UserDelete(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 
 	rw := db.New(conn)
 	wrapper := db.TestWrapper(t)
@@ -298,14 +273,7 @@ func Test_UserDelete(t *testing.T) {
 
 func Test_UserGetScope(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
-
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 	t.Run("valid-scope", func(t *testing.T) {
 		assert, require := assert.New(t), require.New(t)
@@ -320,13 +288,7 @@ func Test_UserGetScope(t *testing.T) {
 
 func TestUser_Clone(t *testing.T) {
 	t.Parallel()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	defer func() {
-		err := cleanup()
-		assert.NoError(t, err)
-		err = conn.Close()
-		assert.NoError(t, err)
-	}()
+	conn, _ := db.TestSetup(t, "postgres")
 	org, _ := TestScopes(t, conn)
 
 	t.Run("valid", func(t *testing.T) {
diff --git a/internal/servers/controller/handlers/groups/group_service_test.go b/internal/servers/controller/handlers/groups/group_service_test.go
index 356fdaf7e..8b50b706b 100644
--- a/internal/servers/controller/handlers/groups/group_service_test.go
+++ b/internal/servers/controller/handlers/groups/group_service_test.go
@@ -26,15 +26,7 @@ import (
 // Creates an org scoped group and a project scoped group.
 func createDefaultGroupsAndRepo(t *testing.T) (*iam.Group, *iam.Group, func() (*iam.Repository, error)) {
 	t.Helper()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
@@ -144,15 +136,7 @@ func TestGet(t *testing.T) {
 
 func TestList(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
diff --git a/internal/servers/controller/handlers/host_catalogs/host_catalog_service_test.go b/internal/servers/controller/handlers/host_catalogs/host_catalog_service_test.go
index 683619a07..c55f50909 100644
--- a/internal/servers/controller/handlers/host_catalogs/host_catalog_service_test.go
+++ b/internal/servers/controller/handlers/host_catalogs/host_catalog_service_test.go
@@ -26,15 +26,7 @@ import (
 func createDefaultHostCatalogAndRepo(t *testing.T) (*static.HostCatalog, *iam.Scope, func() (*static.Repository, error)) {
 	t.Helper()
 	require := require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("failed closing the gorm db: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("failed to clean up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	_, pRes := iam.TestScopes(t, conn)
 
 	wrap := db.TestWrapper(t)
diff --git a/internal/servers/controller/handlers/organizations/organization_service_test.go b/internal/servers/controller/handlers/organizations/organization_service_test.go
index 63884d3dc..da640aa5c 100644
--- a/internal/servers/controller/handlers/organizations/organization_service_test.go
+++ b/internal/servers/controller/handlers/organizations/organization_service_test.go
@@ -23,15 +23,7 @@ import (
 
 func createDefaultOrganizationAndRepo(t *testing.T) (*iam.Scope, func() (*iam.Repository, error)) {
 	t.Helper()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
@@ -112,15 +104,7 @@ func TestGet(t *testing.T) {
 
 func TestList(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
diff --git a/internal/servers/controller/handlers/projects/project_service_test.go b/internal/servers/controller/handlers/projects/project_service_test.go
index 07a01da39..60cbd31ad 100644
--- a/internal/servers/controller/handlers/projects/project_service_test.go
+++ b/internal/servers/controller/handlers/projects/project_service_test.go
@@ -26,15 +26,7 @@ import (
 
 func createDefaultProjectAndRepo(t *testing.T) (*iam.Scope, func() (*iam.Repository, error)) {
 	t.Helper()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
@@ -116,15 +108,7 @@ func TestGet(t *testing.T) {
 
 func TestList(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
diff --git a/internal/servers/controller/handlers/roles/role_service_test.go b/internal/servers/controller/handlers/roles/role_service_test.go
index 322bc848c..12d236bd1 100644
--- a/internal/servers/controller/handlers/roles/role_service_test.go
+++ b/internal/servers/controller/handlers/roles/role_service_test.go
@@ -25,15 +25,7 @@ import (
 
 func createDefaultRolesAndRepo(t *testing.T) (*iam.Role, *iam.Role, func() (*iam.Repository, error)) {
 	t.Helper()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
@@ -143,15 +135,7 @@ func TestGet(t *testing.T) {
 
 func TestList(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
diff --git a/internal/servers/controller/handlers/users/user_service_test.go b/internal/servers/controller/handlers/users/user_service_test.go
index ebedfb4de..2d6e16ed7 100644
--- a/internal/servers/controller/handlers/users/user_service_test.go
+++ b/internal/servers/controller/handlers/users/user_service_test.go
@@ -25,15 +25,7 @@ import (
 
 func createDefaultUserAndRepo(t *testing.T) (*iam.User, func() (*iam.Repository, error)) {
 	t.Helper()
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {
@@ -110,15 +102,7 @@ func TestGet(t *testing.T) {
 
 func TestList(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
-	cleanup, conn, _ := db.TestSetup(t, "postgres")
-	t.Cleanup(func() {
-		if err := conn.Close(); err != nil {
-			t.Errorf("Error when closing gorm DB: %v", err)
-		}
-		if err := cleanup(); err != nil {
-			t.Errorf("Error when cleaning up TestSetup: %v", err)
-		}
-	})
+	conn, _ := db.TestSetup(t, "postgres")
 	rw := db.New(conn)
 	wrap := db.TestWrapper(t)
 	repoFn := func() (*iam.Repository, error) {