Files
coder/coderd/rbac/scopes_test.go
T
Bobby Ho 55da502938 feat: allow admins to configure an OAuth2 app's scope allowlist (#29313)
Add backend support for scope allowlists on admin-created OAuth2 apps, previously available only through DCR.

- Add optional, space-separated `scope` to create/update requests and return canonicalized, deduplicated scopes in app responses.
- On create, omitted or empty `scope` means unrestricted. On update, `scope` replaces the allowlist; omission preserves it, and an empty string clears it to unrestricted.
- Keep scope enforcement unchanged. Add tests for scope round-trips, DCR canonicalization parity, and authorization narrowing.
- Include generated SDK and docs updates. The UI scope picker follows in a separate PR.

Part of [PLAT-475](https://linear.app/codercom/issue/PLAT-475).
2026-09-18 11:58:49 -07:00

433 lines
14 KiB
Go

package rbac_test
import (
"fmt"
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/coderd/rbac"
"github.com/coder/coder/v2/coderd/rbac/policy"
)
func TestExpandScope(t *testing.T) {
t.Parallel()
t.Run("low_level_pairs", func(t *testing.T) {
t.Parallel()
cases := []struct {
name string
resource string
action policy.Action
}{
{name: "workspace:start", resource: rbac.ResourceWorkspace.Type, action: policy.ActionWorkspaceStart},
{name: "workspace:ssh", resource: rbac.ResourceWorkspace.Type, action: policy.ActionSSH},
{name: "template:use", resource: rbac.ResourceTemplate.Type, action: policy.ActionUse},
{name: "api_key:read", resource: rbac.ResourceApiKey.Type, action: policy.ActionRead},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
s, err := rbac.ScopeName(tc.name).Expand()
require.NoError(t, err)
// site-only single permission
require.Len(t, s.Site, 1)
require.Equal(t, tc.resource, s.Site[0].ResourceType)
require.Equal(t, tc.action, s.Site[0].Action)
require.Empty(t, s.ByOrgID)
require.Empty(t, s.User)
require.Equal(t, []rbac.AllowListElement{rbac.AllowListAll()}, s.AllowIDList)
})
}
})
t.Run("invalid_low_level", func(t *testing.T) {
t.Parallel()
invalid := []string{
"", // empty
"workspace:", // missing action
":read", // missing resource
"unknown:read", // unknown resource
"workspace:bogus", // unknown action
"a:b:c", // too many parts
}
for _, name := range invalid {
t.Run(name, func(t *testing.T) {
t.Parallel()
_, err := rbac.ScopeName(name).Expand()
require.Error(t, err)
})
}
})
}
func TestFirstScopeNotCovered(t *testing.T) {
t.Parallel()
tests := []struct {
name string
allowed []rbac.ScopeName
requested []rbac.ScopeName
want rbac.ScopeName
// wantErrContains names the side that could not be expanded, as in
// TestScopesCover.
wantErrContains string
}{
{
name: "EmptyRequestIsCovered",
allowed: []rbac.ScopeName{"workspace:read"},
requested: nil,
},
{
name: "EveryRequestedScopeCovered",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: []rbac.ScopeName{"workspace:read", "workspace:ssh"},
},
{
// The answer names which scope failed, not merely that one did.
name: "NamesTheFirstUncovered",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: []rbac.ScopeName{"workspace:read", "workspace:delete", "user_secret:delete"},
want: "workspace:delete",
},
{
name: "UnexpandableRequestedScopeNamed",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: []rbac.ScopeName{"workspace:read", "not_a_real_scope"},
want: "not_a_real_scope",
wantErrContains: "expand requested scope",
},
{
name: "UnexpandableAllowedScopeNamed",
allowed: []rbac.ScopeName{"not_a_real_scope"},
requested: []rbac.ScopeName{"workspace:read"},
want: "not_a_real_scope",
wantErrContains: "expand allowed scope",
},
{
// The alias validates but is not an expandable name, so callers
// must canonicalize first. Pinned because the allowed side is
// expanded once now, outside the per-scope loop.
name: "LegacyAliasIsNotExpandable",
allowed: []rbac.ScopeName{"all"},
requested: []rbac.ScopeName{"workspace:read"},
want: "all",
wantErrContains: "expand allowed scope",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
got, err := rbac.FirstScopeNotCovered(test.allowed, test.requested)
if test.wantErrContains != "" {
require.ErrorContains(t, err, test.wantErrContains)
require.Equal(t, test.want, got, "an undecidable comparison must name the scope it could not decide")
return
}
require.NoError(t, err)
require.Equal(t, test.want, got)
})
}
}
// The two answer the same question, so a row that disagrees means one of them
// changed alone.
func TestFirstScopeNotCoveredAgreesWithScopesCover(t *testing.T) {
t.Parallel()
allowed := []rbac.ScopeName{"coder:workspaces.access", "coder:templates.build"}
for _, name := range rbac.ExternalScopeNames() {
canonical := rbac.CanonicalScopeName(rbac.ScopeName(name))
covered, err := rbac.ScopesCover(allowed, canonical)
require.NoError(t, err, "scope %q", name)
outside, err := rbac.FirstScopeNotCovered(allowed, []rbac.ScopeName{canonical})
require.NoError(t, err, "scope %q", name)
require.Equal(t, covered, outside == "", "scope %q", name)
}
}
func TestScopesCover(t *testing.T) {
t.Parallel()
tests := []struct {
name string
allowed []rbac.ScopeName
requested rbac.ScopeName
want bool
// wantErrContains names the side that could not be expanded. Asserting
// the side keeps rows that fail through different paths from passing
// on each other's errors.
wantErrContains string
}{
{
name: "IdenticalName",
allowed: []rbac.ScopeName{"workspace:read"},
requested: "workspace:read",
want: true,
},
{
// Name matching alone cannot decide this: coder:workspaces.access
// never mentions workspace:ssh by name, but its expansion covers it.
name: "CompositeCoversItsMember",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: "workspace:ssh",
want: true,
},
{
// The composite grants no permission on this resource at all.
name: "CompositeDoesNotCoverUnrelatedResource",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: "user_secret:delete",
want: false,
},
{
// Same resource, action the composite does not grant. Coverage
// compares the pair, not the resource alone.
name: "CompositeDoesNotCoverUngrantedActionOnSameResource",
allowed: []rbac.ScopeName{"coder:workspaces.access"},
requested: "workspace:delete",
want: false,
},
{
name: "AllCoversEverything",
allowed: []rbac.ScopeName{rbac.ScopeAll},
requested: "user_secret:delete",
want: true,
},
{
name: "NarrowScopeDoesNotCoverAll",
allowed: []rbac.ScopeName{"workspace:read"},
requested: rbac.ScopeAll,
want: false,
},
{
name: "ResourceWildcardCoversOneAction",
allowed: []rbac.ScopeName{"workspace:*"},
requested: "workspace:ssh",
want: true,
},
{
name: "OneActionDoesNotCoverResourceWildcard",
allowed: []rbac.ScopeName{"workspace:ssh"},
requested: "workspace:*",
want: false,
},
{
// A composite is covered only when every permission it expands
// to is granted, so a strict subset of them is not enough.
name: "PartialUnionDoesNotCoverComposite",
allowed: []rbac.ScopeName{"template:read", "file:create"},
requested: "coder:templates.build",
want: false,
},
{
// The allowed side is a union rather than a set of independent
// candidates, so one composite's permissions may be drawn from
// several allowed entries at once.
name: "UnionOfAllowedScopesCoversComposite",
allowed: []rbac.ScopeName{"template:read", "file:*", "provisioner_jobs:read"},
requested: "coder:templates.build",
want: true,
},
{
name: "EmptyAllowedCoversNothing",
allowed: nil,
requested: "workspace:read",
want: false,
},
{
// Not a false: a caller cannot distinguish "known and not
// covered" from "we could not tell", so an undecidable
// comparison is surfaced rather than answered.
name: "UnknownRequestedScopeErrors",
allowed: []rbac.ScopeName{rbac.ScopeAll},
requested: "not_a_real_scope",
wantErrContains: "expand requested scope",
},
{
name: "UnknownAllowedScopeErrors",
allowed: []rbac.ScopeName{"not_a_real_scope"},
requested: "workspace:read",
wantErrContains: "expand allowed scope",
},
{
// An implementation answering on the first match never reaches it.
name: "UnknownAllowedScopeErrorsBesideCoveringScope",
allowed: []rbac.ScopeName{rbac.ScopeAll, "not_a_real_scope"},
requested: "workspace:read",
wantErrContains: "expand allowed scope",
},
{
// The aliases IsExternalScope accepts are not expandable names,
// so callers must canonicalize before asking about coverage.
name: "NonCanonicalAliasErrorsRequestedAll",
allowed: []rbac.ScopeName{rbac.ScopeAll},
requested: "all",
wantErrContains: "expand requested scope",
},
{
name: "NonCanonicalAliasErrorsRequestedApplicationConnect",
allowed: []rbac.ScopeName{rbac.ScopeAll},
requested: "application_connect",
wantErrContains: "expand requested scope",
},
{
// The only row that would catch someone canonicalizing inside the
// allowed loop, which would silently widen what an allow list
// accepts without any caller asking for it.
name: "NonCanonicalAliasErrorsAllowedApplicationConnect",
allowed: []rbac.ScopeName{"application_connect"},
requested: rbac.ScopeApplicationConnect,
wantErrContains: "expand allowed scope",
},
{
name: "NonCanonicalAliasErrorsAllowedAll",
allowed: []rbac.ScopeName{"all"},
requested: rbac.ScopeAll,
wantErrContains: "expand allowed scope",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
got, err := rbac.ScopesCover(test.allowed, test.requested)
if test.wantErrContains != "" {
require.ErrorContains(t, err, test.wantErrContains)
require.False(t, got, "an undecided comparison must not report coverage")
return
}
require.NoError(t, err)
require.Equal(t, test.want, got)
})
}
}
// TestCanonicalScopeName pins the alias mapping. Without it the two case arms
// could be swapped, so that requesting `all` persisted application_connect and
// the reverse, and the suite would stay green.
func TestCanonicalScopeName(t *testing.T) {
t.Parallel()
require.Equal(t, rbac.ScopeAll, rbac.CanonicalScopeName("all"))
require.Equal(t, rbac.ScopeApplicationConnect, rbac.CanonicalScopeName("application_connect"))
// Canonical names and low-level names are returned unchanged, so callers
// can canonicalize unconditionally.
require.Equal(t, rbac.ScopeAll, rbac.CanonicalScopeName(rbac.ScopeAll))
require.Equal(t, rbac.ScopeApplicationConnect, rbac.CanonicalScopeName(rbac.ScopeApplicationConnect))
require.Equal(t, rbac.ScopeName("workspace:read"), rbac.CanonicalScopeName("workspace:read"))
require.Equal(t, rbac.ScopeName("not_a_real_scope"), rbac.CanonicalScopeName("not_a_real_scope"))
}
// TestCanonicalScopeList pins the display form of a stored allowlist.
func TestCanonicalScopeList(t *testing.T) {
t.Parallel()
cases := []struct {
name string
raw string
want string
}{
{name: "empty", raw: "", want: ""},
// Whitespace-only is a configured allowlist that grants nothing, so it
// must not read back as the empty, unrestricted value.
{name: "whitespace_only", raw: " \t\n ", want: " \t\n "},
{name: "single", raw: "workspace:read", want: "workspace:read"},
{
name: "aliases_rewritten",
raw: "all application_connect",
want: "coder:all coder:application_connect",
},
{
name: "alias_and_canonical_collapse",
raw: "all coder:all application_connect coder:application_connect",
want: "coder:all coder:application_connect",
},
{
name: "duplicates_keep_first_seen_order",
raw: "template:read workspace:read template:read workspace:read",
want: "template:read workspace:read",
},
{
name: "unknown_names_kept",
raw: "workspace:read not_a_real_scope workspace:read not_a_real_scope",
want: "workspace:read not_a_real_scope",
},
{
name: "extra_whitespace_normalized",
raw: " workspace:read\t\ntemplate:read ",
want: "workspace:read template:read",
},
}
for _, test := range cases {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
require.Equal(t, test.want, rbac.CanonicalScopeList(test.raw))
})
}
// A large list of distinct names must come back intact and in order.
t.Run("large_distinct_list", func(t *testing.T) {
t.Parallel()
raw := distinctScopeList(100_000)
got := rbac.CanonicalScopeList(raw)
require.Equal(t, raw, got)
// A repeated list collapses onto the first copy.
got = rbac.CanonicalScopeList(raw + " " + raw)
require.Equal(t, raw, got)
})
}
// distinctScopeList returns count distinct unknown names, space separated.
func distinctScopeList(count int) string {
names := make([]string, 0, count)
for i := range count {
names = append(names, fmt.Sprintf("unknown:%d", i))
}
return strings.Join(names, " ")
}
// BenchmarkCanonicalScopeList measures a list of many distinct names, the
// input that made the dedupe quadratic before it used a set.
func BenchmarkCanonicalScopeList(b *testing.B) {
raw := distinctScopeList(100_000)
for b.Loop() {
_ = rbac.CanonicalScopeList(raw)
}
}
// TestScopesCoverEveryExternalScope asserts the property the OAuth2 allowlist
// check depends on: coder:all is a ceiling over the whole external catalog, and
// every catalog name covers itself. A name that cannot be compared at all would
// otherwise reject every request naming it, which is a rejection no app owner
// could act on.
func TestScopesCoverEveryExternalScope(t *testing.T) {
t.Parallel()
// The aliases inherit this without being named here: TestScopeAliases pins
// that each one canonicalizes to a name this list offers.
for _, name := range rbac.ExternalScopeNames() {
scope := rbac.ScopeName(name)
covered, err := rbac.ScopesCover([]rbac.ScopeName{rbac.ScopeAll}, scope)
require.NoErrorf(t, err, "coder:all vs %q", scope)
require.Truef(t, covered, "coder:all must cover %q", scope)
covered, err = rbac.ScopesCover([]rbac.ScopeName{scope}, scope)
require.NoErrorf(t, err, "%q vs itself", scope)
require.Truef(t, covered, "%q must cover itself", scope)
}
}