## Stack Organization skills load into every member's Coder Agents chats in their organization, with no way for a member to opt out. This stack adds a per-organization setting that lets members turn them off for their own chats, bottom to top: 1. **#31134** data model, API, and chatd (this PR) 2. #31135 admin and member controls in the dashboard, the `/` menu, and docs ## What changes Organizations get `members_can_disable_skills`, off by default. Users who can update organization skills change it with `PUT /api/experimental/organizations/{organization}/skill-settings`, which writes an organization audit entry. Anyone who can read the organization can `GET` it. While the setting is on, each member saves their own choices with `PATCH /api/experimental/organizations/{organization}/members/{user}/skill-preferences`: `all_skills_disabled` (a master switch that also covers skills created later) and `skills`, a sparse map from skill ID to on or off. `GET` returns the setting, the master switch, and `disabled_skill_ids`. The routes follow the personal-settings rules: without `read_personal` or `update_personal` on that user the caller gets 404, a PATCH while the setting is off gets 403, and a key that is not an organization skill that member can read gets a 400 that names the key. The check runs as the member, not the caller, so an owner or user admin editing someone else's choices is held to that member's skills. Turning the setting off keeps the choices but ignores them. Migration 000636 adds the column and two tables keyed by organization membership. Both cascade when the membership goes away, and the per-skill table also cascades when the skill is deleted, so a recreated skill loads by default. chatd reads the preferences as the chat owner when it builds the skill index and when it loads a body for `read_skill` or for a structured skill invocation (#30861). A skill the member turned off is left out of the index, and both loads report it as not found, including later in a running chat. If the preferences cannot be read, turn preparation fails, as it already does when the skill metadata cannot be read. Older migration tests created organizations with `dbgen.Organization` and `GetDefaultOrganization`, which now select the new column before it exists, so they insert organizations with raw SQL instead. ## Review focus - Authorization in `coderd/organizationskillpreferences.go` and the five new dbauthz methods (`read_personal` and `update_personal` on the user, `organization_skill` update for the setting). - `GetOrganizationSkillMemberPreferencesRow.Excludes` is the one rule chatd applies; #31135 mirrors it in `activeOrganizationSkills`. ## Testing - Go tests cover the queries and cascades, dbauthz, both routes (including the audit diff and each 400 case), and chatd (index, `read_skill`, skill invocations, master switch, a change during a chat). Each new test fails with its code path removed. - Remote dogfood UAT (10 scenarios, real model) passed on the pre-split branch head `186c28d81ab`, which has the same code except the fix below. It found one issue: two spellings of one skill ID with opposite values stored a random result. The PATCH now rejects every aliased key with a 400. A second run on the stack's top head at the time, `718dd6d1bd1`, passed: every aliased form returns 400 and stores nothing, and chats leave out a skill the member turned off, including in `read_skill`. - Polish and the test audit stayed inside the implementation diff. No new dependencies. - Rebased on main as one commit. The migration is now 000636, after main's 000634 and 000635. Every organization skill load passes the chat owner, including main's skill invocation path, so `/skill` invocations honor the opt-out too. The model's skill index leaves out a skill that is not model-invocable or that the member turned off. Apart from that, the diff is unchanged. > Xum, an AI agent, opened this PR for @ibetitsmike and wrote this description.
623 lines
25 KiB
Go
623 lines
25 KiB
Go
package database_test
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"cdr.dev/slog/v3/sloggers/slogtest"
|
|
"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/database/dbgen"
|
|
"github.com/coder/coder/v2/coderd/database/dbtestutil"
|
|
"github.com/coder/coder/v2/coderd/httpmw"
|
|
"github.com/coder/coder/v2/coderd/rbac"
|
|
"github.com/coder/coder/v2/coderd/rbac/policy"
|
|
"github.com/coder/coder/v2/coderd/x/skills"
|
|
"github.com/coder/coder/v2/testutil"
|
|
)
|
|
|
|
func TestUserSkillSchemaConstants(t *testing.T) {
|
|
t.Parallel()
|
|
if testing.Short() {
|
|
t.SkipNow()
|
|
}
|
|
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
_, _, sqlDB := dbtestutil.NewDBWithSQLDB(t)
|
|
var triggerDef string
|
|
err := sqlDB.QueryRowContext(ctx,
|
|
`SELECT pg_get_functiondef('enforce_skills_per_owner_limit'::regproc)`,
|
|
).Scan(&triggerDef)
|
|
require.NoError(t, err)
|
|
require.Contains(t, triggerDef, fmt.Sprintf(
|
|
"skill_limit constant int := %d",
|
|
skills.MaxPersonalSkillsPerUser,
|
|
))
|
|
|
|
constraints := map[database.CheckConstraint]string{
|
|
database.CheckSkillsNameSize: fmt.Sprintf(
|
|
"octet_length(name) <= %d",
|
|
skills.MaxPersonalSkillNameBytes,
|
|
),
|
|
database.CheckSkillsNameFormat: "name ~ '^[a-z0-9]+(-[a-z0-9]+)*$'::text",
|
|
database.CheckSkillsDescriptionSize: fmt.Sprintf(
|
|
"octet_length(description) <= %d",
|
|
skills.MaxPersonalSkillDescriptionBytes,
|
|
),
|
|
database.CheckSkillsContentSize: fmt.Sprintf(
|
|
"octet_length(content) <= %d",
|
|
skills.MaxPersonalSkillSizeBytes,
|
|
),
|
|
}
|
|
for constraint, expected := range constraints {
|
|
t.Run(string(constraint), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
var constraintDef string
|
|
err := sqlDB.QueryRowContext(ctx,
|
|
`SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conname = $1`,
|
|
constraint,
|
|
).Scan(&constraintDef)
|
|
require.NoError(t, err)
|
|
require.Contains(t, constraintDef, expected)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSkillOwners(t *testing.T) {
|
|
t.Parallel()
|
|
if testing.Short() {
|
|
t.SkipNow()
|
|
}
|
|
|
|
db, _, sqlDB := dbtestutil.NewDBWithSQLDB(t)
|
|
|
|
type owners struct {
|
|
user, org, project uuid.NullUUID
|
|
}
|
|
type skillRow struct {
|
|
owners
|
|
name string
|
|
enabled, action bool
|
|
groupACL, userACL string
|
|
}
|
|
insertSkill := func(ctx context.Context, q interface {
|
|
ExecContext(context.Context, string, ...any) (sql.Result, error)
|
|
}, row skillRow,
|
|
) error {
|
|
if row.name == "" {
|
|
row.name = "skill-" + uuid.NewString()
|
|
}
|
|
if row.groupACL == "" {
|
|
row.groupACL = "{}"
|
|
}
|
|
if row.userACL == "" {
|
|
row.userACL = "{}"
|
|
}
|
|
_, err := q.ExecContext(ctx, `
|
|
INSERT INTO skills (id, user_id, organization_id, project_id, name, description, content, enabled, action, group_acl, user_acl)
|
|
VALUES ($1, $2, $3, $4, $5, 'desc', 'body', $6, $7, $8::jsonb, $9::jsonb)`,
|
|
uuid.New(), row.user, row.org, row.project, row.name, row.enabled, row.action, row.groupACL, row.userACL)
|
|
return err
|
|
}
|
|
countSkills := func(ctx context.Context, column string, id uuid.UUID) int {
|
|
var count int
|
|
//nolint:gosec // column is a fixed owner column name from this test.
|
|
err := sqlDB.QueryRowContext(ctx, "SELECT count(*) FROM skills WHERE "+column+" = $1", id).Scan(&count)
|
|
require.NoError(t, err)
|
|
return count
|
|
}
|
|
valid := func(id uuid.UUID) uuid.NullUUID { return uuid.NullUUID{UUID: id, Valid: true} }
|
|
newUser := func() uuid.UUID { return dbgen.User(t, db, database.User{}).ID }
|
|
newOrg := func() uuid.UUID { return dbgen.Organization(t, db, database.Organization{}).ID }
|
|
newProject := func() uuid.UUID {
|
|
org := newOrg()
|
|
return dbgen.ChatProject(t, db, database.ChatProject{OrganizationID: org, OwnerID: newUser()}).ID
|
|
}
|
|
|
|
t.Run("ExactlyOneOwner", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
user, org, project := valid(newUser()), valid(newOrg()), valid(newProject())
|
|
for _, o := range []owners{
|
|
{},
|
|
{user: user, org: org},
|
|
{org: org, project: project},
|
|
{user: user, project: project},
|
|
} {
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: o, enabled: true})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsSingleOwner), "owners %+v: %v", o, err)
|
|
}
|
|
})
|
|
|
|
t.Run("ACLOnlyOnOrganizationSkills", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
grant := `{"` + uuid.NewString() + `": {"permissions": ["read"]}}`
|
|
for _, o := range []owners{{user: valid(newUser())}, {project: valid(newProject())}} {
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: o, groupACL: grant})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsAclOnlyOnOrganizationSkills), "group ACL %+v: %v", o, err)
|
|
err = insertSkill(ctx, sqlDB, skillRow{owners: o, userACL: grant})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsAclOnlyOnOrganizationSkills), "user ACL %+v: %v", o, err)
|
|
}
|
|
|
|
org := owners{org: valid(newOrg())}
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: org, groupACL: grant, userACL: grant}))
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: org, groupACL: "[]"})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsGroupAclIsObject), err)
|
|
err = insertSkill(ctx, sqlDB, skillRow{owners: org, userACL: "[]"})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsUserAclIsObject), err)
|
|
})
|
|
|
|
t.Run("ActionOnlyOnProjectSkills", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
for _, o := range []owners{{user: valid(newUser())}, {org: valid(newOrg())}} {
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: o, action: true})
|
|
require.True(t, database.IsCheckViolation(err, database.CheckSkillsActionProjectOnly), "owners %+v: %v", o, err)
|
|
}
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: owners{project: valid(newProject())}, action: true}))
|
|
})
|
|
|
|
// TestUserSkillLimit and TestUserSkillLimitConcurrentCreates in coderd
|
|
// cover the user branch of the cap trigger.
|
|
t.Run("CapPerProject", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitLong)
|
|
full := owners{project: valid(newProject())}
|
|
for range skills.MaxPersonalSkillsPerUser {
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: full, enabled: true}))
|
|
}
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: full, enabled: true})
|
|
require.True(t, database.IsCheckViolation(err, "skills_per_project_limit"), err)
|
|
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: owners{project: valid(newProject())}, enabled: true}))
|
|
})
|
|
|
|
t.Run("ConcurrentOrganizationInsertsHonorCap", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitLong)
|
|
org := valid(newOrg())
|
|
for i := range skills.MaxPersonalSkillsPerUser - 1 {
|
|
// Disabled rows count toward the cap.
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: owners{org: org}, enabled: i%2 == 0}))
|
|
}
|
|
|
|
tx, err := sqlDB.BeginTx(ctx, nil)
|
|
require.NoError(t, err)
|
|
defer func() { _ = tx.Rollback() }()
|
|
require.NoError(t, insertSkill(ctx, tx, skillRow{owners: owners{org: org}, enabled: true}))
|
|
|
|
// Foreign key checks from unrelated inserts take KEY SHARE on the
|
|
// organization row, which the cap lock must not block.
|
|
_, err = sqlDB.ExecContext(ctx, "SELECT 1 FROM organizations WHERE id = $1 FOR KEY SHARE NOWAIT", org.UUID)
|
|
require.NoError(t, err)
|
|
|
|
concurrent := make(chan error, 1)
|
|
go func() {
|
|
concurrent <- insertSkill(ctx, sqlDB, skillRow{owners: owners{org: org}, enabled: true})
|
|
}()
|
|
// Commit only after the concurrent insert waits on the cap lock, so
|
|
// it cannot finish before the transaction by chance.
|
|
require.Eventually(t, func() bool {
|
|
if len(concurrent) > 0 {
|
|
return true
|
|
}
|
|
var waiting bool
|
|
err := sqlDB.QueryRowContext(ctx, `SELECT EXISTS (
|
|
SELECT 1 FROM pg_stat_activity
|
|
WHERE datname = current_database() AND wait_event_type = 'Lock' AND query LIKE '%INSERT INTO skills%'
|
|
)`).Scan(&waiting)
|
|
return err == nil && waiting
|
|
}, testutil.WaitShort, testutil.IntervalFast)
|
|
require.NoError(t, tx.Commit())
|
|
|
|
err = testutil.RequireReceive(ctx, t, concurrent)
|
|
require.True(t, database.IsCheckViolation(err, "skills_per_organization_limit"), err)
|
|
require.Equal(t, skills.MaxPersonalSkillsPerUser, countSkills(ctx, "organization_id", org.UUID))
|
|
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: owners{org: valid(newOrg())}, enabled: true}))
|
|
})
|
|
|
|
t.Run("NamesUniquePerOwner", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
const name = "shared-name"
|
|
user, org, otherOrg, project := valid(newUser()), valid(newOrg()), valid(newOrg()), valid(newProject())
|
|
for _, o := range []owners{{user: user}, {org: org}, {org: otherOrg}, {project: project}} {
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: o, name: name}))
|
|
}
|
|
|
|
err := insertSkill(ctx, sqlDB, skillRow{owners: owners{user: user}, name: name})
|
|
require.True(t, database.IsUniqueViolation(err, database.UniqueSkillsUserIDNameIndex), err)
|
|
err = insertSkill(ctx, sqlDB, skillRow{owners: owners{org: org}, name: name})
|
|
require.True(t, database.IsUniqueViolation(err, database.UniqueSkillsOrganizationIDNameIndex), err)
|
|
err = insertSkill(ctx, sqlDB, skillRow{owners: owners{project: project}, name: name})
|
|
require.True(t, database.IsUniqueViolation(err, database.UniqueSkillsProjectIDNameIndex), err)
|
|
})
|
|
|
|
t.Run("MemberRemovalDropsDirectGrants", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
org, otherOrg := newOrg(), newOrg()
|
|
removed, kept := newUser(), newUser()
|
|
for _, o := range []uuid.UUID{org, otherOrg} {
|
|
dbgen.OrganizationMember(t, db, database.OrganizationMember{OrganizationID: o, UserID: removed})
|
|
grants := fmt.Sprintf(`{%q: {"permissions": ["read"]}, %q: {"permissions": ["read"]}}`, removed, kept)
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: owners{org: valid(o)}, userACL: grants}))
|
|
}
|
|
|
|
require.NoError(t, db.DeleteOrganizationMember(ctx, database.DeleteOrganizationMemberParams{OrganizationID: org, UserID: removed}))
|
|
|
|
hasGrant := func(org, user uuid.UUID) bool {
|
|
t.Helper()
|
|
var has bool
|
|
err := sqlDB.QueryRowContext(ctx, "SELECT user_acl ? $2 FROM skills WHERE organization_id = $1", org, user.String()).Scan(&has)
|
|
require.NoError(t, err)
|
|
return has
|
|
}
|
|
require.False(t, hasGrant(org, removed))
|
|
require.True(t, hasGrant(org, kept))
|
|
require.True(t, hasGrant(otherOrg, removed))
|
|
})
|
|
|
|
t.Run("OwnerDeletionRemovesOnlyOwnRows", func(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
user, deletedUser := newUser(), newUser()
|
|
org, deletedOrg := newOrg(), newOrg()
|
|
project := dbgen.ChatProject(t, db, database.ChatProject{OrganizationID: org, OwnerID: deletedUser}).ID
|
|
deletedProject := dbgen.ChatProject(t, db, database.ChatProject{OrganizationID: org, OwnerID: deletedUser}).ID
|
|
for _, o := range []owners{
|
|
{user: valid(user)},
|
|
{user: valid(deletedUser)},
|
|
{org: valid(org)},
|
|
{org: valid(deletedOrg)},
|
|
{project: valid(project)},
|
|
{project: valid(deletedProject)},
|
|
} {
|
|
require.NoError(t, insertSkill(ctx, sqlDB, skillRow{owners: o}))
|
|
}
|
|
|
|
_, err := sqlDB.ExecContext(ctx, "UPDATE users SET deleted = true WHERE id = $1", deletedUser)
|
|
require.NoError(t, err)
|
|
_, err = sqlDB.ExecContext(ctx, "DELETE FROM organizations WHERE id = $1", deletedOrg)
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.DeleteChatProjectByID(ctx, deletedProject))
|
|
|
|
require.Equal(t, 1, countSkills(ctx, "user_id", user))
|
|
require.Equal(t, 0, countSkills(ctx, "user_id", deletedUser))
|
|
require.Equal(t, 1, countSkills(ctx, "organization_id", org))
|
|
require.Equal(t, 0, countSkills(ctx, "organization_id", deletedOrg))
|
|
// The soft-deleted user's project keeps its skills.
|
|
require.Equal(t, 1, countSkills(ctx, "project_id", project))
|
|
require.Equal(t, 0, countSkills(ctx, "project_id", deletedProject))
|
|
})
|
|
}
|
|
|
|
// TestOrganizationSkillQueries runs the organization skill queries that only
|
|
// execute against Postgres here: the SQL-filtered list, whose regosql
|
|
// converter must agree with the Rego ACL rules, and the update and delete
|
|
// statements.
|
|
func TestOrganizationSkillQueries(t *testing.T) {
|
|
t.Parallel()
|
|
if testing.Short() {
|
|
t.SkipNow()
|
|
}
|
|
|
|
ctx := testutil.Context(t, testutil.WaitLong)
|
|
db, _ := dbtestutil.NewDB(t)
|
|
authzDB := dbauthz.New(db, rbac.NewStrictCachingAuthorizer(prometheus.NewRegistry()), slogtest.Make(t, nil), coderdtest.AccessControlStorePointer())
|
|
|
|
org := dbgen.Organization(t, db, database.Organization{})
|
|
otherOrg := dbgen.Organization(t, db, database.Organization{})
|
|
group := dbgen.Group(t, db, database.Group{OrganizationID: org.ID})
|
|
newUser := func(siteRoles []string, orgID uuid.UUID, orgRoles ...string) uuid.UUID {
|
|
user := dbgen.User(t, db, database.User{RBACRoles: siteRoles})
|
|
if orgID != uuid.Nil {
|
|
dbgen.OrganizationMember(t, db, database.OrganizationMember{UserID: user.ID, OrganizationID: orgID, Roles: orgRoles})
|
|
}
|
|
return user.ID
|
|
}
|
|
var (
|
|
siteOwner = newUser([]string{rbac.RoleOwner().String()}, uuid.Nil)
|
|
orgAdmin = newUser(nil, org.ID, rbac.RoleOrgAdmin())
|
|
groupMember = newUser(nil, org.ID)
|
|
grantedMember = newUser(nil, org.ID)
|
|
grantedOutside = newUser(nil, uuid.Nil)
|
|
)
|
|
dbgen.GroupMember(t, db, database.GroupMemberTable{UserID: groupMember, GroupID: group.ID})
|
|
|
|
read := database.ChatACLEntry{Permissions: []policy.Action{policy.ActionRead}}
|
|
orgSkill := func(groupACL, userACL database.ChatACL) database.Skill {
|
|
return dbgen.OrganizationSkill(t, db, database.Skill{
|
|
OrganizationID: uuid.NullUUID{UUID: org.ID, Valid: true},
|
|
GroupACL: groupACL,
|
|
UserACL: userACL,
|
|
})
|
|
}
|
|
everyoneSkill := orgSkill(database.ChatACL{org.ID.String(): read}, nil)
|
|
groupSkill := orgSkill(database.ChatACL{group.ID.String(): read}, nil)
|
|
userSkill := orgSkill(nil, database.ChatACL{grantedMember.String(): read, grantedOutside.String(): read})
|
|
privateSkill := orgSkill(nil, nil)
|
|
dbgen.OrganizationSkill(t, db, database.Skill{
|
|
OrganizationID: uuid.NullUUID{UUID: otherOrg.ID, Valid: true},
|
|
GroupACL: database.ChatACL{otherOrg.ID.String(): read},
|
|
})
|
|
|
|
as := func(userID uuid.UUID) context.Context {
|
|
subject, _, err := httpmw.UserRBACSubject(ctx, db, userID, rbac.ExpandableScope(rbac.ScopeAll))
|
|
require.NoError(t, err)
|
|
return dbauthz.As(ctx, subject)
|
|
}
|
|
all := []uuid.UUID{everyoneSkill.ID, groupSkill.ID, userSkill.ID, privateSkill.ID}
|
|
for name, tc := range map[string]struct {
|
|
user uuid.UUID
|
|
want []uuid.UUID
|
|
}{
|
|
"SiteOwner": {siteOwner, all},
|
|
"OrgAdmin": {orgAdmin, all},
|
|
"GroupMember": {groupMember, []uuid.UUID{everyoneSkill.ID, groupSkill.ID}},
|
|
"GrantedMember": {grantedMember, []uuid.UUID{everyoneSkill.ID, userSkill.ID}},
|
|
"GrantedOutside": {grantedOutside, nil},
|
|
} {
|
|
rows, err := authzDB.ListOrganizationSkillMetadataByOrganizationID(as(tc.user), org.ID)
|
|
require.NoError(t, err, name)
|
|
got := make([]uuid.UUID, 0, len(rows))
|
|
for _, row := range rows {
|
|
got = append(got, row.ID)
|
|
}
|
|
require.ElementsMatch(t, tc.want, got, name)
|
|
}
|
|
|
|
updated, err := authzDB.UpdateOrganizationSkillByOrganizationIDAndName(as(orgAdmin), database.UpdateOrganizationSkillByOrganizationIDAndNameParams{
|
|
OrganizationID: org.ID, Name: groupSkill.Name, Enabled: sql.NullBool{Bool: false, Valid: true},
|
|
})
|
|
require.NoError(t, err)
|
|
require.False(t, updated.Enabled)
|
|
require.Equal(t, groupSkill.Content, updated.Content)
|
|
deleted, err := authzDB.DeleteOrganizationSkillByOrganizationIDAndName(as(orgAdmin), database.DeleteOrganizationSkillByOrganizationIDAndNameParams{
|
|
OrganizationID: org.ID, Name: groupSkill.Name,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, groupSkill.ID, deleted.ID)
|
|
}
|
|
|
|
func TestProjectSkillQueries(t *testing.T) {
|
|
t.Parallel()
|
|
if testing.Short() {
|
|
t.SkipNow()
|
|
}
|
|
|
|
ctx := testutil.Context(t, testutil.WaitLong)
|
|
db, _ := dbtestutil.NewDB(t)
|
|
authzDB := dbauthz.New(db, rbac.NewStrictCachingAuthorizer(prometheus.NewRegistry()), slogtest.Make(t, nil), coderdtest.AccessControlStorePointer())
|
|
|
|
org := dbgen.Organization(t, db, database.Organization{})
|
|
newMember := func(orgRoles ...string) uuid.UUID {
|
|
user := dbgen.User(t, db, database.User{})
|
|
dbgen.OrganizationMember(t, db, database.OrganizationMember{UserID: user.ID, OrganizationID: org.ID, Roles: orgRoles})
|
|
return user.ID
|
|
}
|
|
var (
|
|
projectOwner = newMember()
|
|
orgAdmin = newMember(rbac.RoleOrgAdmin())
|
|
otherMember = newMember()
|
|
reader = newMember()
|
|
)
|
|
project := dbgen.ChatProject(t, db, database.ChatProject{OrganizationID: org.ID, OwnerID: projectOwner})
|
|
require.NoError(t, db.UpdateChatProjectACLByID(ctx, database.UpdateChatProjectACLByIDParams{
|
|
ID: project.ID,
|
|
UserACL: database.ChatACL{reader.String(): {Permissions: []policy.Action{policy.ActionRead}}},
|
|
GroupACL: database.ChatACL{},
|
|
}))
|
|
|
|
// as takes the caller's t and ctx because parallel subtests only start
|
|
// after this function returns, possibly past the parent ctx deadline,
|
|
// and must not call FailNow on the parent test.
|
|
as := func(t *testing.T, ctx context.Context, userID uuid.UUID) context.Context {
|
|
t.Helper()
|
|
subject, _, err := httpmw.UserRBACSubject(ctx, db, userID, rbac.ExpandableScope(rbac.ScopeAll))
|
|
require.NoError(t, err)
|
|
return dbauthz.As(ctx, subject)
|
|
}
|
|
requireAllowed := func(t *testing.T, allowed bool, err error) {
|
|
t.Helper()
|
|
if allowed {
|
|
require.NoError(t, err)
|
|
return
|
|
}
|
|
require.True(t, dbauthz.IsNotAuthorizedError(err), err)
|
|
}
|
|
|
|
for name, tc := range map[string]struct {
|
|
user uuid.UUID
|
|
read, write bool
|
|
}{
|
|
"ProjectOwner": {user: projectOwner, read: true, write: true},
|
|
"OrgAdmin": {user: orgAdmin, read: true, write: true},
|
|
"SharedReader": {user: reader, read: true, write: false},
|
|
"OtherMember": {user: otherMember, read: false, write: false},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Parallel()
|
|
userCtx := as(t, testutil.Context(t, testutil.WaitLong), tc.user)
|
|
_, err := authzDB.ListProjectSkillMetadataByProjectID(userCtx, project.ID)
|
|
requireAllowed(t, tc.read, err)
|
|
|
|
skillName := "skill-" + strings.ToLower(name)
|
|
_, err = authzDB.InsertProjectSkill(userCtx, database.InsertProjectSkillParams{
|
|
ID: uuid.New(), ProjectID: project.ID, Name: skillName, Description: "desc", Content: "body",
|
|
})
|
|
requireAllowed(t, tc.write, err)
|
|
})
|
|
}
|
|
|
|
ownerCtx := as(t, ctx, projectOwner)
|
|
skill, err := authzDB.InsertProjectSkill(ownerCtx, database.InsertProjectSkillParams{
|
|
ID: uuid.New(), ProjectID: project.ID, Name: "owned", Description: "desc", Content: "body",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, uuid.NullUUID{UUID: project.ID, Valid: true}, skill.ProjectID)
|
|
|
|
otherProject := dbgen.ChatProject(t, db, database.ChatProject{OrganizationID: org.ID, OwnerID: projectOwner})
|
|
_, err = authzDB.InsertProjectSkill(ownerCtx, database.InsertProjectSkillParams{
|
|
ID: uuid.New(), ProjectID: otherProject.ID, Name: "other", Description: "desc", Content: "body",
|
|
})
|
|
require.NoError(t, err)
|
|
listed, err := authzDB.ListProjectSkillMetadataByProjectID(as(t, ctx, reader), project.ID)
|
|
require.NoError(t, err)
|
|
listedIDs := make([]uuid.UUID, 0, len(listed))
|
|
for _, row := range listed {
|
|
require.Equal(t, skill.ProjectID, row.ProjectID)
|
|
listedIDs = append(listedIDs, row.ID)
|
|
}
|
|
require.Contains(t, listedIDs, skill.ID)
|
|
got, err := authzDB.GetProjectSkillByProjectIDAndName(as(t, ctx, reader), database.GetProjectSkillByProjectIDAndNameParams{ProjectID: project.ID, Name: skill.Name})
|
|
require.NoError(t, err)
|
|
require.Equal(t, skill.Content, got.Content)
|
|
_, err = authzDB.GetProjectSkillByProjectIDAndName(as(t, ctx, reader), database.GetProjectSkillByProjectIDAndNameParams{ProjectID: project.ID, Name: "other"})
|
|
require.ErrorIs(t, err, sql.ErrNoRows)
|
|
|
|
_, err = authzDB.GetProjectSkillByProjectIDAndName(as(t, ctx, otherMember), database.GetProjectSkillByProjectIDAndNameParams{ProjectID: project.ID, Name: skill.Name})
|
|
require.True(t, dbauthz.IsNotAuthorizedError(err), err)
|
|
_, err = authzDB.GetProjectSkillByIDForUpdate(as(t, ctx, otherMember), skill.ID)
|
|
require.True(t, dbauthz.IsNotAuthorizedError(err), err)
|
|
locked, err := authzDB.GetProjectSkillByIDForUpdate(as(t, ctx, reader), skill.ID)
|
|
require.NoError(t, err)
|
|
require.Equal(t, skill.ID, locked.ID)
|
|
|
|
_, err = authzDB.UpdateProjectSkillByProjectIDAndName(as(t, ctx, reader), database.UpdateProjectSkillByProjectIDAndNameParams{
|
|
ProjectID: project.ID, Name: skill.Name, Enabled: sql.NullBool{Bool: false, Valid: true},
|
|
})
|
|
require.True(t, dbauthz.IsNotAuthorizedError(err), err)
|
|
updated, err := authzDB.UpdateProjectSkillByProjectIDAndName(ownerCtx, database.UpdateProjectSkillByProjectIDAndNameParams{
|
|
ProjectID: project.ID, Name: skill.Name, Enabled: sql.NullBool{Bool: false, Valid: true},
|
|
})
|
|
require.NoError(t, err)
|
|
require.False(t, updated.Enabled)
|
|
require.Equal(t, skill.Content, updated.Content)
|
|
|
|
_, err = authzDB.DeleteProjectSkillByProjectIDAndName(as(t, ctx, reader), database.DeleteProjectSkillByProjectIDAndNameParams{ProjectID: project.ID, Name: skill.Name})
|
|
require.True(t, dbauthz.IsNotAuthorizedError(err), err)
|
|
deleted, err := authzDB.DeleteProjectSkillByProjectIDAndName(ownerCtx, database.DeleteProjectSkillByProjectIDAndNameParams{ProjectID: project.ID, Name: skill.Name})
|
|
require.NoError(t, err)
|
|
require.Equal(t, skill.ID, deleted.ID)
|
|
}
|
|
|
|
func TestOrganizationSkillMemberPreferencesExcludes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
skillID := uuid.New()
|
|
otherSkillID := uuid.New()
|
|
for _, tc := range []struct {
|
|
name string
|
|
prefs database.GetOrganizationSkillMemberPreferencesRow
|
|
wantSkill bool
|
|
wantOthers bool
|
|
}{
|
|
{
|
|
name: "SettingOffIgnoresChoices",
|
|
prefs: database.GetOrganizationSkillMemberPreferencesRow{AllSkillsDisabled: true, DisabledSkillIDs: []uuid.UUID{skillID}},
|
|
},
|
|
{
|
|
name: "SettingOnNoChoices",
|
|
prefs: database.GetOrganizationSkillMemberPreferencesRow{MembersCanDisableSkills: true},
|
|
},
|
|
{
|
|
name: "SettingOnSkillOptedOut",
|
|
prefs: database.GetOrganizationSkillMemberPreferencesRow{MembersCanDisableSkills: true, DisabledSkillIDs: []uuid.UUID{skillID}},
|
|
wantSkill: true,
|
|
},
|
|
{
|
|
name: "SettingOnAllSkillsDisabled",
|
|
prefs: database.GetOrganizationSkillMemberPreferencesRow{MembersCanDisableSkills: true, AllSkillsDisabled: true},
|
|
wantSkill: true,
|
|
wantOthers: true,
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
require.Equal(t, tc.wantSkill, tc.prefs.Excludes(skillID))
|
|
require.Equal(t, tc.wantOthers, tc.prefs.Excludes(otherSkillID))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOrganizationSkillMemberPreferences(t *testing.T) {
|
|
t.Parallel()
|
|
if testing.Short() {
|
|
t.SkipNow()
|
|
}
|
|
|
|
ctx := testutil.Context(t, testutil.WaitLong)
|
|
db, _ := dbtestutil.NewDB(t)
|
|
|
|
org := dbgen.Organization(t, db, database.Organization{})
|
|
otherOrg := dbgen.Organization(t, db, database.Organization{})
|
|
user := dbgen.User(t, db, database.User{})
|
|
dbgen.OrganizationMember(t, db, database.OrganizationMember{UserID: user.ID, OrganizationID: org.ID})
|
|
dbgen.OrganizationMember(t, db, database.OrganizationMember{UserID: user.ID, OrganizationID: otherOrg.ID})
|
|
skill := dbgen.OrganizationSkill(t, db, database.Skill{OrganizationID: uuid.NullUUID{UUID: org.ID, Valid: true}})
|
|
deletedSkill := dbgen.OrganizationSkill(t, db, database.Skill{OrganizationID: uuid.NullUUID{UUID: org.ID, Valid: true}})
|
|
foreignSkill := dbgen.OrganizationSkill(t, db, database.Skill{OrganizationID: uuid.NullUUID{UUID: otherOrg.ID, Valid: true}})
|
|
|
|
get := func(orgID uuid.UUID) database.GetOrganizationSkillMemberPreferencesRow {
|
|
t.Helper()
|
|
prefs, err := db.GetOrganizationSkillMemberPreferences(ctx, database.GetOrganizationSkillMemberPreferencesParams{
|
|
OrganizationID: orgID,
|
|
UserID: user.ID,
|
|
})
|
|
require.NoError(t, err)
|
|
return prefs
|
|
}
|
|
disable := func(orgID, skillID uuid.UUID) {
|
|
t.Helper()
|
|
require.NoError(t, db.InsertOrganizationMemberDisabledSkill(ctx, database.InsertOrganizationMemberDisabledSkillParams{
|
|
OrganizationID: orgID,
|
|
UserID: user.ID,
|
|
SkillID: skillID,
|
|
}))
|
|
}
|
|
|
|
require.Equal(t, database.GetOrganizationSkillMemberPreferencesRow{DisabledSkillIDs: []uuid.UUID{}}, get(org.ID))
|
|
|
|
require.NoError(t, db.UpsertOrganizationMemberSkillSettings(ctx, database.UpsertOrganizationMemberSkillSettingsParams{
|
|
OrganizationID: org.ID,
|
|
UserID: user.ID,
|
|
AllSkillsDisabled: true,
|
|
}))
|
|
disable(org.ID, skill.ID)
|
|
disable(org.ID, deletedSkill.ID)
|
|
// A skill owned by another organization is never stored.
|
|
disable(org.ID, foreignSkill.ID)
|
|
require.ElementsMatch(t, []uuid.UUID{skill.ID, deletedSkill.ID}, get(org.ID).DisabledSkillIDs)
|
|
require.True(t, get(org.ID).AllSkillsDisabled)
|
|
|
|
// Deleting a skill deletes every opt-out of it.
|
|
_, err := db.DeleteOrganizationSkillByOrganizationIDAndName(ctx, database.DeleteOrganizationSkillByOrganizationIDAndNameParams{
|
|
OrganizationID: org.ID,
|
|
Name: deletedSkill.Name,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, []uuid.UUID{skill.ID}, get(org.ID).DisabledSkillIDs)
|
|
|
|
// Leaving the organization deletes the member's choices there only.
|
|
disable(otherOrg.ID, foreignSkill.ID)
|
|
require.NoError(t, db.DeleteOrganizationMember(ctx, database.DeleteOrganizationMemberParams{
|
|
OrganizationID: org.ID,
|
|
UserID: user.ID,
|
|
}))
|
|
require.Equal(t, database.GetOrganizationSkillMemberPreferencesRow{DisabledSkillIDs: []uuid.UUID{}}, get(org.ID))
|
|
require.Equal(t, []uuid.UUID{foreignSkill.ID}, get(otherOrg.ID).DisabledSkillIDs)
|
|
}
|