diff --git a/internal/iam/action_test.go b/internal/iam/action_test.go index e53ffe15f..81e7e34e3 100644 --- a/internal/iam/action_test.go +++ b/internal/iam/action_test.go @@ -9,8 +9,8 @@ import ( // Test_CrudActions provides unit tests for CrudActions() func Test_CrudActions(t *testing.T) { t.Parallel() - assert := assert.New(t) t.Run("valid", func(t *testing.T) { + assert := assert.New(t) a := CrudlActions() assert.Equal(a[ActionCreate.String()], ActionCreate) assert.Equal(a[ActionUpdate.String()], ActionUpdate) @@ -18,6 +18,7 @@ func Test_CrudActions(t *testing.T) { assert.Equal(a[ActionDelete.String()], ActionDelete) }) t.Run("invalid", func(t *testing.T) { + assert := assert.New(t) a := CrudlActions() action, ok := a["invalid"] assert.Equal(ok, false) @@ -28,8 +29,8 @@ func Test_CrudActions(t *testing.T) { // Test_CrudlActions provides unit tests for CrudlActions() func Test_CrudlActions(t *testing.T) { t.Parallel() - assert := assert.New(t) t.Run("valid", func(t *testing.T) { + assert := assert.New(t) a := CrudlActions() assert.Equal(a[ActionList.String()], ActionList) assert.Equal(a[ActionCreate.String()], ActionCreate) @@ -38,6 +39,7 @@ func Test_CrudlActions(t *testing.T) { assert.Equal(a[ActionDelete.String()], ActionDelete) }) t.Run("invalid", func(t *testing.T) { + assert := assert.New(t) a := CrudlActions() action, ok := a["invalid"] assert.Equal(ok, false) diff --git a/internal/iam/options_test.go b/internal/iam/options_test.go index f80e219f1..5ba76875d 100644 --- a/internal/iam/options_test.go +++ b/internal/iam/options_test.go @@ -9,14 +9,15 @@ import ( // Test_GetOpts provides unit tests for GetOpts and all the options func Test_GetOpts(t *testing.T) { t.Parallel() - assert := assert.New(t) t.Run("WithName", func(t *testing.T) { + assert := assert.New(t) opts := getOpts(WithName("test")) testOpts := getDefaultOptions() testOpts.withName = "test" assert.Equal(opts, testOpts) }) t.Run("withScope", func(t *testing.T) { + assert := assert.New(t) s, err := NewOrganization() assert.NoError(err) assert.NotNil(s.Scope) @@ -27,6 +28,7 @@ func Test_GetOpts(t *testing.T) { assert.Equal(opts, testOpts) }) t.Run("WithDescription", func(t *testing.T) { + assert := assert.New(t) opts := getOpts(WithDescription("test desc")) testOpts := getDefaultOptions() testOpts.withDescription = "test desc" diff --git a/internal/iam/repository_scope_test.go b/internal/iam/repository_scope_test.go index dcc402f1f..1e33ab73e 100644 --- a/internal/iam/repository_scope_test.go +++ b/internal/iam/repository_scope_test.go @@ -7,12 +7,12 @@ import ( "time" "github.com/golang/protobuf/ptypes" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" "github.com/hashicorp/watchtower/internal/db/timestamp" iam_store "github.com/hashicorp/watchtower/internal/iam/store" "github.com/hashicorp/watchtower/internal/oplog" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -20,86 +20,81 @@ func Test_Repository_CreateScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) s, err := NewOrganization(WithName(id)) - assert.NoError(err) + require.NoError(err) s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) + require.NoError(err) + require.NotNil(s) assert.NotEmpty(s.GetPublicId()) assert.Equal(s.GetName(), id) foundScope, err := repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundScope, s)) err = db.TestVerifyOplog(t, rw, s.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_CREATE), db.WithCreateNotBefore(10*time.Second)) assert.NoError(err) }) t.Run("dup-org-names", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) s, err := NewOrganization(WithName(id)) - assert.NoError(err) + require.NoError(err) s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) + require.NoError(err) + require.NotNil(s) assert.NotEmpty(s.GetPublicId()) assert.Equal(s.GetName(), id) s2, err := NewOrganization(WithName(id)) - assert.NoError(err) + require.NoError(err) s2, err = repo.CreateScope(context.Background(), s2) - assert.Error(err) + require.Error(err) assert.Nil(s2) }) t.Run("dup-proj-names", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) s, err := NewOrganization(WithName(id)) - assert.NoError(err) + require.NoError(err) s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) + require.NoError(err) + require.NotNil(s) assert.NotEmpty(s.GetPublicId()) assert.Equal(s.GetName(), id) p, err := NewProject(s.PublicId, WithName(id)) - assert.NoError(err) + require.NoError(err) p, err = repo.CreateScope(context.Background(), p) - assert.NoError(err) - assert.NotEmpty(p.PublicId) + require.NoError(err) + require.NotEmpty(p.PublicId) p2, err := NewProject(s.PublicId, WithName(id)) - assert.NoError(err) + require.NoError(err) p2, err = repo.CreateScope(context.Background(), p2) assert.Error(err) assert.Nil(p2) @@ -110,51 +105,41 @@ func Test_Repository_UpdateScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) - s, err := NewOrganization(WithName(id)) - assert.NoError(err) - s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) - assert.NotEmpty(s.GetPublicId()) - assert.Equal(s.GetName(), id) + s := testOrg(t, conn, id, "") + assert.Equal(id, s.Name) foundScope, err := repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundScope, s)) err = db.TestVerifyOplog(t, rw, s.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_CREATE), db.WithCreateNotBefore(10*time.Second)) - assert.NoError(err) + require.NoError(err) s.Name = id s.Description = "desc-id" // not in the field mask paths s, updatedRows, err := repo.UpdateScope(context.Background(), s, []string{"Name"}) - assert.NoError(err) + require.NoError(err) assert.Equal(1, updatedRows) - assert.NotNil(s) + require.NotNil(s) assert.Equal(s.GetName(), id) assert.Empty(foundScope.GetDescription()) // should be "" after update in db foundScope, err = repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.Equal(foundScope.GetPublicId(), s.GetPublicId()) assert.Empty(foundScope.GetDescription()) @@ -162,30 +147,25 @@ func Test_Repository_UpdateScope(t *testing.T) { assert.NoError(err) }) t.Run("bad-parent-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) - s, err := NewOrganization(WithName(id)) - assert.NoError(err) - s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) - assert.NotEmpty(s.GetPublicId()) - assert.Equal(s.GetName(), id) + s := testOrg(t, conn, id, "") + assert.Equal(id, s.Name) project, err := NewProject(s.PublicId) - assert.NoError(err) + require.NoError(err) project, err = repo.CreateScope(context.Background(), project) - assert.NoError(err) - assert.NotNil(project) + require.NoError(err) + require.NotNil(project) project.ParentId = project.PublicId project, updatedRows, err := repo.UpdateScope(context.Background(), project, []string{"ParentId"}) - assert.Error(err) + require.Error(err) assert.Nil(project) assert.Equal(0, updatedRows) assert.Equal("update scope: you cannot change a scope's parent: invalid field mask", err.Error()) @@ -196,39 +176,29 @@ func Test_Repository_LookupScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) t.Run("found-and-not-found", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) - s, err := NewOrganization(WithName(id)) - assert.NoError(err) - s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) - assert.NotEmpty(s.GetPublicId()) + s := testOrg(t, conn, id, "") + require.NotEmpty(s.GetPublicId()) assert.Equal(s.GetName(), id) foundScope, err := repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundScope, s)) - invalidId, err := uuid.GenerateUUID() - assert.NoError(err) + invalidId := testId(t) notFoundById, err := repo.LookupScope(context.Background(), invalidId) assert.NoError(err) assert.Nil(notFoundById) @@ -239,52 +209,42 @@ func Test_Repository_DeleteScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + assert.NoError(t, err) t.Run("valid-with-public-id", func(t *testing.T) { - s, err := NewOrganization() - assert.NoError(err) - s, err = repo.CreateScope(context.Background(), s) - assert.NoError(err) - assert.NotNil(s) - assert.NotEmpty(s.GetPublicId()) - + assert, require := assert.New(t), require.New(t) + s, _ := TestScopes(t, conn) foundScope, err := repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.Equal(foundScope.GetPublicId(), s.GetPublicId()) rowsDeleted, err := repo.DeleteScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.Equal(1, rowsDeleted) err = db.TestVerifyOplog(t, rw, s.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_DELETE), db.WithCreateNotBefore(10*time.Second)) assert.NoError(err) foundScope, err = repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.Nil(foundScope) }) t.Run("valid-with-bad-id", func(t *testing.T) { - invalidId, err := uuid.GenerateUUID() - assert.NoError(err) + assert, require := assert.New(t), require.New(t) + invalidId := testId(t) foundScope, err := repo.LookupScope(context.Background(), invalidId) - assert.NoError(err) - assert.Nil(foundScope) + require.NoError(err) + require.Nil(foundScope) rowsDeleted, err := repo.DeleteScope(context.Background(), invalidId) - assert.NoError(err) // no error is expected if the resource isn't in the db + require.NoError(err) // no error is expected if the resource isn't in the db assert.Equal(0, rowsDeleted) }) } @@ -294,14 +254,10 @@ func TestRepository_UpdateScope(t *testing.T) { now := ×tamp.Timestamp{Timestamp: ptypes.TimestampNow()} id := testId(t) defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() rw := db.New(conn) wrapper := db.TestWrapper(t) @@ -460,7 +416,7 @@ func TestRepository_UpdateScope(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) r := &Repository{ reader: rw, writer: rw, @@ -472,12 +428,12 @@ func TestRepository_UpdateScope(t *testing.T) { } updatedScope, rowsUpdated, err := r.UpdateScope(context.Background(), tt.args.scope, tt.args.fieldMaskPaths, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Equal(tt.wantUpdatedRows, rowsUpdated) assert.Equal(tt.wantErrMsg, err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantUpdatedRows, rowsUpdated) if tt.wantUpdatedRows > 0 { err = db.TestVerifyOplog(t, rw, org.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second)) @@ -491,7 +447,7 @@ func TestRepository_UpdateScope(t *testing.T) { where = fmt.Sprintf("%s and %s is null", where, f) } err = rw.LookupWhere(context.Background(), &foundScope, where, org.PublicId) - assert.NoError(err) + require.NoError(err) assert.Equal(org.PublicId, foundScope.PublicId) assert.Equal(tt.wantName, foundScope.Name) assert.Equal(tt.wantDescription, foundScope.Description) @@ -500,7 +456,7 @@ func TestRepository_UpdateScope(t *testing.T) { }) } t.Run("dup-name", func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) r := &Repository{ reader: rw, writer: rw, @@ -511,7 +467,7 @@ func TestRepository_UpdateScope(t *testing.T) { org2 := testOrg(t, conn, "dup-"+id, id) org2.Name = id updatedScope, rowsUpdated, err := r.UpdateScope(context.Background(), org2, []string{"Name"}) - assert.Error(err) + require.Error(err) assert.Equal(0, rowsUpdated, "updated rows should be 0") assert.Nil(updatedScope, "scope should be nil") }) diff --git a/internal/iam/repository_test.go b/internal/iam/repository_test.go index e71bbf531..8c9f7b1e1 100644 --- a/internal/iam/repository_test.go +++ b/internal/iam/repository_test.go @@ -3,19 +3,18 @@ package iam import ( "context" "fmt" - "reflect" "testing" "time" "github.com/golang/protobuf/ptypes" wrapping "github.com/hashicorp/go-kms-wrapping" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" "github.com/hashicorp/watchtower/internal/db/timestamp" iam_store "github.com/hashicorp/watchtower/internal/iam/store" "github.com/hashicorp/watchtower/internal/oplog" "github.com/hashicorp/watchtower/internal/oplog/store" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -23,15 +22,10 @@ func TestNewRepository(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() rw := db.New(conn) wrapper := db.TestWrapper(t) @@ -97,17 +91,15 @@ func TestNewRepository(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) got, err := NewRepository(tt.args.r, tt.args.w, tt.args.wrapper) - if (err != nil) != tt.wantErr { - t.Errorf("NewRepository() error = %v, wantErr %v", err, tt.wantErr) + if tt.wantErr { + require.Error(err) + assert.Equal(err.Error(), tt.wantErrString) return } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("NewRepository() = %v, want %v", got, tt.want) - } - if err != nil { - assert.Equal(err.Error(), tt.wantErrString) - } + require.NoError(err) + assert.Equal(tt.want, got) }) } } @@ -115,51 +107,47 @@ func Test_Repository_create(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + id := testId(t) s, err := NewOrganization(WithName("fname-" + id)) assert.NoError(err) retScope, err := repo.create(context.Background(), s) - assert.NoError(err) - assert.NotNil(retScope) + require.NoError(err) + require.NotNil(retScope) assert.NotEmpty(retScope.GetPublicId()) assert.Equal(retScope.GetName(), "fname-"+id) foundScope, err := repo.LookupScope(context.Background(), s.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundScope, retScope.(*Scope))) var metadata store.Metadata err = conn.Where("key = ? and value = ?", "resource-public-id", s.PublicId).First(&metadata).Error - assert.NoError(err) + require.NoError(err) var foundEntry oplog.Entry err = conn.Where("id = ?", metadata.EntryId).First(&foundEntry).Error assert.NoError(err) }) t.Run("nil-resource", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) resource, err := repo.create(context.Background(), nil) - assert.NotNil(err) + require.Error(err) assert.Nil(resource) assert.Equal(err.Error(), "error creating resource that is nil") }) @@ -169,44 +157,35 @@ func Test_Repository_delete(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-org", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) - s, err := NewOrganization() - assert.NoError(err) - retScope, err := repo.create(context.Background(), s) - assert.NoError(err) - assert.NotNil(retScope) - assert.NotEmpty(retScope.GetPublicId()) - assert.Equal(retScope.GetName(), "") + s, _ := TestScopes(t, conn) rowsDeleted, err := repo.delete(context.Background(), s) - assert.NoError(err) + require.NoError(err) assert.Equal(1, rowsDeleted) err = db.TestVerifyOplog(t, rw, s.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_DELETE), db.WithCreateNotBefore(5*time.Second)) - assert.NoError(err) + require.NoError(err) }) t.Run("nil-resource", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) deletedRows, err := repo.delete(context.Background(), nil, nil) - assert.NotNil(err) + assert.Error(err) assert.Equal(0, deletedRows) assert.Equal(err.Error(), "error deleting resource that is nil") }) @@ -217,14 +196,10 @@ func TestRepository_update(t *testing.T) { now := ×tamp.Timestamp{Timestamp: ptypes.TimestampNow()} id := testId(t) defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() rw := db.New(conn) wrapper := db.TestWrapper(t) @@ -341,7 +316,7 @@ func TestRepository_update(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) r := &Repository{ reader: rw, writer: rw, @@ -353,15 +328,15 @@ func TestRepository_update(t *testing.T) { } updatedResource, rowsUpdated, err := r.update(context.Background(), tt.args.resource, tt.args.fieldMaskPaths, tt.args.setToNullPaths, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Equal(tt.wantUpdatedRows, rowsUpdated) assert.Equal(tt.wantErrMsg, err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantUpdatedRows, rowsUpdated) err = db.TestVerifyOplog(t, rw, org.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second)) - assert.NoError(err) + require.NoError(err) foundResource := allocScope() foundResource.PublicId = updatedResource.GetPublicId() @@ -370,7 +345,7 @@ func TestRepository_update(t *testing.T) { where = fmt.Sprintf("%s and %s is null", where, f) } err = rw.LookupWhere(context.Background(), &foundResource, where, tt.args.resource.GetPublicId()) - assert.NoError(err) + require.NoError(err) assert.Equal(tt.args.resource.GetPublicId(), foundResource.GetPublicId()) assert.Equal(tt.wantName, foundResource.GetName()) assert.Equal(tt.wantDescription, foundResource.GetDescription()) diff --git a/internal/iam/repository_user_test.go b/internal/iam/repository_user_test.go index 432dbe129..c6698d6fd 100644 --- a/internal/iam/repository_user_test.go +++ b/internal/iam/repository_user_test.go @@ -8,11 +8,11 @@ import ( "testing" "time" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" dbassert "github.com/hashicorp/watchtower/internal/db/assert" "github.com/hashicorp/watchtower/internal/oplog" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -20,20 +20,17 @@ func TestRepository_CreateUser(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - a := assert.New(t) - defer conn.Close() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - a.NoError(err) - id, err := uuid.GenerateUUID() - a.NoError(err) - + require.NoError(t, err) + id := testId(t) org, _ := TestScopes(t, conn) type args struct { @@ -86,16 +83,15 @@ func TestRepository_CreateUser(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) - + assert, require := assert.New(t), require.New(t) if tt.wantDup { dup, err := repo.CreateUser(context.Background(), tt.args.user, tt.args.opt...) - assert.NoError(err) - assert.NotNil(dup) + require.NoError(err) + require.NotNil(dup) } u, err := repo.CreateUser(context.Background(), tt.args.user, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Nil(u) switch tt.name { case "dup-name": @@ -105,12 +101,12 @@ func TestRepository_CreateUser(t *testing.T) { } return } - assert.NoError(err) + require.NoError(err) assert.NotNil(u.CreateTime) assert.NotNil(u.UpdateTime) foundUser, err := repo.LookupUser(context.Background(), u.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundUser, u)) err = db.TestVerifyOplog(t, rw, u.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_CREATE), db.WithCreateNotBefore(10*time.Second)) @@ -123,20 +119,17 @@ func TestRepository_UpdateUser(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - a := assert.New(t) - defer conn.Close() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - a.NoError(err) - id, err := uuid.GenerateUUID() - a.NoError(err) - + require.NoError(t, err) + id := testId(t) org, proj := TestScopes(t, conn) pubId := func(s string) *string { return &s } @@ -304,12 +297,12 @@ func TestRepository_UpdateUser(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) if tt.wantDup { u := TestUser(t, conn, org.PublicId, tt.newUserOpts...) u.Name = tt.args.name _, _, err := repo.UpdateUser(context.Background(), u, tt.args.fieldMaskPaths, tt.args.opt...) - assert.NoError(err) + require.NoError(err) } u := TestUser(t, conn, org.PublicId, tt.newUserOpts...) @@ -325,7 +318,7 @@ func TestRepository_UpdateUser(t *testing.T) { userAfterUpdate, updatedRows, err := repo.UpdateUser(context.Background(), &updateUser, tt.args.fieldMaskPaths, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) if tt.wantIsErr != nil { assert.True(errors.Is(err, db.ErrRecordNotFound)) } @@ -338,18 +331,17 @@ func TestRepository_UpdateUser(t *testing.T) { assert.Equal(tt.wantErrMsg, err.Error()) } err = db.TestVerifyOplog(t, rw, u.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second)) - assert.Error(err) + require.Error(err) assert.Equal("record not found", err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantRowsUpdate, updatedRows) assert.NotEqual(u.UpdateTime, userAfterUpdate.UpdateTime) foundUser, err := repo.LookupUser(context.Background(), u.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(userAfterUpdate, foundUser)) - conn.LogMode(true) dbassert := dbassert.New(t, rw) if tt.args.name == "" { dbassert.IsNull(foundUser, "name") @@ -357,7 +349,6 @@ func TestRepository_UpdateUser(t *testing.T) { if tt.args.description == "" { dbassert.IsNull(foundUser, "description") } - conn.LogMode(false) err = db.TestVerifyOplog(t, rw, u.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second)) assert.NoError(err) @@ -369,17 +360,16 @@ func TestRepository_DeleteUser(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - a := assert.New(t) - defer conn.Close() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - a.NoError(err) + require.NoError(t, err) org, _ := TestScopes(t, conn) type args struct { @@ -418,9 +408,9 @@ func TestRepository_DeleteUser(t *testing.T) { args: args{ user: func() *User { u, err := NewUser(org.PublicId) - a.NoError(err) + require.NoError(t, err) id, err := newUserId() - a.NoError(err) + require.NoError(t, err) u.PublicId = id return u }(), @@ -432,26 +422,26 @@ func TestRepository_DeleteUser(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) deletedRows, err := repo.DeleteUser(context.Background(), tt.args.user.PublicId, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Equal(0, deletedRows) assert.True(strings.HasPrefix(err.Error(), tt.wantErrMsg)) err = db.TestVerifyOplog(t, rw, tt.args.user.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_DELETE), db.WithCreateNotBefore(10*time.Second)) - assert.Error(err) + require.Error(err) assert.Equal("record not found", err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantRowsDeleted, deletedRows) foundUser, err := repo.LookupUser(context.Background(), tt.args.user.PublicId) - assert.Error(err) + require.Error(err) assert.Nil(foundUser) assert.True(errors.Is(err, db.ErrRecordNotFound)) err = db.TestVerifyOplog(t, rw, tt.args.user.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_DELETE), db.WithCreateNotBefore(10*time.Second)) - assert.NoError(err) + require.NoError(err) }) } } diff --git a/internal/iam/resource_test.go b/internal/iam/resource_test.go index 643ff0f04..d9c203a16 100644 --- a/internal/iam/resource_test.go +++ b/internal/iam/resource_test.go @@ -6,6 +6,7 @@ import ( "github.com/hashicorp/watchtower/internal/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -13,33 +14,35 @@ func Test_LookupScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - assert := assert.New(t) - defer conn.Close() t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) org, _ := TestScopes(t, conn) user := TestUser(t, conn, org.PublicId) foundScope, err := LookupScope(context.Background(), w, user) - assert.NoError(err) + require.NoError(err) assert.Equal(foundScope.PublicId, user.ScopeId) user2 := allocUser() user2.PublicId = user.PublicId foundScope, err = LookupScope(context.Background(), w, user) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(foundScope, org)) }) t.Run("bad-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) org, _ := TestScopes(t, conn) user := TestUser(t, conn, org.PublicId) s, err := LookupScope(context.Background(), nil, user) + require.Error(err) assert.Nil(s) assert.Equal("error reader is nil for LookupScope", err.Error()) @@ -51,6 +54,5 @@ func Test_LookupScope(t *testing.T) { s, err = LookupScope(context.Background(), w, &user2) assert.Nil(s) assert.Equal("error resource has an unset public id", err.Error()) - }) } diff --git a/internal/iam/scope_test.go b/internal/iam/scope_test.go index 8a97643e2..14d7358d8 100644 --- a/internal/iam/scope_test.go +++ b/internal/iam/scope_test.go @@ -4,9 +4,9 @@ import ( "context" "testing" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -14,43 +14,40 @@ func Test_NewScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-org-with-project", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) + require.NoError(err) + require.NotNil(s.Scope) err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + require.NoError(err) + require.NotEmpty(s.PublicId) - id, err := uuid.GenerateUUID() - assert.NoError(err) + id := testId(t) projScope, err := NewProject(s.PublicId, WithDescription(id)) - assert.NoError(err) - assert.NotNil(projScope.Scope) + require.NoError(err) + require.NotNil(projScope.Scope) assert.Equal(projScope.GetParentId(), s.PublicId) assert.Equal(projScope.GetDescription(), id) }) t.Run("unknown-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) s, err := newScope(UnknownScope) - assert.NotNil(err) - assert.Nil(s) + require.Error(err) + require.Nil(s) assert.Equal(err.Error(), "error unknown scope type for new scope") }) t.Run("proj-scope-with-no-org", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) s, err := NewProject("") - assert.NotNil(err) - assert.Nil(s) + require.Error(err) + require.Nil(s) assert.Equal(err.Error(), "error creating new project: error project scope parent id is unset") }) } @@ -58,45 +55,40 @@ func Test_ScopeCreate(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) + require.NoError(err) + require.NotNil(s.Scope) err = w.Create(context.Background(), s) - assert.NoError(err) + require.NoError(err) assert.NotEmpty(s.PublicId) }) t.Run("valid-with-parent", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) + require.NoError(err) + require.NotNil(s.Scope) err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(err) + require.NotEmpty(s.PublicId) + id := testId(t) project, err := NewProject(s.PublicId, WithDescription(id)) - assert.NoError(err) - assert.NotNil(project.Scope) + require.NoError(err) + require.NotNil(project.Scope) assert.Equal(project.Scope.ParentId, s.PublicId) assert.Equal(project.GetDescription(), id) err = w.Create(context.Background(), project) - assert.NoError(err) + require.NoError(err) assert.Equal(project.ParentId, s.PublicId) }) } @@ -105,44 +97,29 @@ func Test_ScopeUpdate(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s, _ := TestScopes(t, conn) - id, err := uuid.GenerateUUID() - assert.NoError(err) - s.Name = id + s.Name = testId(t) updatedRows, err := w.Update(context.Background(), s, []string{"Name"}, nil) - assert.NoError(err) + require.NoError(err) assert.Equal(1, updatedRows) }) t.Run("type-update-not-allowed", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s, _ := TestScopes(t, conn) s.Type = ProjectScope.String() updatedRows, err := w.Update(context.Background(), s, []string{"Type"}, nil) - assert.NotNil(err) + require.Error(err) assert.Equal(0, updatedRows) }) } @@ -150,47 +127,30 @@ func Test_ScopeGetScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - foundScope, err := s.GetScope(context.Background(), w) - assert.NoError(err) + org, proj := TestScopes(t, conn) + foundScope, err := org.GetScope(context.Background(), w) + require.NoError(err) assert.Nil(foundScope) - project, err := NewProject(s.PublicId) - assert.NoError(err) - assert.NotNil(project.Scope) - assert.Equal(project.ParentId, s.PublicId) - err = w.Create(context.Background(), project) - assert.NoError(err) - - projectOrg, err := project.GetScope(context.Background(), w) - assert.NoError(err) + projectOrg, err := proj.GetScope(context.Background(), w) + require.NoError(err) assert.NotNil(projectOrg) - assert.Equal(projectOrg.PublicId, project.ParentId) + assert.Equal(projectOrg.PublicId, proj.ParentId) p := allocScope() - p.PublicId = project.PublicId + p.PublicId = proj.PublicId p.Type = ProjectScope.String() projectOrg, err = p.GetScope(context.Background(), w) - assert.NoError(err) - assert.Equal(s.PublicId, projectOrg.PublicId) + require.NoError(err) + assert.Equal(org.PublicId, projectOrg.PublicId) }) } @@ -209,55 +169,30 @@ func TestScope_Actions(t *testing.T) { } func TestScope_ResourceType(t *testing.T) { - assert := assert.New(t) o, err := NewOrganization() - assert.NoError(err) - ty := o.ResourceType() - assert.Equal(ty, ResourceTypeOrganization) + require.NoError(t, err) + assert.Equal(t, o.ResourceType(), ResourceTypeOrganization) } func TestScope_Clone(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer func() { - if err := conn.Close(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() t.Run("valid", func(t *testing.T) { - w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + assert := assert.New(t) + s, _ := TestScopes(t, conn) cp := s.Clone() assert.True(proto.Equal(cp.(*Scope).Scope, s.Scope)) }) t.Run("not-equal", func(t *testing.T) { - w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - s2, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s2.Scope) - err = w.Create(context.Background(), s2) - assert.NoError(err) - assert.NotEmpty(s2.PublicId) - + assert := assert.New(t) + s, _ := TestScopes(t, conn) + s2, _ := TestScopes(t, conn) cp := s.Clone() assert.True(!proto.Equal(cp.(*Scope).Scope, s2.Scope)) }) diff --git a/internal/iam/testing.go b/internal/iam/testing.go index a6a750507..d322a8b9f 100644 --- a/internal/iam/testing.go +++ b/internal/iam/testing.go @@ -8,78 +8,79 @@ import ( "github.com/hashicorp/watchtower/internal/db" "github.com/jinzhu/gorm" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) // TestScopes creates an organization and project suitable for testing. func TestScopes(t *testing.T, conn *gorm.DB) (org *Scope, prj *Scope) { t.Helper() - assert := assert.New(t) + require := require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) org, err = NewOrganization() + require.NoError(err) org, err = repo.CreateScope(context.Background(), org) - assert.NoError(err) - assert.NotNil(org) - assert.NotEmpty(org.GetPublicId()) + require.NoError(err) + require.NotNil(org) + require.NotEmpty(org.GetPublicId()) prj, err = NewProject(org.GetPublicId()) + require.NoError(err) prj, err = repo.CreateScope(context.Background(), prj) - assert.NoError(err) - assert.NotNil(prj) - assert.NotEmpty(prj.GetPublicId()) + require.NoError(err) + require.NotNil(prj) + require.NotEmpty(prj.GetPublicId()) return } func testOrg(t *testing.T, conn *gorm.DB, name, description string) (org *Scope) { t.Helper() - assert := assert.New(t) + require := require.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) o, err := NewOrganization(WithDescription(description), WithName(name)) - assert.NoError(err) + require.NoError(err) o, err = repo.CreateScope(context.Background(), o) - assert.NoError(err) - assert.NotNil(o) - assert.NotEmpty(o.GetPublicId()) + require.NoError(err) + require.NotNil(o) + require.NotEmpty(o.GetPublicId()) return o } func testId(t *testing.T) string { t.Helper() - assert := assert.New(t) id, err := uuid.GenerateUUID() - assert.NoError(err) + require.NoError(t, err) return id } func testPublicId(t *testing.T, prefix string) string { t.Helper() - assert := assert.New(t) publicId, err := db.NewPublicId(prefix) - assert.NoError(err) + require.NoError(t, err) return publicId } // TestUser creates a user suitable for testing. func TestUser(t *testing.T, conn *gorm.DB, orgId string, opt ...Option) *User { t.Helper() - assert := assert.New(t) + require := assert.New(t) rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - assert.NoError(err) + require.NoError(err) user, err := NewUser(orgId, opt...) - assert.NoError(err) + require.NoError(err) user, err = repo.CreateUser(context.Background(), user) - assert.NoError(err) - assert.NotEmpty(user.PublicId) + require.NoError(err) + require.NotEmpty(user.PublicId) return user } diff --git a/internal/iam/testing_test.go b/internal/iam/testing_test.go index f6d53e0f7..9aad59f1f 100644 --- a/internal/iam/testing_test.go +++ b/internal/iam/testing_test.go @@ -6,6 +6,7 @@ import ( "github.com/hashicorp/watchtower/internal/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func Test_testOrg(t *testing.T) { @@ -15,9 +16,7 @@ func Test_testOrg(t *testing.T) { defer func() { err := cleanup() assert.NoError(err) - }() - defer func() { - err := conn.Close() + err = conn.Close() assert.NoError(err) }() id := testId(t) @@ -35,49 +34,46 @@ func Test_testId(t *testing.T) { } func Test_testPublicId(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) id := testPublicId(t, "test") - assert.NotEmpty(id) + require.NotEmpty(id) assert.True(strings.HasPrefix(id, "test_")) } func Test_TestScopes(t *testing.T) { - assert := assert.New(t) - + assert, require := assert.New(t), require.New(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) - } + err := cleanup() + assert.NoError(err) + err = conn.Close() + assert.NoError(err) }() org, prj := TestScopes(t, conn) - assert.NotNil(org) + require.NotNil(org) assert.NotEmpty(org.GetPublicId()) - assert.NotNil(prj) + require.NotNil(prj) assert.NotEmpty(prj.GetPublicId()) } func Test_TestUser(t *testing.T) { t.Helper() - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(err) + err = conn.Close() + assert.NoError(err) }() - defer conn.Close() org, _ := TestScopes(t, conn) - assert.NotNil(org) + require.NotNil(org) assert.NotEmpty(org.GetPublicId()) user := TestUser(t, conn, org.PublicId) - assert.NotNil(user) + require.NotNil(user) assert.NotEmpty(user.PublicId) } diff --git a/internal/iam/user_test.go b/internal/iam/user_test.go index 7dad75b29..051f3bc46 100644 --- a/internal/iam/user_test.go +++ b/internal/iam/user_test.go @@ -5,9 +5,9 @@ import ( "errors" "testing" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -15,16 +15,13 @@ func TestNewUser(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - assert := assert.New(t) - defer conn.Close() org, _ := TestScopes(t, conn) - - id, err := uuid.GenerateUUID() - assert.NoError(err) + id := testId(t) type args struct { organizationPublicId string @@ -66,13 +63,14 @@ func TestNewUser(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) got, err := NewUser(tt.args.organizationPublicId, tt.args.opt...) if tt.wantErr { assert.Error(err) assert.Equal(tt.wantErrMsg, err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantName, got.Name) assert.Empty(got.PublicId) }) @@ -83,42 +81,41 @@ func Test_UserCreate(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - assert := assert.New(t) - defer conn.Close() org, _ := TestScopes(t, conn) - - id, err := uuid.GenerateUUID() - assert.NoError(err) + id := testId(t) t.Run("valid-user", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) user, err := NewUser(org.PublicId) - assert.NoError(err) + require.NoError(err) id, err := newUserId() - assert.NoError(err) + require.NoError(err) user.PublicId = id err = w.Create(context.Background(), user) - assert.NoError(err) - assert.NotEmpty(user.PublicId) + require.NoError(err) + require.NotEmpty(user.PublicId) foundUser := allocUser() foundUser.PublicId = user.PublicId err = w.LookupByPublicId(context.Background(), &foundUser) - assert.NoError(err) + require.NoError(err) assert.Equal(user, &foundUser) }) t.Run("bad-orgid", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) user, err := NewUser(id) - assert.NoError(err) + require.NoError(err) id, err := newUserId() - assert.NoError(err) + require.NoError(err) user.PublicId = id err = w.Create(context.Background(), user) - assert.Error(err) + require.Error(err) assert.Equal("create: vet for write failed scope is not found", err.Error()) }) } @@ -127,20 +124,17 @@ func Test_UserUpdate(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - a := assert.New(t) - defer conn.Close() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - a.NoError(err) - id, err := uuid.GenerateUUID() - a.NoError(err) - + require.NoError(t, err) + id := testId(t) org, proj := TestScopes(t, conn) type args struct { @@ -211,12 +205,12 @@ func Test_UserUpdate(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) if tt.wantDup { u := TestUser(t, conn, org.PublicId) u.Name = tt.args.name _, err := rw.Update(context.Background(), u, tt.args.fieldMaskPaths, nil) - assert.NoError(err) + require.NoError(err) } u := TestUser(t, conn, org.PublicId) @@ -229,16 +223,16 @@ func Test_UserUpdate(t *testing.T) { updatedRows, err := rw.Update(context.Background(), &updateUser, tt.args.fieldMaskPaths, nil) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Equal(0, updatedRows) assert.Equal(tt.wantErrMsg, err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantRowsUpdate, updatedRows) assert.NotEqual(u.UpdateTime, updateUser.UpdateTime) foundUser, err := repo.LookupUser(context.Background(), u.PublicId) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(updateUser, foundUser)) }) } @@ -248,19 +242,17 @@ func Test_UserDelete(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - a := assert.New(t) - defer conn.Close() rw := db.New(conn) wrapper := db.TestWrapper(t) repo, err := NewRepository(rw, rw, wrapper) - a.NoError(err) - id, err := uuid.GenerateUUID() - a.NoError(err) + require.NoError(t, err) + id := testId(t) org, _ := TestScopes(t, conn) tests := []struct { @@ -285,7 +277,7 @@ func Test_UserDelete(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assert := assert.New(t) + assert, require := assert.New(t), require.New(t) deleteUser := allocUser() deleteUser.PublicId = tt.user.GetPublicId() deletedRows, err := rw.Delete(context.Background(), &deleteUser) @@ -293,7 +285,7 @@ func Test_UserDelete(t *testing.T) { assert.Equal(tt.wantRowsDeleted, deletedRows) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantRowsDeleted, deletedRows) foundUser, err := repo.LookupUser(context.Background(), tt.user.GetPublicId()) assert.True(errors.Is(err, db.ErrRecordNotFound)) @@ -306,35 +298,19 @@ func Test_UserGetScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - defer conn.Close() - assert := assert.New(t) org, _ := TestScopes(t, conn) t.Run("valid-scope", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) - user, err := NewUser(org.PublicId) - assert.NoError(err) - id, err := newUserId() - assert.NoError(err) - user.PublicId = id - err = w.Create(context.Background(), user) - assert.NoError(err) - assert.NotEmpty(user.PublicId) - assert.Equal(user.ScopeId, org.PublicId) - - childScope, err := NewProject(org.PublicId) - assert.NoError(err) - assert.NotNil(childScope.Scope) - assert.Equal(childScope.GetParentId(), org.PublicId) - err = w.Create(context.Background(), childScope) - assert.NoError(err) - + user := TestUser(t, conn, org.PublicId) userScope, err := user.GetScope(context.Background(), w) - assert.NoError(err) + require.NoError(err) assert.True(proto.Equal(org, userScope)) }) @@ -344,28 +320,21 @@ func TestUser_Clone(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) }() - assert := assert.New(t) - defer conn.Close() org, _ := TestScopes(t, conn) t.Run("valid", func(t *testing.T) { - w := db.New(conn) - user, err := NewUser(org.PublicId) - assert.NoError(err) - id, err := newUserId() - assert.NoError(err) - user.PublicId = id - err = w.Create(context.Background(), user) - assert.NoError(err) - + assert := assert.New(t) + user := TestUser(t, conn, org.PublicId) cp := user.Clone() assert.True(proto.Equal(cp.(*User).User, user.User)) }) t.Run("not-equal-test", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) user, err := NewUser(org.PublicId) @@ -405,18 +374,6 @@ func TestUser_Actions(t *testing.T) { func TestUser_ResourceType(t *testing.T) { t.Parallel() - cleanup, conn, _ := db.TestSetup(t, "postgres") - defer func() { - if err := cleanup(); err != nil { - t.Error(err) - } - }() - assert := assert.New(t) - defer conn.Close() - org, _ := TestScopes(t, conn) - - u, err := NewUser(org.PublicId) - assert.NoError(err) - ty := u.ResourceType() - assert.Equal(ty, ResourceTypeUser) + u := allocUser() + assert.Equal(t, ResourceTypeUser, u.ResourceType()) }