Pushing test db cleanup up to where the database objects are created using t.Cleanup. (#166)
This commit is contained in:
1 parent
316b250a24
commit
bb4a185412
25 files changed
+110
-793
No files matched your search
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
+15
-111
@@ -24,16 +24,10 @@ import (
|
||||
)
|
||||
|
||||
func TestDb_Update(t *testing.T) {
|
||||
cleanup, db, _ := TestSetup(t, "postgres")
|
||||
db, _ := TestSetup(t, "postgres")
|
||||
now := ×tamp.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{})
|
||||
|
||||
+10
-3
@@ -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
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 := ×tamp.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)
|
||||
|
||||
@@ -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 := ×tamp.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")
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in new issue
Block a user