* refact: Changes required for gorm v2 * refact: Add db.DB wrapper and refact all test fixtures to use it Stop leaking the gorm abstraction within our unit tests. * refact: Migrate direct calls to pq to pgx driver The refactor will remove the remaining direct dependencies on the pq driver which has been deprecated in favor of the pgx driver. It includes the addition of common.SqlOpen which is a wrapper around sql.Open, which is needed to deal with the driver name changing from "postgres" to "pgx" but in our code base the dialect and driver are synonyms.
507 lines
15 KiB
Go
507 lines
15 KiB
Go
package target
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hashicorp/boundary/internal/credential/vault"
|
|
"github.com/hashicorp/boundary/internal/db"
|
|
dbassert "github.com/hashicorp/boundary/internal/db/assert"
|
|
"github.com/hashicorp/boundary/internal/errors"
|
|
"github.com/hashicorp/boundary/internal/host/static"
|
|
"github.com/hashicorp/boundary/internal/iam"
|
|
"github.com/hashicorp/boundary/internal/kms"
|
|
"github.com/hashicorp/boundary/internal/oplog"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
func TestRepository_CreateTcpTarget(t *testing.T) {
|
|
t.Parallel()
|
|
conn, _ := db.TestSetup(t, "postgres")
|
|
rw := db.New(conn)
|
|
wrapper := db.TestWrapper(t)
|
|
testKms := kms.TestKms(t, conn, wrapper)
|
|
repo, err := NewRepository(rw, rw, testKms)
|
|
require.NoError(t, err)
|
|
_, proj := iam.TestScopes(t, iam.TestRepo(t, conn, wrapper))
|
|
|
|
cats := static.TestCatalogs(t, conn, proj.PublicId, 1)
|
|
hsets := static.TestSets(t, conn, cats[0].GetPublicId(), 2)
|
|
var sets []string
|
|
for _, s := range hsets {
|
|
sets = append(sets, s.PublicId)
|
|
}
|
|
|
|
cs := vault.TestCredentialStores(t, conn, wrapper, proj.GetPublicId(), 1)[0]
|
|
credSources := vault.TestCredentialLibraries(t, conn, wrapper, cs.GetPublicId(), 2)
|
|
var clIds []string
|
|
for _, cl := range credSources {
|
|
clIds = append(clIds, cl.PublicId)
|
|
}
|
|
|
|
type args struct {
|
|
target *TcpTarget
|
|
opt []Option
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
wantHostSources []string
|
|
wantCredLibs []string
|
|
wantErr bool
|
|
wantIsError errors.Code
|
|
}{
|
|
{
|
|
name: "valid-org",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target, err := NewTcpTarget(proj.PublicId,
|
|
WithName("valid-org"),
|
|
WithDescription("valid-org"),
|
|
WithDefaultPort(uint32(22)))
|
|
require.NoError(t, err)
|
|
return target
|
|
}(),
|
|
},
|
|
wantErr: false,
|
|
wantCredLibs: []string{},
|
|
wantHostSources: []string{},
|
|
},
|
|
{
|
|
name: "valid-org-with-host-sets",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target, err := NewTcpTarget(proj.PublicId,
|
|
WithName("valid-org-with-host-sets"),
|
|
WithDescription("valid-org"),
|
|
WithDefaultPort(uint32(22)))
|
|
require.NoError(t, err)
|
|
return target
|
|
}(),
|
|
opt: []Option{WithHostSources(sets)},
|
|
},
|
|
wantErr: false,
|
|
wantHostSources: sets,
|
|
wantCredLibs: []string{},
|
|
},
|
|
{
|
|
name: "valid-org-with-cred-libs",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target, err := NewTcpTarget(proj.PublicId,
|
|
WithName("valid-org-with-cred-libs"),
|
|
WithDescription("valid-org"),
|
|
WithDefaultPort(uint32(22)))
|
|
require.NoError(t, err)
|
|
return target
|
|
}(),
|
|
opt: []Option{WithCredentialSources(clIds)},
|
|
},
|
|
wantErr: false,
|
|
wantCredLibs: clIds,
|
|
wantHostSources: []string{},
|
|
},
|
|
{
|
|
name: "valid-org-with-cred-libs-and-host-sets",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target, err := NewTcpTarget(proj.PublicId,
|
|
WithName("valid-org-with-cred-libs-and-host-sets"),
|
|
WithDescription("valid-org"),
|
|
WithDefaultPort(uint32(22)))
|
|
require.NoError(t, err)
|
|
return target
|
|
}(),
|
|
opt: []Option{
|
|
WithHostSources(sets),
|
|
WithCredentialSources(clIds),
|
|
},
|
|
},
|
|
wantErr: false,
|
|
wantCredLibs: clIds,
|
|
wantHostSources: sets,
|
|
},
|
|
{
|
|
name: "nil-target",
|
|
args: args{
|
|
target: nil,
|
|
},
|
|
wantErr: true,
|
|
wantIsError: errors.InvalidParameter,
|
|
},
|
|
{
|
|
name: "nil-target-store",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target := &TcpTarget{}
|
|
return target
|
|
}(),
|
|
},
|
|
wantErr: true,
|
|
wantIsError: errors.InvalidParameter,
|
|
},
|
|
{
|
|
name: "public-id-not-empty",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target, err := NewTcpTarget(proj.PublicId, WithName("valid-org"), WithDescription("valid-org"), WithDefaultPort(uint32(22)))
|
|
require.NoError(t, err)
|
|
id, err := newTcpTargetId()
|
|
require.NoError(t, err)
|
|
target.PublicId = id
|
|
return target
|
|
}(),
|
|
},
|
|
wantErr: true,
|
|
wantIsError: errors.InvalidParameter,
|
|
},
|
|
{
|
|
name: "empty-scope-id",
|
|
args: args{
|
|
target: func() *TcpTarget {
|
|
target := allocTcpTarget()
|
|
target.Name = "empty-scope-id"
|
|
require.NoError(t, err)
|
|
return &target
|
|
}(),
|
|
},
|
|
wantErr: true,
|
|
wantIsError: errors.InvalidParameter,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
target, hostSources, credSources, err := repo.CreateTcpTarget(context.Background(), tt.args.target, tt.args.opt...)
|
|
if tt.wantErr {
|
|
assert.Error(err)
|
|
assert.Nil(target)
|
|
assert.True(errors.Match(errors.T(tt.wantIsError), err))
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
assert.NotNil(target.GetPublicId())
|
|
hsIds := make([]string, 0, len(hostSources))
|
|
for _, s := range hostSources {
|
|
hsIds = append(hsIds, s.Id())
|
|
}
|
|
assert.Equal(tt.wantHostSources, hsIds)
|
|
|
|
clIds := make([]string, 0, len(credSources))
|
|
for _, cl := range credSources {
|
|
clIds = append(clIds, cl.Id())
|
|
}
|
|
assert.Equal(tt.wantCredLibs, clIds)
|
|
|
|
foundTarget, foundHostSources, foundCredLibs, err := repo.LookupTarget(context.Background(), target.GetPublicId())
|
|
assert.NoError(err)
|
|
assert.True(proto.Equal(target.(*TcpTarget), foundTarget.(*TcpTarget)))
|
|
assert.Equal(hostSources, foundHostSources)
|
|
assert.Equal(credSources, foundCredLibs)
|
|
|
|
err = db.TestVerifyOplog(t, rw, target.GetPublicId(), db.WithOperation(oplog.OpType_OP_TYPE_CREATE), db.WithCreateNotBefore(10*time.Second))
|
|
assert.NoError(err)
|
|
|
|
// TODO (jimlambrt 9/2020) - unfortunately, we can currently
|
|
// test to make sure that the oplog entry for a target host sets
|
|
// create exist because the db.TestVerifyOplog doesn't really
|
|
// support that level of testing and the previous call to
|
|
// CreateTcpTarget would create an oplog entry for the
|
|
// create on the target even if no host sets were added. Once
|
|
// TestVerifyOplog supports the appropriate granularity, we should
|
|
// add an appropriate assert.
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRepository_UpdateTcpTarget(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
conn, _ := db.TestSetup(t, "postgres")
|
|
rw := db.New(conn)
|
|
wrapper := db.TestWrapper(t)
|
|
testKms := kms.TestKms(t, conn, wrapper)
|
|
|
|
repo, err := NewRepository(rw, rw, testKms)
|
|
require.NoError(t, err)
|
|
id := testId(t)
|
|
|
|
iamRepo := iam.TestRepo(t, conn, wrapper)
|
|
_, proj := iam.TestScopes(t, iamRepo)
|
|
pubId := func(s string) *string { return &s }
|
|
|
|
type args struct {
|
|
name string
|
|
description string
|
|
port uint32
|
|
fieldMaskPaths []string
|
|
opt []Option
|
|
ScopeId string
|
|
PublicId *string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
newScopeId string
|
|
newName string
|
|
newTargetOpts []Option
|
|
args args
|
|
wantRowsUpdate int
|
|
wantErr bool
|
|
wantErrMsg string
|
|
wantIsError errors.Code
|
|
wantDup bool
|
|
}{
|
|
{
|
|
name: "valid",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: false,
|
|
wantRowsUpdate: 1,
|
|
},
|
|
{
|
|
name: "valid-no-op",
|
|
args: args{
|
|
name: "valid-no-op" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
newName: "valid-no-op" + id,
|
|
wantErr: false,
|
|
wantRowsUpdate: 1,
|
|
},
|
|
{
|
|
name: "not-found",
|
|
args: args{
|
|
name: "not-found" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
PublicId: func() *string { s := "1"; return &s }(),
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: failed for 1: db.DoTx: target.(Repository).UpdateTcpTarget: target.(Repository).update: db.DoTx: target.(Repository).update: db.Update: db.lookupAfterWrite: db.LookupById: record not found, search issue: error #1100",
|
|
wantIsError: errors.RecordNotFound,
|
|
},
|
|
{
|
|
name: "null-name",
|
|
args: args{
|
|
name: "",
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
newName: "null-name" + id,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "db.DoTx: target.(Repository).UpdateTcpTarget: target.(Repository).update: db.DoTx: target.(Repository).update: db.Update: name must not be empty: not null constraint violated: integrity violation: error #1001",
|
|
},
|
|
{
|
|
name: "null-description",
|
|
args: args{
|
|
name: "null-description",
|
|
fieldMaskPaths: []string{"Description"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
newTargetOpts: []Option{WithDescription("null-description" + id)},
|
|
wantErr: false,
|
|
wantRowsUpdate: 1,
|
|
},
|
|
{
|
|
name: "empty-field-mask",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: []string{},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
|
|
wantIsError: errors.EmptyFieldMask,
|
|
},
|
|
{
|
|
name: "nil-fieldmask",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: nil,
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
|
|
wantIsError: errors.EmptyFieldMask,
|
|
},
|
|
{
|
|
name: "read-only-fields",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: []string{"CreateTime"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: invalid field mask: CreateTime: parameter violation: error #103",
|
|
wantIsError: errors.InvalidFieldMask,
|
|
},
|
|
{
|
|
name: "unknown-fields",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: []string{"Alice"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantRowsUpdate: 0,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: invalid field mask: Alice: parameter violation: error #103",
|
|
wantIsError: errors.InvalidFieldMask,
|
|
},
|
|
{
|
|
name: "no-public-id",
|
|
args: args{
|
|
name: "valid" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
PublicId: pubId(""),
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: missing target public id: parameter violation: error #100",
|
|
wantIsError: errors.InvalidParameter,
|
|
wantRowsUpdate: 0,
|
|
},
|
|
{
|
|
name: "proj-scope-id-no-mask",
|
|
args: args{
|
|
name: "proj-scope-id" + id,
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantErrMsg: "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
|
|
wantIsError: errors.EmptyFieldMask,
|
|
},
|
|
{
|
|
name: "empty-scope-id-with-name-mask",
|
|
args: args{
|
|
name: "empty-scope-id" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: "",
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: false,
|
|
wantRowsUpdate: 1,
|
|
},
|
|
{
|
|
name: "dup-name",
|
|
args: args{
|
|
name: "dup-name" + id,
|
|
fieldMaskPaths: []string{"Name"},
|
|
ScopeId: proj.PublicId,
|
|
},
|
|
newScopeId: proj.PublicId,
|
|
wantErr: true,
|
|
wantDup: true,
|
|
wantErrMsg: " already exists in scope " + proj.PublicId,
|
|
wantIsError: errors.NotUnique,
|
|
},
|
|
}
|
|
css := vault.TestCredentialStores(t, conn, wrapper, proj.GetPublicId(), len(tests))
|
|
for i, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cs := css[i]
|
|
require, assert := require.New(t), assert.New(t)
|
|
if tt.wantDup {
|
|
_ = TestTcpTarget(t, conn, proj.PublicId, tt.args.name)
|
|
}
|
|
|
|
testCats := static.TestCatalogs(t, conn, proj.PublicId, 1)
|
|
hsets := static.TestSets(t, conn, testCats[0].GetPublicId(), 5)
|
|
testHostSetIds := make([]string, 0, len(hsets))
|
|
for _, hs := range hsets {
|
|
testHostSetIds = append(testHostSetIds, hs.PublicId)
|
|
}
|
|
|
|
cls := vault.TestCredentialLibraries(t, conn, wrapper, cs.GetPublicId(), 5)
|
|
var testClIds []string
|
|
for _, cl := range cls {
|
|
testClIds = append(testClIds, cl.PublicId)
|
|
}
|
|
|
|
tt.newTargetOpts = append(tt.newTargetOpts, WithHostSources(testHostSetIds), WithCredentialSources(testClIds))
|
|
name := tt.newName
|
|
if name == "" {
|
|
name = testId(t)
|
|
}
|
|
target := TestTcpTarget(t, conn, tt.newScopeId, name, tt.newTargetOpts...)
|
|
updateTarget := allocTcpTarget()
|
|
updateTarget.PublicId = target.PublicId
|
|
if tt.args.PublicId != nil {
|
|
updateTarget.PublicId = *tt.args.PublicId
|
|
}
|
|
updateTarget.ScopeId = tt.args.ScopeId
|
|
updateTarget.Name = tt.args.name
|
|
updateTarget.Description = tt.args.description
|
|
updateTarget.DefaultPort = tt.args.port
|
|
|
|
targetAfterUpdate, hostSources, credSources, updatedRows, err := repo.UpdateTcpTarget(context.Background(), &updateTarget, target.Version, tt.args.fieldMaskPaths, tt.args.opt...)
|
|
if tt.wantErr {
|
|
assert.Error(err)
|
|
assert.True(errors.Match(errors.T(tt.wantIsError), err))
|
|
assert.Nil(targetAfterUpdate)
|
|
assert.Equal(0, updatedRows)
|
|
assert.Contains(err.Error(), tt.wantErrMsg)
|
|
err = db.TestVerifyOplog(t, rw, target.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second))
|
|
assert.Error(err)
|
|
assert.True(errors.IsNotFoundError(err))
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
require.NotNil(targetAfterUpdate)
|
|
assert.Equal(tt.wantRowsUpdate, updatedRows)
|
|
afterUpdateIds := make([]string, 0, len(hostSources))
|
|
for _, hs := range hostSources {
|
|
afterUpdateIds = append(afterUpdateIds, hs.Id())
|
|
}
|
|
assert.Equal(testHostSetIds, afterUpdateIds)
|
|
|
|
afterUpdateIds = make([]string, 0, len(credSources))
|
|
for _, cl := range credSources {
|
|
afterUpdateIds = append(afterUpdateIds, cl.Id())
|
|
}
|
|
assert.Equal(testClIds, afterUpdateIds)
|
|
|
|
switch tt.name {
|
|
case "valid-no-op":
|
|
assert.Equal(target.UpdateTime, targetAfterUpdate.(*TcpTarget).UpdateTime)
|
|
default:
|
|
assert.NotEqual(target.UpdateTime, targetAfterUpdate.(*TcpTarget).UpdateTime)
|
|
}
|
|
foundTarget, _, _, err := repo.LookupTarget(context.Background(), target.PublicId)
|
|
assert.NoError(err)
|
|
assert.True(proto.Equal(targetAfterUpdate.((*TcpTarget)), foundTarget.((*TcpTarget))))
|
|
underlyingDB, err := conn.SqlDB(ctx)
|
|
require.NoError(err)
|
|
dbassert := dbassert.New(t, underlyingDB)
|
|
if tt.args.description == "" {
|
|
assert.Equal(foundTarget.GetDescription(), "")
|
|
dbassert.IsNull(foundTarget, "description")
|
|
}
|
|
err = db.TestVerifyOplog(t, rw, target.PublicId, db.WithOperation(oplog.OpType_OP_TYPE_UPDATE), db.WithCreateNotBefore(10*time.Second))
|
|
assert.NoError(err)
|
|
})
|
|
}
|
|
}
|