synced/coder
1
0
Fork 0
mirror of https://github.com/coder/coder.git synced 2025-07-06 15:41:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add tests

Browse Source
This commit is contained in:
Sas Swart
2025-02-05 12:18:25 +00:00
parent 2f0c60fda4
commit 00f1ec30df
51 changed files with 1477 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
coderd/database/dbauthz/dbauthz_test.go
View File

@ -891,9 +891,9 @@ func (s *MethodTestSuite) TestOrganization() {
}
_, err := db.InsertPreset(context.Background(), insertPresetParams)
require.NoError(s.T(), err)
check.Args(insertPresetParams).Asserts(rbac.ResourceTemplate, policy.ActionCreate)
check.Args(insertPresetParams).Asserts(rbac.ResourceSystem, policy.ActionCreate)
}))
s.Run("InsertPreset", s.Subtest(func(db database.Store, check *expects) {
s.Run("InsertPresetParameters", s.Subtest(func(db database.Store, check *expects) {
org := dbgen.Organization(s.T(), db, database.Organization{})
user := dbgen.User(s.T(), db, database.User{})
template := dbgen.Template(s.T(), db, database.Template{
@ -932,7 +932,7 @@ func (s *MethodTestSuite) TestOrganization() {
}
_, err = db.InsertPresetParameters(context.Background(), insertPresetParametersParams)
require.NoError(s.T(), err)
check.Args(insertPresetParametersParams).Asserts(rbac.ResourceTemplate, policy.ActionCreate)
check.Args(insertPresetParametersParams).Asserts(rbac.ResourceSystem, policy.ActionCreate)
}))
s.Run("DeleteOrganizationMember", s.Subtest(func(db database.Store, check *expects) {
o := dbgen.Organization(s.T(), db, database.Organization{})

40
coderd/database/dbmock/dbmock.go
View File

@ -2017,48 +2017,48 @@ func (mr *MockStoreMockRecorder) GetParameterSchemasByJobID(ctx, jobID any) *gom
}
// GetPresetByWorkspaceBuildID mocks base method.
func (m *MockStore) GetPresetByWorkspaceBuildID(arg0 context.Context, arg1 uuid.UUID) (database.TemplateVersionPreset, error) {
func (m *MockStore) GetPresetByWorkspaceBuildID(ctx context.Context, workspaceBuildID uuid.UUID) (database.TemplateVersionPreset, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPresetByWorkspaceBuildID", arg0, arg1)
ret := m.ctrl.Call(m, "GetPresetByWorkspaceBuildID", ctx, workspaceBuildID)
ret0, _ := ret[0].(database.TemplateVersionPreset)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPresetByWorkspaceBuildID indicates an expected call of GetPresetByWorkspaceBuildID.
func (mr *MockStoreMockRecorder) GetPresetByWorkspaceBuildID(arg0, arg1 any) *gomock.Call {
func (mr *MockStoreMockRecorder) GetPresetByWorkspaceBuildID(ctx, workspaceBuildID any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetByWorkspaceBuildID", reflect.TypeOf((*MockStore)(nil).GetPresetByWorkspaceBuildID), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetByWorkspaceBuildID", reflect.TypeOf((*MockStore)(nil).GetPresetByWorkspaceBuildID), ctx, workspaceBuildID)
}
// GetPresetParametersByTemplateVersionID mocks base method.
func (m *MockStore) GetPresetParametersByTemplateVersionID(arg0 context.Context, arg1 uuid.UUID) ([]database.TemplateVersionPresetParameter, error) {
func (m *MockStore) GetPresetParametersByTemplateVersionID(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionPresetParameter, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPresetParametersByTemplateVersionID", arg0, arg1)
ret := m.ctrl.Call(m, "GetPresetParametersByTemplateVersionID", ctx, templateVersionID)
ret0, _ := ret[0].([]database.TemplateVersionPresetParameter)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPresetParametersByTemplateVersionID indicates an expected call of GetPresetParametersByTemplateVersionID.
func (mr *MockStoreMockRecorder) GetPresetParametersByTemplateVersionID(arg0, arg1 any) *gomock.Call {
func (mr *MockStoreMockRecorder) GetPresetParametersByTemplateVersionID(ctx, templateVersionID any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetParametersByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetParametersByTemplateVersionID), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetParametersByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetParametersByTemplateVersionID), ctx, templateVersionID)
}
// GetPresetsByTemplateVersionID mocks base method.
func (m *MockStore) GetPresetsByTemplateVersionID(arg0 context.Context, arg1 uuid.UUID) ([]database.GetPresetsByTemplateVersionIDRow, error) {
func (m *MockStore) GetPresetsByTemplateVersionID(ctx context.Context, templateVersionID uuid.UUID) ([]database.GetPresetsByTemplateVersionIDRow, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetPresetsByTemplateVersionID", arg0, arg1)
ret := m.ctrl.Call(m, "GetPresetsByTemplateVersionID", ctx, templateVersionID)
ret0, _ := ret[0].([]database.GetPresetsByTemplateVersionIDRow)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetPresetsByTemplateVersionID indicates an expected call of GetPresetsByTemplateVersionID.
func (mr *MockStoreMockRecorder) GetPresetsByTemplateVersionID(arg0, arg1 any) *gomock.Call {
func (mr *MockStoreMockRecorder) GetPresetsByTemplateVersionID(ctx, templateVersionID any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetsByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetsByTemplateVersionID), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetsByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetsByTemplateVersionID), ctx, templateVersionID)
}
// GetPreviousTemplateVersion mocks base method.
@ -4097,33 +4097,33 @@ func (mr *MockStoreMockRecorder) InsertOrganizationMember(ctx, arg any) *gomock.
}
// InsertPreset mocks base method.
func (m *MockStore) InsertPreset(arg0 context.Context, arg1 database.InsertPresetParams) (database.TemplateVersionPreset, error) {
func (m *MockStore) InsertPreset(ctx context.Context, arg database.InsertPresetParams) (database.TemplateVersionPreset, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InsertPreset", arg0, arg1)
ret := m.ctrl.Call(m, "InsertPreset", ctx, arg)
ret0, _ := ret[0].(database.TemplateVersionPreset)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// InsertPreset indicates an expected call of InsertPreset.
func (mr *MockStoreMockRecorder) InsertPreset(arg0, arg1 any) *gomock.Call {
func (mr *MockStoreMockRecorder) InsertPreset(ctx, arg any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPreset", reflect.TypeOf((*MockStore)(nil).InsertPreset), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPreset", reflect.TypeOf((*MockStore)(nil).InsertPreset), ctx, arg)
}
// InsertPresetParameters mocks base method.
func (m *MockStore) InsertPresetParameters(arg0 context.Context, arg1 database.InsertPresetParametersParams) ([]database.TemplateVersionPresetParameter, error) {
func (m *MockStore) InsertPresetParameters(ctx context.Context, arg database.InsertPresetParametersParams) ([]database.TemplateVersionPresetParameter, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InsertPresetParameters", arg0, arg1)
ret := m.ctrl.Call(m, "InsertPresetParameters", ctx, arg)
ret0, _ := ret[0].([]database.TemplateVersionPresetParameter)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// InsertPresetParameters indicates an expected call of InsertPresetParameters.
func (mr *MockStoreMockRecorder) InsertPresetParameters(arg0, arg1 any) *gomock.Call {
func (mr *MockStoreMockRecorder) InsertPresetParameters(ctx, arg any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPresetParameters", reflect.TypeOf((*MockStore)(nil).InsertPresetParameters), arg0, arg1)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPresetParameters", reflect.TypeOf((*MockStore)(nil).InsertPresetParameters), ctx, arg)
}
// InsertProvisionerJob mocks base method.

56
coderd/presets_test.go Normal file
View File

@ -0,0 +1,56 @@
package coderd_test
import (
"context"
"testing"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/coderd/coderdtest"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/dbauthz"
"github.com/coder/coder/v2/coderd/httpmw"
"github.com/coder/coder/v2/coderd/rbac"
)
func TestTemplateVersionPresets(t *testing.T) {
t.Parallel()
ctx := context.Background()
client, db := coderdtest.NewWithDatabase(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
user := coderdtest.CreateFirstUser(t, client)
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
// nolint:gocritic // This is a test
provisionerCtx := dbauthz.AsProvisionerd(ctx)
preset, err := db.InsertPreset(provisionerCtx, database.InsertPresetParams{
Name: "My Preset",
TemplateVersionID: version.ID,
})
require.NoError(t, err)
_, err = db.InsertPresetParameters(provisionerCtx, database.InsertPresetParametersParams{
TemplateVersionPresetID: preset.ID,
Names: []string{"preset_param1", "preset_param2"},
Values: []string{"A1B2C3", "D4E5F6"},
})
require.NoError(t, err)
userSubject, _, err := httpmw.UserRBACSubject(ctx, db, user.UserID, rbac.ScopeAll)
require.NoError(t, err)
userCtx := dbauthz.As(ctx, userSubject)
presets, err := client.TemplateVersionPresets(userCtx, version.ID)
require.NoError(t, err)
require.Equal(t, 1, len(presets))
require.Equal(t, "My Preset", presets[0].Name)
presetParams, err := client.TemplateVersionPresetParameters(userCtx, version.ID)
require.NoError(t, err)
require.Equal(t, 2, len(presetParams))
require.Equal(t, "preset_param1", presetParams[0].Name)
require.Equal(t, "A1B2C3", presetParams[0].Value)
require.Equal(t, "preset_param2", presetParams[1].Name)
require.Equal(t, "D4E5F6", presetParams[1].Value)
}

72
coderd/provisionerdserver/provisionerdserver.go
View File

@ -1340,35 +1340,9 @@ func (s *server) CompleteJob(ctx context.Context, completed *proto.CompletedJob)
}
}
for _, preset := range jobType.TemplateImport.Presets {
s.Logger.Info(ctx, "inserting template import job preset",
slog.F("job_id", job.ID.String()),
slog.F("preset_name", preset.Name),
)
dbPreset, err := s.Database.InsertPreset(ctx, database.InsertPresetParams{
TemplateVersionID: input.TemplateVersionID,
Name: preset.Name,
CreatedAt: s.timeNow(),
})
if err != nil {
return nil, xerrors.Errorf("insert preset: %w", err)
}
var presetParameterNames []string
var presetParameterValues []string
for _, parameter := range preset.Parameters {
presetParameterNames = append(presetParameterNames, parameter.Name)
presetParameterValues = append(presetParameterValues, parameter.Value)
}
_, err = s.Database.InsertPresetParameters(ctx, database.InsertPresetParametersParams{
TemplateVersionPresetID: dbPreset.ID,
Names: presetParameterNames,
Values: presetParameterValues,
})
if err != nil {
return nil, xerrors.Errorf("insert preset parameters: %w", err)
}
err = InsertWorkspacePresetsAndParameters(ctx, s.Logger, s.Database, jobID, input.TemplateVersionID, jobType.TemplateImport.Presets, s.timeNow())
if err != nil {
return nil, xerrors.Errorf("insert workspace presets and parameters: %w", err)
}
var completedError sql.NullString
@ -1840,6 +1814,46 @@ func InsertWorkspaceModule(ctx context.Context, db database.Store, jobID uuid.UU
return nil
}
func InsertWorkspacePresetsAndParameters(ctx context.Context, logger slog.Logger, db database.Store, jobID uuid.UUID, templateVersionID uuid.UUID, protoPresets []*sdkproto.Preset, t time.Time) error {
for _, preset := range protoPresets {
logger.Info(ctx, "inserting template import job preset",
slog.F("job_id", jobID.String()),
slog.F("preset_name", preset.Name),
)
if err := InsertWorkspacePresetAndParameters(ctx, db, templateVersionID, preset, t); err != nil {
return xerrors.Errorf("insert workspace preset: %w", err)
}
}
return nil
}
func InsertWorkspacePresetAndParameters(ctx context.Context, db database.Store, templateVersionID uuid.UUID, protoPreset *sdkproto.Preset, t time.Time) error {
dbPreset, err := db.InsertPreset(ctx, database.InsertPresetParams{
TemplateVersionID: templateVersionID,
Name: protoPreset.Name,
CreatedAt: t,
})
if err != nil {
return xerrors.Errorf("insert preset: %w", err)
}
var presetParameterNames []string
var presetParameterValues []string
for _, parameter := range protoPreset.Parameters {
presetParameterNames = append(presetParameterNames, parameter.Name)
presetParameterValues = append(presetParameterValues, parameter.Value)
}
_, err = db.InsertPresetParameters(ctx, database.InsertPresetParametersParams{
TemplateVersionPresetID: dbPreset.ID,
Names: presetParameterNames,
Values: presetParameterValues,
})
if err != nil {
return xerrors.Errorf("insert preset parameters: %w", err)
}
return nil
}
func InsertWorkspaceResource(ctx context.Context, db database.Store, jobID uuid.UUID, transition database.WorkspaceTransition, protoResource *sdkproto.Resource, snapshot *telemetry.Snapshot) error {
resource, err := db.InsertWorkspaceResource(ctx, database.InsertWorkspaceResourceParams{
ID: uuid.New(),

150
coderd/provisionerdserver/provisionerdserver_test.go
View File

@ -30,6 +30,7 @@ import (
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/dbgen"
"github.com/coder/coder/v2/coderd/database/dbmem"
"github.com/coder/coder/v2/coderd/database/dbtestutil"
"github.com/coder/coder/v2/coderd/database/dbtime"
"github.com/coder/coder/v2/coderd/database/pubsub"
"github.com/coder/coder/v2/coderd/externalauth"
@ -1708,6 +1709,155 @@ func TestCompleteJob(t *testing.T) {
})
}
func TestInsertWorkspacePresetsAndParameters(t *testing.T) {
t.Parallel()
type testCase struct {
name string
givenPresets []*sdkproto.Preset
}
testCases := []testCase{
{
name: "no presets",
},
{
name: "one preset with no parameters",
givenPresets: []*sdkproto.Preset{
{
Name: "preset1",
},
},
},
{
name: "one preset with multiple parameters",
givenPresets: []*sdkproto.Preset{
{
Name: "preset1",
Parameters: []*sdkproto.PresetParameter{
{
Name: "param1",
Value: "value1",
},
{
Name: "param2",
Value: "value2",
},
},
},
},
},
{
name: "multiple presets with parameters",
givenPresets: []*sdkproto.Preset{
{
Name: "preset1",
Parameters: []*sdkproto.PresetParameter{
{
Name: "param1",
Value: "value1",
},
{
Name: "param2",
Value: "value2",
},
},
},
{
Name: "preset2",
Parameters: []*sdkproto.PresetParameter{
{
Name: "param3",
Value: "value3",
},
{
Name: "param4",
Value: "value4",
},
},
},
},
},
}
for _, c := range testCases {
c := c
t.Run(c.name, func(t *testing.T) {
t.Parallel()
ctx := context.Background()
logger := testutil.Logger(t)
db, ps := dbtestutil.NewDB(t)
org := dbgen.Organization(t, db, database.Organization{})
user := dbgen.User(t, db, database.User{})
job := dbgen.ProvisionerJob(t, db, ps, database.ProvisionerJob{
Type: database.ProvisionerJobTypeWorkspaceBuild,
OrganizationID: org.ID,
})
templateVersion := dbgen.TemplateVersion(t, db, database.TemplateVersion{
JobID: job.ID,
OrganizationID: org.ID,
CreatedBy: user.ID,
})
err := provisionerdserver.InsertWorkspacePresetsAndParameters(
ctx,
logger,
db,
job.ID,
templateVersion.ID,
c.givenPresets,
time.Now(),
)
require.NoError(t, err)
gotPresets, err := db.GetPresetsByTemplateVersionID(ctx, templateVersion.ID)
require.NoError(t, err)
require.Len(t, gotPresets, len(c.givenPresets))
for _, givenPreset := range c.givenPresets {
foundMatch := false
for _, gotPreset := range gotPresets {
if givenPreset.Name == gotPreset.Name {
foundMatch = true
break
}
}
require.True(t, foundMatch, "preset %s not found in parameters", givenPreset.Name)
}
gotPresetParameters, err := db.GetPresetParametersByTemplateVersionID(ctx, templateVersion.ID)
require.NoError(t, err)
for _, givenPreset := range c.givenPresets {
for _, givenParameter := range givenPreset.Parameters {
foundMatch := false
for _, gotParameter := range gotPresetParameters {
nameMatches := givenParameter.Name == gotParameter.Name
valueMatches := givenParameter.Value == gotParameter.Value
// ensure that preset parameters are matched to the correct preset:
var gotPreset database.GetPresetsByTemplateVersionIDRow
for _, preset := range gotPresets {
if preset.ID == gotParameter.TemplateVersionPresetID {
gotPreset = preset
break
}
}
presetMatches := gotPreset.Name == givenPreset.Name
if nameMatches && valueMatches && presetMatches {
foundMatch = true
break
}
}
require.True(t, foundMatch, "preset parameter %s not found in presets", givenParameter.Name)
}
}
})
}
}
func TestInsertWorkspaceResource(t *testing.T) {
t.Parallel()
ctx := context.Background()