From c408fccc6f5c192550193185d9496c0ed78ad128 Mon Sep 17 00:00:00 2001 From: Jim Lambert Date: Tue, 9 Jun 2020 16:24:17 -0400 Subject: [PATCH] refactor tests --- internal/iam/assigned_role_test.go | 71 +++------- internal/iam/auth_method_test.go | 82 ++++------- internal/iam/group.go | 30 ++-- internal/iam/group_member_test.go | 96 +++---------- internal/iam/group_test.go | 193 ++++++++++++-------------- internal/iam/repository_group.go | 5 + internal/iam/repository_group_test.go | 30 ++-- internal/iam/repository_test.go | 9 +- internal/iam/resource_test.go | 11 +- internal/iam/role_grant_test.go | 78 ++++------- internal/iam/role_test.go | 91 +++++------- internal/iam/user_grants_test.go | 20 ++- internal/iam/user_groups_test.go | 21 ++- internal/iam/user_roles_test.go | 11 +- 14 files changed, 284 insertions(+), 464 deletions(-) diff --git a/internal/iam/assigned_role_test.go b/internal/iam/assigned_role_test.go index df5b53b5e3..3be41d4dee 100644 --- a/internal/iam/assigned_role_test.go +++ b/internal/iam/assigned_role_test.go @@ -14,22 +14,15 @@ func Test_NewAssignedRole(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + s := testOrg(t, conn, "", "") user := TestUser(t, conn, s.PublicId) role, err := NewRole(s.PublicId, WithDescription("this is a test role")) @@ -51,14 +44,7 @@ func Test_NewAssignedRole(t *testing.T) { assert.NotNil(uRole) assert.Equal(uRole.GetPrincipalId(), user.PublicId) - grp, err := NewGroup(s.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) + grp := TestGroup(t, conn, s.PublicId) gRole, err := NewAssignedRole(role, grp) assert.NoError(err) @@ -71,21 +57,10 @@ func Test_NewAssignedRole(t *testing.T) { assert.Equal(gRole.GetPrincipalId(), grp.PublicId) }) t.Run("bad-resource-type", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - secondScope, err := NewOrganization() - assert.NoError(err) - assert.NotNil(secondScope.Scope) - err = w.Create(context.Background(), secondScope) - assert.NoError(err) - assert.NotEmpty(secondScope.PublicId) - + s := testOrg(t, conn, "", "") + secondScope := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) assert.NotNil(role) @@ -101,14 +76,8 @@ func Test_NewAssignedRole(t *testing.T) { assert.Equal(err.Error(), "error unknown principal type for assigning role") }) t.Run("nil-role", func(t *testing.T) { - w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + assert := assert.New(t) + s := testOrg(t, conn, "", "") user := TestUser(t, conn, s.PublicId) uRole, err := NewAssignedRole(nil, user) @@ -117,13 +86,9 @@ func Test_NewAssignedRole(t *testing.T) { assert.Equal(err.Error(), "error role is nil for assigning role") }) t.Run("nil-principal", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) @@ -140,13 +105,9 @@ func Test_NewAssignedRole(t *testing.T) { assert.Equal(err.Error(), "principal is nil for assigning role") }) t.Run("nil-scope", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) diff --git a/internal/iam/auth_method_test.go b/internal/iam/auth_method_test.go index b9c65f8ede..8b6cc2e9c1 100644 --- a/internal/iam/auth_method_test.go +++ b/internal/iam/auth_method_test.go @@ -13,21 +13,15 @@ func Test_NewAuthMethod(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") meth, err := NewAuthMethod(s.PublicId, AuthUserPass) assert.NoError(err) @@ -38,6 +32,7 @@ func Test_NewAuthMethod(t *testing.T) { assert.Equal(meth.Type, AuthUserPass.String()) }) t.Run("no-scope", func(t *testing.T) { + assert := assert.New(t) meth, err := NewAuthMethod("", AuthUserPass) assert.Error(err) assert.Nil(meth) @@ -49,21 +44,15 @@ func TestAuthMethod_GetScope(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") meth, err := NewAuthMethod(s.PublicId, AuthUserPass) assert.NoError(err) @@ -77,28 +66,21 @@ func TestAuthMethod_GetScope(t *testing.T) { assert.NoError(err) assert.Equal(scope.GetPublicId(), s.PublicId) }) - } func TestAuthMethod_ResourceType(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") meth, err := NewAuthMethod(s.PublicId, AuthUserPass) assert.NoError(err) @@ -127,21 +109,15 @@ func TestAuthMethod_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() - t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") meth, err := NewAuthMethod(s.PublicId, AuthUserPass) assert.NoError(err) @@ -155,13 +131,9 @@ func TestAuthMethod_Clone(t *testing.T) { assert.True(proto.Equal(cp.(*AuthMethod).AuthMethod, meth.AuthMethod)) }) t.Run("not-equal", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") meth, err := NewAuthMethod(s.PublicId, AuthUserPass) assert.NoError(err) diff --git a/internal/iam/group.go b/internal/iam/group.go index 8c2c135779..d08602ed3d 100644 --- a/internal/iam/group.go +++ b/internal/iam/group.go @@ -2,7 +2,6 @@ package iam import ( "context" - "errors" "fmt" "github.com/hashicorp/watchtower/internal/db" @@ -10,7 +9,7 @@ import ( "google.golang.org/protobuf/proto" ) -// Group is made up of members and can be assigned roles +// Group is made up of principals which are scoped to an organization type Group struct { *store.Group tableName string `gorm:"-"` @@ -22,24 +21,17 @@ var _ Clonable = (*Group)(nil) var _ db.VetForWriter = (*Group)(nil) // NewGroup creates a new in memory group with a scope (project/organization) -// options include: withDescripion, WithName +// and allowed options include: withDescripion, WithName func NewGroup(scopeId string, opt ...Option) (*Group, error) { opts := getOpts(opt...) - withName := opts.withName - withDescription := opts.withDescription if scopeId == "" { - return nil, errors.New("error organization id is unset for new group") - } - publicId, err := db.NewPublicId("g") - if err != nil { - return nil, fmt.Errorf("error generating public id %w for new group", err) + return nil, fmt.Errorf("new group: missing scope id %w", db.ErrInvalidParameter) } g := &Group{ Group: &store.Group{ - PublicId: publicId, + Name: opts.withName, + Description: opts.withDescription, ScopeId: scopeId, - Name: withName, - Description: withDescription, }, } return g, nil @@ -63,7 +55,7 @@ func allocGroup() Group { // before it's written func (g *Group) VetForWrite(ctx context.Context, r db.Reader, opType db.OpType, opt ...db.Option) error { if g.PublicId == "" { - return errors.New("error public id is empty string for group write") + return fmt.Errorf("group vet for write: missing public id: %w", db.ErrInvalidParameter) } if err := validateScopeForWrite(ctx, r, g, opType, opt...); err != nil { return err @@ -102,3 +94,13 @@ func (g *Group) SetTableName(n string) { g.tableName = n } } + +const GroupPrefix = "g" + +func newGroupId() (string, error) { + id, err := db.NewPublicId(GroupPrefix) + if err != nil { + return "", fmt.Errorf("new group id: %w", err) + } + return id, nil +} diff --git a/internal/iam/group_member_test.go b/internal/iam/group_member_test.go index cc9d74035b..d42710d1d0 100644 --- a/internal/iam/group_member_test.go +++ b/internal/iam/group_member_test.go @@ -12,33 +12,17 @@ func TestGroup_AddUser(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - user := TestUser(t, conn, s.PublicId) - - grp, err := NewGroup(s.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) - + org, _ := TestScopes(t, conn) + user := TestUser(t, conn, org.PublicId) + grp := TestGroup(t, conn, org.PublicId) gm, err := grp.AddUser(user.PublicId) assert.NoError(err) assert.NotNil(gm) @@ -53,32 +37,17 @@ func Test_NewGroupMember(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", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + s := testOrg(t, conn, "", "") user := TestUser(t, conn, s.PublicId) - - grp, err := NewGroup(s.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) + grp := TestGroup(t, conn, s.PublicId) gm, err := grp.AddUser(user.PublicId) assert.NoError(err) @@ -101,13 +70,9 @@ func Test_NewGroupMember(t *testing.T) { assert.Equal(0, len(members)) }) t.Run("bad-type", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) @@ -117,14 +82,7 @@ func Test_NewGroupMember(t *testing.T) { assert.NoError(err) assert.NotEmpty(role.PublicId) - grp, err := NewGroup(s.PublicId) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) - + grp := TestGroup(t, conn, s.PublicId) gm, err := grp.AddUser(role.PublicId) assert.NoError(err) assert.NotNil(gm) @@ -134,21 +92,9 @@ func Test_NewGroupMember(t *testing.T) { }) t.Run("nil-user", func(t *testing.T) { - w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - - grp, err := NewGroup(s.PublicId) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) + assert := assert.New(t) + s := testOrg(t, conn, "", "") + grp := TestGroup(t, conn, s.PublicId) gm, err := grp.AddUser("") assert.Error(err) diff --git a/internal/iam/group_test.go b/internal/iam/group_test.go index 5369a554a4..85a6a82c06 100644 --- a/internal/iam/group_test.go +++ b/internal/iam/group_test.go @@ -6,10 +6,10 @@ import ( "testing" "time" - "github.com/hashicorp/go-uuid" "github.com/hashicorp/watchtower/internal/db" "github.com/hashicorp/watchtower/internal/oplog" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" ) @@ -17,63 +17,65 @@ func TestNewGroup(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 opt []Option } tests := []struct { - name string - args args - wantErr bool - wantErrMsg string - wantName string + name string + args args + wantErr bool + wantErrMsg string + wantName string + wantDescription string }{ { name: "valid", args: args{ organizationPublicId: org.PublicId, - opt: []Option{WithName(id)}, + opt: []Option{WithName(id), WithDescription(id)}, }, - wantErr: false, - wantName: id, + wantErr: false, + wantName: id, + wantDescription: id, }, { - name: "valid-with-no-name", + name: "valid-with-no-options", args: args{ organizationPublicId: org.PublicId, }, wantErr: false, }, { - name: "no-org", + name: "no-scope", args: args{ opt: []Option{WithName(id)}, }, wantErr: true, - wantErrMsg: "error organization id is unset for new group", + wantErrMsg: "new group: missing scope id invalid parameter", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + assert, require := assert.New(t), require.New(t) got, err := NewGroup(tt.args.organizationPublicId, tt.args.opt...) if tt.wantErr { - assert.Error(err) + require.Error(err) assert.Equal(tt.wantErrMsg, err.Error()) return } - assert.NoError(err) + require.NoError(err) assert.Equal(tt.wantName, got.Name) + assert.Equal(tt.wantDescription, got.Description) + assert.Empty(got.PublicId) }) } } @@ -82,36 +84,59 @@ func Test_GroupCreate(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) - t.Run("valid", func(t *testing.T) { + org, proj := TestScopes(t, conn) + id := testId(t) + t.Run("valid-with-org", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) grp, err := NewGroup(org.PublicId, WithName(id), WithDescription(id)) - assert.NoError(err) + require.NoError(err) + id, err := newGroupId() + require.NoError(err) + grp.PublicId = id err = w.Create(context.Background(), grp) - assert.NoError(err) + require.NoError(err) assert.NotEmpty(grp.PublicId) foundGrp := allocGroup() foundGrp.PublicId = grp.PublicId err = w.LookupByPublicId(context.Background(), &foundGrp) - assert.NoError(err) + require.NoError(err) + assert.Equal(grp, &foundGrp) + }) + t.Run("valid-with-proj", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) + w := db.New(conn) + grp, err := NewGroup(proj.PublicId, WithName(id), WithDescription(id)) + require.NoError(err) + id, err := newGroupId() + require.NoError(err) + grp.PublicId = id + err = w.Create(context.Background(), grp) + require.NoError(err) + assert.NotEmpty(grp.PublicId) + + foundGrp := allocGroup() + foundGrp.PublicId = grp.PublicId + err = w.LookupByPublicId(context.Background(), &foundGrp) + require.NoError(err) assert.Equal(grp, &foundGrp) }) - t.Run("bad-orgid", func(t *testing.T) { + t.Run("bad-scope-id", func(t *testing.T) { + assert, require := assert.New(t), require.New(t) w := db.New(conn) grp, err := NewGroup(id) - assert.NoError(err) + require.NoError(err) + id, err := newGroupId() + require.NoError(err) + grp.PublicId = id err = w.Create(context.Background(), grp) - assert.Error(err) + require.Error(err) assert.Equal("create: vet for write failed scope is not found", err.Error()) }) } @@ -119,19 +144,14 @@ func Test_GroupUpdate(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) - id, err := uuid.GenerateUUID() - a.NoError(err) - + id := testId(t) org, proj := TestScopes(t, conn) - + rw := db.New(conn) type args struct { name string description string @@ -242,16 +262,14 @@ func Test_GroupDelete(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) - id, err := uuid.GenerateUUID() - a.NoError(err) + id := testId(t) org, _ := TestScopes(t, conn) tests := []struct { @@ -321,26 +339,17 @@ func TestGroup_GetScope(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) { + assert := assert.New(t) w := db.New(conn) - - grp, err := NewGroup(org.PublicId) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(org.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) - + grp := TestGroup(t, conn, org.PublicId) scope, err := grp.GetScope(context.Background(), w) assert.NoError(err) assert.True(proto.Equal(org, scope)) @@ -351,47 +360,23 @@ func TestGroup_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) - - grp, err := NewGroup(org.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(org.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) - + assert := assert.New(t) + grp := TestGroup(t, conn, org.PublicId) cp := grp.Clone() assert.True(proto.Equal(cp.(*Group).Group, grp.Group)) }) t.Run("not-equal", func(t *testing.T) { - w := db.New(conn) - - grp, err := NewGroup(org.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(org.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) - - grp2, err := NewGroup(org.PublicId, WithDescription("second group")) - assert.NoError(err) - assert.NotNil(grp2) - err = w.Create(context.Background(), grp2) - assert.NoError(err) - assert.NotEmpty(grp2.PublicId) + assert := assert.New(t) + grp := TestGroup(t, conn, org.PublicId) + grp2 := TestGroup(t, conn, org.PublicId) cp := grp.Clone() assert.True(!proto.Equal(cp.(*Group).Group, grp2.Group)) diff --git a/internal/iam/repository_group.go b/internal/iam/repository_group.go index 6d26dc3bfc..943688520a 100644 --- a/internal/iam/repository_group.go +++ b/internal/iam/repository_group.go @@ -13,6 +13,11 @@ func (r *Repository) CreateGroup(ctx context.Context, group *Group, opt ...Optio if group == nil { return nil, errors.New("error group is nil for create") } + id, err := newGroupId() + if err != nil { + return nil, fmt.Errorf("create group: %w", err) + } + group.PublicId = id resource, err := r.create(ctx, group) if err != nil { return nil, fmt.Errorf("failed to create group: %w", err) diff --git a/internal/iam/repository_group_test.go b/internal/iam/repository_group_test.go index ec0565318e..42d4575dcd 100644 --- a/internal/iam/repository_group_test.go +++ b/internal/iam/repository_group_test.go @@ -17,13 +17,12 @@ func TestRepository_CreateGroup(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) @@ -113,13 +112,12 @@ func TestRepository_UpdateGroup(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) @@ -231,13 +229,12 @@ func TestRepository_DeleteGroup(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) @@ -279,7 +276,10 @@ func TestRepository_DeleteGroup(t *testing.T) { name: "not-found", args: args{ group: func() *Group { + id, err := newGroupId() + a.NoError(err) g, err := NewGroup(org.PublicId) + g.PublicId = id a.NoError(err) return g }(), diff --git a/internal/iam/repository_test.go b/internal/iam/repository_test.go index e71bbf5311..240b92043a 100644 --- a/internal/iam/repository_test.go +++ b/internal/iam/repository_test.go @@ -185,14 +185,7 @@ func Test_Repository_delete(t *testing.T) { repo, err := NewRepository(rw, rw, wrapper) assert.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 := testOrg(t, conn, "", "") rowsDeleted, err := repo.delete(context.Background(), s) assert.NoError(err) assert.Equal(1, rowsDeleted) diff --git a/internal/iam/resource_test.go b/internal/iam/resource_test.go index 643ff0f04b..a4813bcdd9 100644 --- a/internal/iam/resource_test.go +++ b/internal/iam/resource_test.go @@ -13,13 +13,13 @@ 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 := assert.New(t) w := db.New(conn) org, _ := TestScopes(t, conn) user := TestUser(t, conn, org.PublicId) @@ -35,6 +35,7 @@ func Test_LookupScope(t *testing.T) { assert.True(proto.Equal(foundScope, org)) }) t.Run("bad-scope", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) org, _ := TestScopes(t, conn) user := TestUser(t, conn, org.PublicId) diff --git a/internal/iam/role_grant_test.go b/internal/iam/role_grant_test.go index 38bf44dafb..0760da7980 100644 --- a/internal/iam/role_grant_test.go +++ b/internal/iam/role_grant_test.go @@ -12,18 +12,16 @@ import ( func TestNewRoleGrant(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) @@ -54,13 +52,9 @@ func TestNewRoleGrant(t *testing.T) { assert.Equal(uRole.GetPrincipalId(), user.PublicId) }) t.Run("nil-scope", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) @@ -71,14 +65,7 @@ func TestNewRoleGrant(t *testing.T) { assert.NotEmpty(role.PublicId) }) t.Run("nil-role", func(t *testing.T) { - w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + assert := assert.New(t) g, err := NewRoleGrant(nil, "everything*") assert.Error(err) assert.Nil(g) @@ -106,18 +93,17 @@ func TestRoleGrant_ResourceType(t *testing.T) { func TestRoleGrant_GetScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) @@ -143,18 +129,16 @@ func TestRoleGrant_GetScope(t *testing.T) { func TestRoleGrant_Clone(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) @@ -174,13 +158,9 @@ func TestRoleGrant_Clone(t *testing.T) { assert.True(proto.Equal(cp.(*RoleGrant).RoleGrant, g.RoleGrant)) }) t.Run("not-equal", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId) assert.NoError(err) diff --git a/internal/iam/role_test.go b/internal/iam/role_test.go index 30c2619aec..a186031b4f 100644 --- a/internal/iam/role_test.go +++ b/internal/iam/role_test.go @@ -12,18 +12,16 @@ import ( func Test_NewRole(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) @@ -35,6 +33,7 @@ func Test_NewRole(t *testing.T) { assert.NotEmpty(role.PublicId) }) t.Run("no-scope", func(t *testing.T) { + assert := assert.New(t) role, err := NewRole("") assert.Error(err) assert.Nil(role) @@ -62,18 +61,16 @@ func TestRole_ResourceType(t *testing.T) { func TestRole_GetScope(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) @@ -93,19 +90,16 @@ func TestRole_GetScope(t *testing.T) { func TestRole_AssignedRoles(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) - + s := testOrg(t, conn, "", "") user := TestUser(t, conn, s.PublicId) role, err := NewRole(s.PublicId, WithDescription("this is a test role")) @@ -127,14 +121,7 @@ func TestRole_AssignedRoles(t *testing.T) { assert.NotNil(uRole) assert.Equal(uRole.GetPrincipalId(), user.PublicId) - grp, err := NewGroup(s.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(s.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEmpty(grp.PublicId) + grp := TestGroup(t, conn, s.PublicId) gRole, err := NewAssignedRole(role, grp) assert.NoError(err) @@ -155,18 +142,16 @@ func TestRole_AssignedRoles(t *testing.T) { func TestRole_Clone(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) @@ -181,13 +166,9 @@ func TestRole_Clone(t *testing.T) { assert.True(proto.Equal(cp.(*Role).Role, role.Role)) }) t.Run("not-equal", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) - s, err := NewOrganization() - assert.NoError(err) - assert.NotNil(s.Scope != nil) - err = w.Create(context.Background(), s) - assert.NoError(err) - assert.NotEmpty(s.PublicId) + s := testOrg(t, conn, "", "") role, err := NewRole(s.PublicId, WithDescription("this is a test role")) assert.NoError(err) diff --git a/internal/iam/user_grants_test.go b/internal/iam/user_grants_test.go index c46ae9c8a3..32f3a6549d 100644 --- a/internal/iam/user_grants_test.go +++ b/internal/iam/user_grants_test.go @@ -12,13 +12,16 @@ import ( func Test_UserGrants(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() org, _ := TestScopes(t, conn) t.Run("valid", func(t *testing.T) { + assert := assert.New(t) id, err := uuid.GenerateUUID() assert.NoError(err) w := db.New(conn) @@ -56,14 +59,7 @@ func Test_UserGrants(t *testing.T) { assert.Equal(len(userGrants), 1) assert.Equal(userGrants[0], g) - grp, err := NewGroup(org.PublicId, WithDescription("user grants test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "user grants test group") - assert.Equal(org.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEqual(grp.PublicId, "") + grp := TestGroup(t, conn, org.PublicId) gm, err := grp.AddUser(user.PublicId) assert.NoError(err) diff --git a/internal/iam/user_groups_test.go b/internal/iam/user_groups_test.go index 5e95a722f0..a32b510304 100644 --- a/internal/iam/user_groups_test.go +++ b/internal/iam/user_groups_test.go @@ -11,24 +11,19 @@ import ( func Test_UserGroups(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() - + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() org, _ := TestScopes(t, conn) - t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) user := TestUser(t, conn, org.PublicId) - grp, err := NewGroup(org.PublicId, WithDescription("this is a test group")) - assert.NoError(err) - assert.NotNil(grp) - assert.Equal(grp.Description, "this is a test group") - assert.Equal(org.PublicId, grp.ScopeId) - err = w.Create(context.Background(), grp) - assert.NoError(err) - assert.NotEqual(grp.PublicId, "") + grp := TestGroup(t, conn, org.PublicId) gm, err := grp.AddUser(user.PublicId) assert.NoError(err) diff --git a/internal/iam/user_roles_test.go b/internal/iam/user_roles_test.go index 4432f5e4a7..1e3a84aecb 100644 --- a/internal/iam/user_roles_test.go +++ b/internal/iam/user_roles_test.go @@ -11,12 +11,15 @@ import ( func Test_UserRoles(t *testing.T) { t.Parallel() cleanup, conn, _ := db.TestSetup(t, "postgres") - defer cleanup() - assert := assert.New(t) - defer conn.Close() + defer func() { + err := cleanup() + assert.NoError(t, err) + err = conn.Close() + assert.NoError(t, err) + }() org, _ := TestScopes(t, conn) - t.Run("valid", func(t *testing.T) { + assert := assert.New(t) w := db.New(conn) user := TestUser(t, conn, org.PublicId)