May 20, 2024 · May 16, 2024 · May 16, 2024 · May 16, 2024 · May 17, 2024 · May 17, 2024
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
 return q.db.GetTemplateVersionVariables(ctx, templateVersionID)
 }

 func (q *querier) GetTemplateVersionWorkspaceTags(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionWorkspaceTag, error) {
 tv, err := q.db.GetTemplateVersionByID(ctx, templateVersionID)
 if err != nil {
 return nil, err
 }

 var object rbac.Objecter
 template, err := q.db.GetTemplateByID(ctx, tv.TemplateID.UUID)
 if err != nil {
 if !errors.Is(err, sql.ErrNoRows) {
 return nil, err
 }
 object = rbac.ResourceTemplate.InOrg(tv.OrganizationID)
 } else {
 object = tv.RBACObject(template)
 }

 if err := q.authorizeContext(ctx, policy.ActionRead, object); err != nil {
 return nil, err
 }
 return q.db.GetTemplateVersionWorkspaceTags(ctx, templateVersionID)
 }

 // GetTemplateVersionsByIDs is only used for workspace build data.
 // The workspace is already fetched.
 func (q *querier) GetTemplateVersionsByIDs(ctx context.Context, ids []uuid.UUID) ([]database.TemplateVersion, error) {
 return q.db.InsertTemplateVersionVariable(ctx, arg)
 }

 func (q *querier) InsertTemplateVersionWorkspaceTag(ctx context.Context, arg database.InsertTemplateVersionWorkspaceTagParams) (database.TemplateVersionWorkspaceTag, error) {
 if err := q.authorizeContext(ctx, policy.ActionCreate, rbac.ResourceSystem); err != nil {
 return database.TemplateVersionWorkspaceTag{}, err
 }
 return q.db.InsertTemplateVersionWorkspaceTag(ctx, arg)
 }

 func (q *querier) InsertUser(ctx context.Context, arg database.InsertUserParams) (database.User, error) {
 // Always check if the assigned roles can actually be assigned by this actor.
 impliedRoles := append([]string{rbac.RoleMember()}, arg.RBACRoles...)
diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
 })
 check.Args(tv.ID).Asserts(t1, policy.ActionRead).Returns([]database.TemplateVersionVariable{tvv1})
 }))
 s.Run("GetTemplateVersionWorkspaceTags", s.Subtest(func(db database.Store, check *expects) {
 t1 := dbgen.Template(s.T(), db, database.Template{})
 tv := dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
 TemplateID: uuid.NullUUID{UUID: t1.ID, Valid: true},
 })
 wt1 := dbgen.TemplateVersionWorkspaceTag(s.T(), db, database.TemplateVersionWorkspaceTag{
 TemplateVersionID: tv.ID,
 })
 check.Args(tv.ID).Asserts(t1, policy.ActionRead).Returns([]database.TemplateVersionWorkspaceTag{wt1})
 }))
 s.Run("GetTemplateGroupRoles", s.Subtest(func(db database.Store, check *expects) {
 t1 := dbgen.Template(s.T(), db, database.Template{})
 check.Args(t1.ID).Asserts(t1, policy.ActionUpdate)
 s.Run("InsertTemplateVersionVariable", s.Subtest(func(db database.Store, check *expects) {
 check.Args(database.InsertTemplateVersionVariableParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
 }))
 s.Run("InsertTemplateVersionWorkspaceTag", s.Subtest(func(db database.Store, check *expects) {
 check.Args(database.InsertTemplateVersionWorkspaceTagParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
 }))
 s.Run("UpdateInactiveUsersToDormant", s.Subtest(func(db database.Store, check *expects) {
 check.Args(database.UpdateInactiveUsersToDormantParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate).Errors(sql.ErrNoRows)
 }))
diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
 return version
 }

 func TemplateVersionWorkspaceTag(t testing.TB, db database.Store, orig database.TemplateVersionWorkspaceTag) database.TemplateVersionWorkspaceTag {
 workspaceTag, err := db.InsertTemplateVersionWorkspaceTag(genCtx, database.InsertTemplateVersionWorkspaceTagParams{
 TemplateVersionID: takeFirst(orig.TemplateVersionID, uuid.New()),
 Key:               takeFirst(orig.Key, namesgenerator.GetRandomName(1)),
 Value:             takeFirst(orig.Value, namesgenerator.GetRandomName(1)),
 })
 require.NoError(t, err, "insert template version workspace tag")
 return workspaceTag
 }

 func TemplateVersionParameter(t testing.TB, db database.Store, orig database.TemplateVersionParameter) database.TemplateVersionParameter {
 t.Helper()

diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
 templateVersions              []database.TemplateVersionTable
 templateVersionParameters     []database.TemplateVersionParameter
 templateVersionVariables      []database.TemplateVersionVariable
 templateVersionWorkspaceTags  []database.TemplateVersionWorkspaceTag
 templates                     []database.TemplateTable
 templateUsageStats            []database.TemplateUsageStat
 workspaceAgents               []database.WorkspaceAgent
 return variables, nil
 }

 func (q *FakeQuerier) GetTemplateVersionWorkspaceTags(_ context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionWorkspaceTag, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()

 workspaceTags := make([]database.TemplateVersionWorkspaceTag, 0)
 for _, workspaceTag := range q.templateVersionWorkspaceTags {
 if workspaceTag.TemplateVersionID != templateVersionID {
 continue
 }
 workspaceTags = append(workspaceTags, workspaceTag)
 }

 sort.Slice(workspaceTags, func(i, j int) bool {
 return workspaceTags[i].Key < workspaceTags[j].Key
 })
 return workspaceTags, nil
 }

 func (q *FakeQuerier) GetTemplateVersionsByIDs(_ context.Context, ids []uuid.UUID) ([]database.TemplateVersion, error) {
 q.mutex.RLock()
 defer q.mutex.RUnlock()
 return variable, nil
 }

 func (q *FakeQuerier) InsertTemplateVersionWorkspaceTag(_ context.Context, arg database.InsertTemplateVersionWorkspaceTagParams) (database.TemplateVersionWorkspaceTag, error) {
 err := validateDatabaseType(arg)
 if err != nil {
 return database.TemplateVersionWorkspaceTag{}, err
 }

 q.mutex.Lock()
 defer q.mutex.Unlock()

 //nolint:gosimple
 workspaceTag := database.TemplateVersionWorkspaceTag{
 TemplateVersionID: arg.TemplateVersionID,
 Key:               arg.Key,
 Value:             arg.Value,
 }
 q.templateVersionWorkspaceTags = append(q.templateVersionWorkspaceTags, workspaceTag)
 return workspaceTag, nil
 }

 func (q *FakeQuerier) InsertUser(_ context.Context, arg database.InsertUserParams) (database.User, error) {
 if err := validateDatabaseType(arg); err != nil {
 return database.User{}, err
diff --git a/coderd/database/dbmetrics/dbmetrics.go b/coderd/database/dbmetrics/dbmetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/dump.sql b/coderd/database/dump.sql
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1786,6 +1786,29 @@ func (q *querier) GetTemplateVersionVariables(ctx context.Context, templateVersi
		return q.db.GetTemplateVersionVariables(ctx, templateVersionID)
		}

		func (q *querier) GetTemplateVersionWorkspaceTags(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionWorkspaceTag, error) {
		tv, err := q.db.GetTemplateVersionByID(ctx, templateVersionID)
		if err != nil {
		return nil, err
		}

		var object rbac.Objecter
		template, err := q.db.GetTemplateByID(ctx, tv.TemplateID.UUID)
		if err != nil {
		if !errors.Is(err, sql.ErrNoRows) {
		return nil, err
		}
		object = rbac.ResourceTemplate.InOrg(tv.OrganizationID)
		} else {
		object = tv.RBACObject(template)
		}

		if err := q.authorizeContext(ctx, policy.ActionRead, object); err != nil {
		return nil, err
		}
		return q.db.GetTemplateVersionWorkspaceTags(ctx, templateVersionID)
		}

		// GetTemplateVersionsByIDs is only used for workspace build data.
		// The workspace is already fetched.
		func (q *querier) GetTemplateVersionsByIDs(ctx context.Context, ids []uuid.UUID) ([]database.TemplateVersion, error) {
Expand DownExpand Up		@@ -2507,6 +2530,13 @@ func (q *querier) InsertTemplateVersionVariable(ctx context.Context, arg databas
		return q.db.InsertTemplateVersionVariable(ctx, arg)
		}

		func (q *querier) InsertTemplateVersionWorkspaceTag(ctx context.Context, arg database.InsertTemplateVersionWorkspaceTagParams) (database.TemplateVersionWorkspaceTag, error) {
		if err := q.authorizeContext(ctx, policy.ActionCreate, rbac.ResourceSystem); err != nil {
		return database.TemplateVersionWorkspaceTag{}, err
		}
		return q.db.InsertTemplateVersionWorkspaceTag(ctx, arg)
		}

mtojek marked this conversation as resolved. Show resolvedHide resolved
		func (q *querier) InsertUser(ctx context.Context, arg database.InsertUserParams) (database.User, error) {
		// Always check if the assigned roles can actually be assigned by this actor.
		impliedRoles := append([]string{rbac.RoleMember()}, arg.RBACRoles...)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -778,6 +778,16 @@ func (s *MethodTestSuite) TestTemplate() {
		})
		check.Args(tv.ID).Asserts(t1, policy.ActionRead).Returns([]database.TemplateVersionVariable{tvv1})
		}))
		s.Run("GetTemplateVersionWorkspaceTags", s.Subtest(func(db database.Store, check *expects) {
		t1 := dbgen.Template(s.T(), db, database.Template{})
		tv := dbgen.TemplateVersion(s.T(), db, database.TemplateVersion{
		TemplateID: uuid.NullUUID{UUID: t1.ID, Valid: true},
		})
		wt1 := dbgen.TemplateVersionWorkspaceTag(s.T(), db, database.TemplateVersionWorkspaceTag{
		TemplateVersionID: tv.ID,
		})
		check.Args(tv.ID).Asserts(t1, policy.ActionRead).Returns([]database.TemplateVersionWorkspaceTag{wt1})
		}))
		s.Run("GetTemplateGroupRoles", s.Subtest(func(db database.Store, check *expects) {
		t1 := dbgen.Template(s.T(), db, database.Template{})
		check.Args(t1.ID).Asserts(t1, policy.ActionUpdate)
Expand DownExpand Up		@@ -2339,6 +2349,9 @@ func (s *MethodTestSuite) TestSystemFunctions() {
		s.Run("InsertTemplateVersionVariable", s.Subtest(func(db database.Store, check *expects) {
		check.Args(database.InsertTemplateVersionVariableParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
		}))
		s.Run("InsertTemplateVersionWorkspaceTag", s.Subtest(func(db database.Store, check *expects) {
		check.Args(database.InsertTemplateVersionWorkspaceTagParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
		}))
		s.Run("UpdateInactiveUsersToDormant", s.Subtest(func(db database.Store, check *expects) {
		check.Args(database.UpdateInactiveUsersToDormantParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate).Errors(sql.ErrNoRows)
		}))
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -678,6 +678,16 @@ func TemplateVersionVariable(t testing.TB, db database.Store, orig database.Temp
		return version
		}

		func TemplateVersionWorkspaceTag(t testing.TB, db database.Store, orig database.TemplateVersionWorkspaceTag) database.TemplateVersionWorkspaceTag {
		workspaceTag, err := db.InsertTemplateVersionWorkspaceTag(genCtx, database.InsertTemplateVersionWorkspaceTagParams{
		TemplateVersionID: takeFirst(orig.TemplateVersionID, uuid.New()),
		Key: takeFirst(orig.Key, namesgenerator.GetRandomName(1)),
		Value: takeFirst(orig.Value, namesgenerator.GetRandomName(1)),
		})
		require.NoError(t, err, "insert template version workspace tag")
		return workspaceTag
		}

		func TemplateVersionParameter(t testing.TB, db database.Store, orig database.TemplateVersionParameter) database.TemplateVersionParameter {
		t.Helper()

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -163,6 +163,7 @@ type data struct {
		templateVersions []database.TemplateVersionTable
		templateVersionParameters []database.TemplateVersionParameter
		templateVersionVariables []database.TemplateVersionVariable
		templateVersionWorkspaceTags []database.TemplateVersionWorkspaceTag
		templates []database.TemplateTable
		templateUsageStats []database.TemplateUsageStat
		workspaceAgents []database.WorkspaceAgent
Expand DownExpand Up		@@ -4177,6 +4178,24 @@ func (q *FakeQuerier) GetTemplateVersionVariables(_ context.Context, templateVer
		return variables, nil
		}

		func (q *FakeQuerier) GetTemplateVersionWorkspaceTags(_ context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionWorkspaceTag, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()

		workspaceTags := make([]database.TemplateVersionWorkspaceTag, 0)
		for _, workspaceTag := range q.templateVersionWorkspaceTags {
		if workspaceTag.TemplateVersionID != templateVersionID {
		continue
		}
		workspaceTags = append(workspaceTags, workspaceTag)
		}

		sort.Slice(workspaceTags, func(i, j int) bool {
		return workspaceTags[i].Key < workspaceTags[j].Key
		})
		return workspaceTags, nil
		}

		func (q *FakeQuerier) GetTemplateVersionsByIDs(_ context.Context, ids []uuid.UUID) ([]database.TemplateVersion, error) {
		q.mutex.RLock()
		defer q.mutex.RUnlock()
Expand DownExpand Up		@@ -6352,6 +6371,25 @@ func (q *FakeQuerier) InsertTemplateVersionVariable(_ context.Context, arg datab
		return variable, nil
		}

		func (q *FakeQuerier) InsertTemplateVersionWorkspaceTag(_ context.Context, arg database.InsertTemplateVersionWorkspaceTagParams) (database.TemplateVersionWorkspaceTag, error) {
		err := validateDatabaseType(arg)
		if err != nil {
		return database.TemplateVersionWorkspaceTag{}, err
		}

		q.mutex.Lock()
		defer q.mutex.Unlock()

		//nolint:gosimple
		workspaceTag := database.TemplateVersionWorkspaceTag{
		TemplateVersionID: arg.TemplateVersionID,
		Key: arg.Key,
		Value: arg.Value,
		}
		q.templateVersionWorkspaceTags = append(q.templateVersionWorkspaceTags, workspaceTag)
		return workspaceTag, nil
		}

		func (q *FakeQuerier) InsertUser(_ context.Context, arg database.InsertUserParams) (database.User, error) {
		if err := validateDatabaseType(arg); err != nil {
		return database.User{}, err
Expand Down