CyberCoveLLC/threshold
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup tests: properly use require, catch defer errors, use testing functions (#113)

Browse Source
This commit is contained in:
Jim authored and GitHub committed 2020-06-10 12:10:34 -04:00
1 parent ce166c0bdf
commit 10e08e90f0
10 files changed
+362 -546
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

internal/iam/action_test.go
+4 -2
View File
@@ -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)
internal/iam/options_test.go
+3 -1
View File
@@ -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"
internal/iam/repository_scope_test.go
+89 -133
View File
@@ -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 := &timestamp.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")
})
internal/iam/repository_test.go
+46 -71
View File
@@ -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 := &timestamp.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())
internal/iam/repository_user_test.go
+38 -48
View File
@@ -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)
})
}
}
internal/iam/resource_test.go
+10 -8
View File
@@ -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())
})
}
internal/iam/scope_test.go
+72 -137
View File
@@ -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))
})
internal/iam/testing.go
+24 -23
View File
@@ -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
}
internal/iam/testing_test.go
+18 -22
View File
@@ -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)
}
internal/iam/user_test.go
+58 -101
View File
@@ -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())
}