Restores `agents-access` (**Coder Agents User**) as a built-in organization role and adds it to every organization's `default_org_member_roles`. Members keep Coder Agents by default, and admins can now restrict it per organization by removing the role from the defaults and granting it through IdP role sync or direct assignment. Since #28186, chat permissions lived in the organization-member floor, so the only way to limit Coder Agents was narrowing per-model access lists, which did not hide the feature. - Migration 000602 appends `agents-access` to every organization's defaults, so upgrading keeps every member's access. New organizations get it from `rbac.DefaultOrgMemberRoles()`. - Service accounts do not inherit the role from the defaults (`GetAuthorizationUserRoles`), so they still need an explicit grant for chat. - Owners and Organization Admins keep chat access regardless of defaults. Chats shared with a user stay readable without the role. - Role sync is unchanged. It does not store default roles, so after the default is removed a mapped user gets `agents-access` at their next sign-in. - The retired-role mechanism (`IsRetiredRoleName`) is removed. - `PATCH /api/v2/organizations/{organization}` rejects duplicate `default_org_member_roles` entries (the CLI already de-duplicated them). - Custom organization role requests treat built-in role names case-insensitively, since custom role names are stored lowercase and `Agents-Access` would otherwise become an undeletable shadow of the built-in role. - The Agents permission alert tells restricted members their chats are kept, and the model selector for users without chat permission no longer claims that no models are configured. Docs add "Control who can use Coder Agents" to the Agents getting-started guide. **NOTE**: Migration 000602 deletes custom roles named `agents-access`, which the built-in role would shadow. The down migration does not restore them. Stored member grants of `agents-access` from the earlier built-in role or a deleted custom role stay and now grant chat access. ## Validation - Remote dogfood [UAT](https://dogfood.cdr.dev/agents/e1c18dc6-f6f0-49a1-b6cd-6ce014b51a86) passed onfb441dfae5, covering case variants of built-in role names on create, update, delete, default roles, and member grants. The previous round, ona6fef66b3f, passed the upgrade from main5dde49dffbon a fresh database.6b7f107e0bonly changes wording (docs, comments, UI copy, CLI help) and did not go through UAT. - Local: rbac, dbauthz, idpsync, migrations (chain including 000602 down and up), querier, httpmw, provisionerdserver, coderd and enterprise chat, role, and organization tests, chatd, toolsdk, CLI; frontend vitest, story tests, biome, oxlint, tsc. ## Known issues (not changed here) - Sending from a chat page that was already open when access was removed shows a generic 404 panel until reload. - The members page role editor is not locked for OIDC users under org role sync; the API rejects the change with 400. - Creating a custom role named after a system role (`organization-member`, `organization-service-account`) returns 400 with a raw database unique-constraint error. <details> <summary>Review record</summary> - Remote UAT (UAT Critic sub-agent `6636c855ec`): round 1 on8bec029d35passed with issues, fixed ind7ba937a10and e0f16e1a45f; round 2 ona6fef66b3fpassed; round 3 onfb441dfae5passed. - Codex: round 1 ona6fef66b3ffound one P2 (case variants of built-in role names), fixed infb441dfae5with a red-green test. Rounds 2 and 3 onfb441dfae5found no major issues. - mafredri onfb441dfae5(PR text only): nine wording suggestions applied in 6b7f107e0b9; NOTE extended for stored grants; description trimmed. - Frontend: FE1 to FE10 and coder-frontend-review checkpoints self-audited. </details> > 🤖 This PR was opened by [Xum](https://mux.coder.com) on behalf of @ibetitsmike.
411 lines
11 KiB
Go
411 lines
11 KiB
Go
package idpsync_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"slices"
|
|
"testing"
|
|
|
|
"github.com/golang-jwt/jwt/v4"
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/mock/gomock"
|
|
|
|
"cdr.dev/slog/v3/sloggers/slogtest"
|
|
"github.com/coder/coder/v2/coderd/database"
|
|
"github.com/coder/coder/v2/coderd/database/dbgen"
|
|
"github.com/coder/coder/v2/coderd/database/dbmock"
|
|
"github.com/coder/coder/v2/coderd/database/dbtestutil"
|
|
"github.com/coder/coder/v2/coderd/idpsync"
|
|
"github.com/coder/coder/v2/coderd/rbac"
|
|
"github.com/coder/coder/v2/coderd/runtimeconfig"
|
|
"github.com/coder/coder/v2/testutil"
|
|
)
|
|
|
|
//nolint:paralleltest, tparallel
|
|
func TestRoleSyncTable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
userClaims := jwt.MapClaims{
|
|
"roles": []string{
|
|
"foo", "bar", "baz",
|
|
"create-bar", "create-baz",
|
|
"legacy-bar", rbac.RoleOrgAuditor(),
|
|
// Some arbitrary values to attempt to trip up the SQL in the matching.
|
|
"Role with (Special Characters)",
|
|
"NULL",
|
|
},
|
|
// bad-claim is a number, and will fail any role sync
|
|
"bad-claim": 100,
|
|
"empty": []string{},
|
|
}
|
|
|
|
testCases := []orgSetupDefinition{
|
|
{
|
|
Name: "NoSync",
|
|
OrganizationRoles: []string{},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{},
|
|
},
|
|
},
|
|
{
|
|
Name: "SyncDisabled",
|
|
OrganizationRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
},
|
|
RoleSettings: &idpsync.RoleSyncSettings{},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Audit role from claim
|
|
Name: "RawAudit",
|
|
OrganizationRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "CustomRole",
|
|
OrganizationRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
},
|
|
CustomRoles: []string{"foo"},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
"foo",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "RoleMapping",
|
|
OrganizationRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
"invalid", // Throw in an extra invalid role that will be removed
|
|
},
|
|
CustomRoles: []string{"custom"},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{
|
|
"foo": {"custom", rbac.RoleOrgTemplateAdmin()},
|
|
},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
rbac.RoleOrgTemplateAdmin(),
|
|
"custom",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// InvalidClaims will log an error, but do not block authentication.
|
|
// This is to prevent a misconfigured organization from blocking
|
|
// a user from authenticating.
|
|
Name: "InvalidClaim",
|
|
OrganizationRoles: []string{rbac.RoleOrgAdmin()},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "bad-claim",
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAdmin(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "NoChange",
|
|
OrganizationRoles: []string{rbac.RoleOrgAdmin(), rbac.RoleOrgTemplateAdmin(), rbac.RoleOrgAuditor()},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{
|
|
"foo": {rbac.RoleOrgAuditor(), rbac.RoleOrgTemplateAdmin()},
|
|
"bar": {rbac.RoleOrgAdmin()},
|
|
},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAdmin(), rbac.RoleOrgAuditor(), rbac.RoleOrgTemplateAdmin(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// InvalidOriginalRole starts the user with an invalid role.
|
|
// In practice, this should not happen, as it means a role was
|
|
// inserted into the database that does not exist.
|
|
// For the purposes of syncing, it does not matter, and the sync
|
|
// should succeed.
|
|
Name: "InvalidOriginalRole",
|
|
OrganizationRoles: []string{"something-bad"},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// agents-access removed from the org defaults is granted
|
|
// through role sync like any other role.
|
|
Name: "AgentsAccessNotDefault",
|
|
OrganizationRoles: []string{},
|
|
DefaultOrgMemberRoles: []string{rbac.RoleOrgWorkspaceAccess()},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{
|
|
"foo": {rbac.RoleAgentsAccess()},
|
|
},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
rbac.RoleAgentsAccess(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// While agents-access is a default it is implicit, so role
|
|
// sync neither stores nor strips it.
|
|
Name: "AgentsAccessDefault",
|
|
OrganizationRoles: []string{},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: map[string][]string{
|
|
"foo": {rbac.RoleAgentsAccess()},
|
|
},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{
|
|
rbac.RoleOrgAuditor(),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "NonExistentClaim",
|
|
OrganizationRoles: []string{rbac.RoleOrgAuditor()},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "not-exists",
|
|
Mapping: map[string][]string{},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{},
|
|
},
|
|
},
|
|
{
|
|
Name: "EmptyClaim",
|
|
OrganizationRoles: []string{rbac.RoleOrgAuditor()},
|
|
RoleSettings: &idpsync.RoleSyncSettings{
|
|
Field: "empty",
|
|
Mapping: map[string][]string{},
|
|
},
|
|
assertRoles: &orgRoleAssert{
|
|
ExpectedOrgRoles: []string{},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
// The final test, "AllTogether", cannot run in parallel.
|
|
// These tests are nearly instant using the memory db, so
|
|
// this is still fast without being in parallel.
|
|
//nolint:paralleltest, tparallel
|
|
t.Run(tc.Name, func(t *testing.T) {
|
|
db, _ := dbtestutil.NewDB(t)
|
|
manager := runtimeconfig.NewManager()
|
|
s := idpsync.NewAGPLSync(slogtest.Make(t, &slogtest.Options{
|
|
IgnoreErrors: true,
|
|
}),
|
|
manager,
|
|
idpsync.DeploymentSyncSettings{
|
|
SiteRoleField: "roles",
|
|
},
|
|
)
|
|
|
|
ctx := testutil.Context(t, testutil.WaitSuperLong)
|
|
user := dbgen.User(t, db, database.User{})
|
|
orgID := uuid.New()
|
|
SetupOrganization(t, s, db, user, orgID, tc)
|
|
|
|
// Do the role sync!
|
|
err := s.SyncRoles(ctx, db, user, idpsync.RoleParams{
|
|
SyncEntitled: true,
|
|
SyncSiteWide: false,
|
|
MergedClaims: userClaims,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
tc.Assert(t, orgID, db, user)
|
|
})
|
|
}
|
|
|
|
// AllTogether runs the entire tabled test as a singular user and
|
|
// deployment. This tests all organizations being synced together.
|
|
// The reason we do them individually, is that it is much easier to
|
|
// debug a single test case.
|
|
//nolint:paralleltest, tparallel // This should run after all the individual tests
|
|
t.Run("AllTogether", func(t *testing.T) {
|
|
db, _ := dbtestutil.NewDB(t)
|
|
manager := runtimeconfig.NewManager()
|
|
s := idpsync.NewAGPLSync(slogtest.Make(t, &slogtest.Options{
|
|
IgnoreErrors: true,
|
|
}),
|
|
manager,
|
|
// Also sync some site wide roles
|
|
idpsync.DeploymentSyncSettings{
|
|
GroupField: "groups",
|
|
SiteRoleField: "roles",
|
|
// Site sync settings do not matter,
|
|
// as we are not testing the site parse here.
|
|
// Only the sync, assuming the parse is correct.
|
|
},
|
|
)
|
|
|
|
ctx := testutil.Context(t, testutil.WaitSuperLong)
|
|
user := dbgen.User(t, db, database.User{})
|
|
|
|
var asserts []func(t *testing.T)
|
|
|
|
for _, tc := range testCases {
|
|
orgID := uuid.New()
|
|
SetupOrganization(t, s, db, user, orgID, tc)
|
|
asserts = append(asserts, func(t *testing.T) {
|
|
t.Run(tc.Name, func(t *testing.T) {
|
|
t.Parallel()
|
|
tc.Assert(t, orgID, db, user)
|
|
})
|
|
})
|
|
}
|
|
|
|
err := s.SyncRoles(ctx, db, user, idpsync.RoleParams{
|
|
SyncEntitled: true,
|
|
SyncSiteWide: true,
|
|
SiteWideRoles: []string{
|
|
rbac.RoleTemplateAdmin().Name, // Duplicate this value to test deduplication
|
|
rbac.RoleTemplateAdmin().Name, rbac.RoleAuditor().Name,
|
|
},
|
|
MergedClaims: userClaims,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
for _, assert := range asserts {
|
|
assert(t)
|
|
}
|
|
|
|
// Also assert site wide roles
|
|
allRoles, err := db.GetAuthorizationUserRoles(ctx, user.ID)
|
|
require.NoError(t, err)
|
|
|
|
allRoleIDs, err := allRoles.RoleNames()
|
|
require.NoError(t, err)
|
|
|
|
// Remove the org roles
|
|
siteRoles := slices.DeleteFunc(allRoleIDs, func(r rbac.RoleIdentifier) bool {
|
|
return r.IsOrgRole()
|
|
})
|
|
|
|
require.ElementsMatch(t, []rbac.RoleIdentifier{
|
|
rbac.RoleTemplateAdmin(), rbac.RoleAuditor(), rbac.RoleMember(),
|
|
}, siteRoles)
|
|
})
|
|
}
|
|
|
|
// TestNoopNoDiff verifies if no role change occurs, no database call is taken
|
|
// per organization. This limits the number of db calls to O(1) if there
|
|
// are no changes. Which is the usual case, as user's roles do not change often.
|
|
func TestNoopNoDiff(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := context.Background()
|
|
ctrl := gomock.NewController(t)
|
|
mDB := dbmock.NewMockStore(ctrl)
|
|
|
|
mgr := runtimeconfig.NewManager()
|
|
s := idpsync.NewAGPLSync(slogtest.Make(t, &slogtest.Options{}), mgr, idpsync.DeploymentSyncSettings{
|
|
SiteRoleField: "",
|
|
SiteRoleMapping: nil,
|
|
SiteDefaultRoles: nil,
|
|
})
|
|
|
|
userID := uuid.New()
|
|
orgID := uuid.New()
|
|
siteRoles := []string{rbac.RoleTemplateAdmin().Name, rbac.RoleAuditor().Name}
|
|
orgRoles := []string{rbac.RoleOrgAuditor(), rbac.RoleOrgAdmin()}
|
|
// The DB mock expects.
|
|
// If this test fails, feel free to add more expectations.
|
|
// The primary expectations to avoid is 'UpdateUserRoles'
|
|
// and 'UpdateMemberRoles'.
|
|
mDB.EXPECT().InTx(
|
|
gomock.Any(), gomock.Any(),
|
|
).DoAndReturn(func(f func(database.Store) error, _ *database.TxOptions) error {
|
|
err := f(mDB)
|
|
return err
|
|
})
|
|
|
|
mDB.EXPECT().OrganizationMembers(gomock.Any(), database.OrganizationMembersParams{
|
|
UserID: userID,
|
|
}).Return([]database.OrganizationMembersRow{
|
|
{
|
|
OrganizationMember: database.OrganizationMember{
|
|
UserID: userID,
|
|
OrganizationID: orgID,
|
|
Roles: orgRoles,
|
|
},
|
|
},
|
|
}, nil)
|
|
|
|
// SyncRoles fetches the org to union implicit roles into the diff filter.
|
|
mDB.EXPECT().GetOrganizationByID(gomock.Any(), orgID).Return(database.Organization{
|
|
ID: orgID,
|
|
DefaultOrgMemberRoles: []string{},
|
|
}, nil)
|
|
|
|
mDB.EXPECT().GetRuntimeConfig(gomock.Any(), gomock.Any()).Return(
|
|
string(must(json.Marshal(idpsync.RoleSyncSettings{
|
|
Field: "roles",
|
|
Mapping: nil,
|
|
}))), nil)
|
|
|
|
err := s.SyncRoles(ctx, mDB, database.User{
|
|
ID: userID,
|
|
Email: "alice@email.com",
|
|
Username: "alice",
|
|
Status: database.UserStatusActive,
|
|
RBACRoles: siteRoles,
|
|
LoginType: database.LoginTypePassword,
|
|
}, idpsync.RoleParams{
|
|
SyncEntitled: true,
|
|
SyncSiteWide: true,
|
|
SiteWideRoles: siteRoles,
|
|
MergedClaims: jwt.MapClaims{
|
|
"roles": orgRoles,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func must[T any](value T, err error) T {
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return value
|
|
}
|