aherman
/
boundary
mirror of https://github.com/hashicorp/boundary
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor tests

Browse Source
pull/165/head
Jim Lambert 6 years ago
parent 23d8ecf7e1
commit c408fccc6f
14 changed files with 284 additions and 464 deletions
Show Stats Download Patch File Download Diff File

71
internal/iam/assigned_role_test.go
Unescape View File

@ -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)

82
internal/iam/auth_method_test.go
Unescape View File

@ -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)

30
internal/iam/group.go
Unescape View File

@ -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
}

96
internal/iam/group_member_test.go
Unescape View File

@ -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)

193
internal/iam/group_test.go
Unescape View File

@ -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))

5
internal/iam/repository_group.go
Unescape View File

@ -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)

30
internal/iam/repository_group_test.go
Unescape View File

@ -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
}(),

9
internal/iam/repository_test.go
Unescape View File

@ -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)

11
internal/iam/resource_test.go
Unescape View File

@ -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)

78
internal/iam/role_grant_test.go
Unescape View File

@ -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)

91
internal/iam/role_test.go
Unescape View File

@ -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)

20
internal/iam/user_grants_test.go
Unescape View File

@ -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)

21
internal/iam/user_groups_test.go
Unescape View File

@ -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)

11
internal/iam/user_roles_test.go
Unescape View File

@ -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)

Write Preview
Loading…
Cancel
Save