Files

486 lines
18 KiB
Go

package governance
import (
"context"
"errors"
"log/slog"
"slices"
"testing"
"github.com/samcharles93/archie-core/modules/governance/internal/store"
)
// TestInvalidInstancePolicy pins that an instance policy that no longer
// compiles closes the instance without locking the operator out: only an
// instance admin working on the policies passes, so the policy can be
// repaired from the dashboard.
func TestInvalidInstancePolicy(t *testing.T) {
broken := Policy{ID: "broken", Level: LevelInstance, Text: `permit(principal, action == Archie::Action::"nope", resource);`}
policies := append(ShippedOrgPolicies(DefaultOrgID), ShippedOrgPolicies("acme")...)
engine := NewEngine(append(policies, broken))
if len(engine.Problems()) != 1 {
t.Fatalf("problems = %v, want the broken instance policy", engine.Problems())
}
owner := func(id IdentityID, o OrgID) Principal {
return Principal{IdentityID: id, Org: o, Memberships: []Membership{{IdentityID: id, OrgID: o, Role: RoleOwner}}}
}
admin := owner("admin", DefaultOrgID)
tests := []struct {
name string
principal Principal
action Action
kind ResourceKind
allowed bool
}{
{"instance admin edits policies", admin, ActionManagePolicies, KindPolicy, true},
{"instance admin reads policies", admin, ActionRead, KindPolicy, true},
{"instance admin reads anything else", admin, ActionRead, KindDashboard, false},
{"another org's owner edits policies", owner("acme-owner", "acme"), ActionManagePolicies, KindPolicy, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := engine.Authorize(t.Context(), tt.principal, tt.action, Resource{Kind: tt.kind}, AccessContext{})
if got.Allowed != tt.allowed {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.allowed, got)
}
})
}
}
// TestReadAuditRoleBoundary pins that the audit feed is an administrator's
// read: the dashboard's broad read grant (viewer and developer) must not open
// the instance's settings, access and identity history.
func TestReadAuditRoleBoundary(t *testing.T) {
const auditOrg = OrgID("acme")
engine := NewEngine(ShippedOrgPolicies(auditOrg))
tests := []struct {
role Role
allowed bool
}{
{RoleOwner, true},
{RoleAdmin, true},
{RoleDeveloper, false},
{RoleViewer, false},
}
for _, tt := range tests {
t.Run(string(tt.role), func(t *testing.T) {
p := Principal{
IdentityID: "person", Org: auditOrg,
Memberships: []Membership{{IdentityID: "person", OrgID: auditOrg, Role: tt.role}},
}
got := engine.Authorize(t.Context(), p, ActionReadAudit, Resource{Kind: KindAudit, Org: auditOrg}, AccessContext{})
if got.Allowed != tt.allowed {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.allowed, got)
}
})
}
}
// TestWorkspaceEnvironment pins that a policy can read the environment of
// the workspace a resource is in: it validates on save and decides runs in
// that workspace only.
func TestWorkspaceEnvironment(t *testing.T) {
frozen := Policy{
ID: "no-prod-runs", Level: LevelOrg, OrgID: "acme",
Text: `forbid(principal, action == Archie::Action::"run", resource) when { resource.workspace.environment == "production" };`,
}
engine := NewEngine(append(ShippedOrgPolicies("acme"), frozen))
if err := engine.Validate(frozen); err != nil {
t.Fatalf("validate: %v", err)
}
dev := Principal{
IdentityID: "dev", Org: "acme",
Memberships: []Membership{{IdentityID: "dev", OrgID: "acme", Role: RoleDeveloper}},
Workspaces: []Workspace{{ID: "live", OrgID: "acme", Environment: "production"}, {ID: "stage", OrgID: "acme", Environment: "staging"}},
}
tests := []struct {
name string
action Action
workspace WorkspaceID
allowed bool
}{
{"run in a production workspace", ActionRun, "live", false},
{"other actions in it", ActionUpdate, "live", true},
{"run in another environment", ActionRun, "stage", true},
{"run on a record with no workspace", ActionRun, "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
resource := Resource{Kind: KindWorkflow, ID: "triage", Org: "acme", Workspace: tt.workspace}
if got := engine.Authorize(t.Context(), dev, tt.action, resource, AccessContext{}); got.Allowed != tt.allowed {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.allowed, got)
}
})
}
}
// TestPendingChainRefusesUntilLoaded pins that a chain built before its store
// is up refuses every request until the first load succeeds, then allows.
func TestPendingChainRefusesUntilLoaded(t *testing.T) {
loaded := false
live := NewPending(func(context.Context) (int64, error) {
return 1, nil
}, func(context.Context) ([]Policy, error) {
if !loaded {
return nil, errors.New("store down")
}
return nil, nil
}, slog.New(slog.DiscardHandler))
request := func() Decision {
return live.Authorize(t.Context(), SharedTokenOwner(), ActionRead,
Resource{Kind: KindDashboard}, AccessContext{})
}
if decision := request(); decision.Allowed || !errors.Is(decision.Err, ErrChainUnavailable) {
t.Fatalf("before load = %+v, want the not-loaded refusal", decision)
}
if live.Ready() {
t.Fatal("Ready before load = true, want false")
}
if got := live.Problems(); got != nil {
t.Fatalf("Problems before load = %v, want nil", got)
}
if decision := live.AuthorizeDelivery(t.Context(), "acme", "sources/x", "10.0.0.1"); decision.Allowed ||
!errors.Is(decision.Err, ErrChainUnavailable) {
t.Fatalf("delivery before load = %+v, want the not-loaded refusal", decision)
}
loaded = true
if err := live.Reload(t.Context()); err != nil {
t.Fatal(err)
}
if !live.Ready() {
t.Fatal("Ready after load = false, want true")
}
if decision := request(); !decision.Allowed {
t.Fatalf("after load = %+v, want allowed", decision)
}
}
type fakePolicyStore struct {
version int64
policies []Policy
versionErr error
listErr error
}
func (s *fakePolicyStore) PoliciesVersion(context.Context) (int64, error) {
if s.versionErr != nil {
return 0, s.versionErr
}
return s.version, nil
}
func (s *fakePolicyStore) ListPolicies(context.Context) ([]Policy, error) {
if s.listErr != nil {
return nil, s.listErr
}
return s.policies, nil
}
// TestLiveAppliesAPolicyEditBeforeTheNextDecision pins the ordering guarantee a
// policy edit gets: the next decision after a write returns is decided by the
// edited chain, and a store failure in between refuses rather than standing on
// the chain the process happens to hold.
func TestLiveAppliesAPolicyEditBeforeTheNextDecision(t *testing.T) {
forbidAll := Policy{ID: "forbid-all", Level: LevelInstance, Text: `forbid(principal, action, resource);`}
storeDown := errors.New("state store down")
request := func(live *Live) Decision {
return live.Authorize(t.Context(), SharedTokenOwner(), ActionRead,
Resource{Kind: KindDashboard}, AccessContext{})
}
tests := []struct {
name string
write func(store *fakePolicyStore)
wantAllowed bool
wantUnavailable bool
}{
{
name: "an unchanged version keeps the chain",
write: func(store *fakePolicyStore) { store.policies = []Policy{forbidAll} },
wantAllowed: true,
},
{
name: "a bumped version applies the forbid",
write: func(store *fakePolicyStore) { store.policies = []Policy{forbidAll}; store.version++ },
},
{
name: "a failed version read refuses",
write: func(store *fakePolicyStore) {
store.policies = []Policy{forbidAll}
store.version++
store.versionErr = storeDown
},
wantUnavailable: true,
},
{
name: "a failed list read after a bump refuses instead of keeping the old chain",
write: func(store *fakePolicyStore) { store.version++; store.listErr = storeDown },
wantUnavailable: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
store := &fakePolicyStore{version: 1}
live := NewPending(store.PoliciesVersion, store.ListPolicies, slog.New(slog.DiscardHandler))
if err := live.Reload(t.Context()); err != nil {
t.Fatal(err)
}
if decision := request(live); !decision.Allowed {
t.Fatalf("before the edit = %+v, want allowed so the edit is what refuses", decision)
}
tt.write(store)
decision := request(live)
if decision.Allowed != tt.wantAllowed {
t.Fatalf("after the edit = %+v, want allowed %v", decision, tt.wantAllowed)
}
if unavailable := errors.Is(decision.Err, ErrChainUnavailable); unavailable != tt.wantUnavailable {
t.Fatalf("after the edit = %+v, want unavailable %v", decision, tt.wantUnavailable)
}
})
}
}
// TestAuthorizeDelivery guards network and object policy evaluation for inbound deliveries.
func TestAuthorizeDelivery(t *testing.T) {
permitAll := Policy{ID: "all", Level: LevelInstance, Text: `permit(principal, action, resource);`}
lanOnly := Policy{ID: "lan-only", Level: LevelInstance, Text: `forbid(principal, action == Archie::Action::"deliver", resource) unless { context.addr.isInRange(ip("10.0.0.0/8")) };`}
sourceOnly := Policy{
ID: "github-only", Level: LevelObject, OrgID: DefaultOrgID, ObjectKind: KindSource, ObjectID: "github",
Text: `permit(principal, action == Archie::Action::"deliver", resource) when { context.addr.isInRange(ip("140.82.112.0/20")) };`,
}
acmeOnly := Policy{
ID: "acme-only", Level: LevelObject, OrgID: "acme", ObjectKind: KindSource, ObjectID: "hook",
Text: `permit(principal, action == Archie::Action::"deliver", resource) when { context.addr.isInRange(ip("10.0.0.0/8")) };`,
}
shipped := ShippedOrgPolicies(DefaultOrgID)
tests := []struct {
name string
org OrgID
policies []Policy
source string
addr string
allowed bool
}{
{name: "no rules admits every sender", policies: shipped, source: "github", addr: "203.0.113.9", allowed: true},
{name: "network rule admits its range", policies: append(shipped, permitAll, lanOnly), source: "ci", addr: "10.1.2.3", allowed: true},
{name: "network rule refuses outside its range", policies: append(shipped, permitAll, lanOnly), source: "ci", addr: "203.0.113.9"},
{name: "source policy refuses another sender", policies: append(shipped, sourceOnly), source: "github", addr: "203.0.113.9"},
{name: "source policy admits its sender", policies: append(shipped, sourceOnly), source: "github", addr: "140.82.112.5", allowed: true},
{name: "source policy leaves other sources alone", policies: append(shipped, sourceOnly), source: "ci", addr: "203.0.113.9", allowed: true},
{name: "other org's source policy refuses an out-of-range sender", org: "acme", policies: append(shipped, acmeOnly), source: "hook", addr: "203.0.113.9"},
{name: "other org's source policy admits its sender", org: "acme", policies: append(shipped, acmeOnly), source: "hook", addr: "10.1.2.3", allowed: true},
{name: "other org's source policy leaves the default org alone", policies: append(shipped, acmeOnly), source: "hook", addr: "203.0.113.9", allowed: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
engine := NewEngine(tt.policies)
acting := tt.org
if acting == "" {
acting = DefaultOrgID
}
if got := engine.AuthorizeDelivery(t.Context(), acting, tt.source, tt.addr); got.Allowed != tt.allowed {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.allowed, got)
}
})
}
}
// TestPolicyGuard pins that policy edits validate against the Cedar schema and
// refuse any change that leaves an org without an active member permitted to
// manage policies, regardless of role name.
func TestPolicyGuard(t *testing.T) {
const testOrg = OrgID("org-sys")
const customOrg = OrgID("acme")
shipped := ShippedOrgPolicies(testOrg)
orgPolicy := func(orgID OrgID, id, text string) Policy {
return Policy{ID: id, Level: LevelOrg, OrgID: orgID, Text: text}
}
sreReadPolicy := orgPolicy(customOrg, "sre-read", `permit(principal, action == Archie::Action::"read", resource) when {
resource.org == principal.org &&
principal.role == "sre"
};`)
srePolicy := orgPolicy(customOrg, "sre-manage", `permit(principal, action, resource) when {
resource.org == principal.org &&
principal.role == "sre"
};`)
basePolicies := append(slices.Clone(shipped), sreReadPolicy, srePolicy)
principals := func(_ context.Context, id OrgID) ([]Principal, error) {
switch id {
case testOrg:
return []Principal{{
IdentityID: "sam", Org: testOrg,
Memberships: []Membership{{IdentityID: "sam", OrgID: testOrg, Role: RoleOwner}},
}}, nil
case customOrg:
return []Principal{{
IdentityID: "pat", Org: customOrg,
Memberships: []Membership{{IdentityID: "pat", OrgID: customOrg, Role: Role("sre")}},
}}, nil
}
return nil, nil
}
orgs := []Org{{ID: testOrg}, {ID: customOrg}}
tests := []struct {
name string
put *Policy
delete *Policy
want error
}{
{
name: "harmless addition",
put: new(orgPolicy(testOrg, "viewers-read", `permit(principal, action == Archie::Action::"read", resource);`)),
},
{
name: "text that does not compile",
put: new(orgPolicy(testOrg, "broken", `permit(principal, action == Archie::Action::"nope", resource);`)),
want: ErrPolicyInvalidText,
},
{
name: "forbid locks owners out",
put: new(orgPolicy(testOrg, "lock", `forbid(principal, action == Archie::Action::"manage_policies", resource);`)),
want: ErrPolicyLockout,
},
{
name: "deleting the owner policy while the admin policy still covers owners",
delete: &shipped[3],
},
{
name: "deleting the read policy",
delete: &shipped[0],
},
{
name: "custom role org keeps manage_policies on harmless edit",
put: new(orgPolicy(customOrg, "sre-logs", `permit(principal, action == Archie::Action::"read_logs", resource);`)),
},
{
name: "deleting the custom role policy locks out custom role org",
delete: &srePolicy,
want: ErrPolicyLockout,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var err error
if tt.put != nil {
err = NewEngine(nil).Validate(*tt.put)
if err == nil {
p := *tt.put
err = CheckPolicyChange(t.Context(), basePolicies, func(cur []Policy) []Policy {
return append(slices.DeleteFunc(cur, func(c Policy) bool { return samePolicy(c, p) }), p)
}, orgs, principals)
}
} else {
d := *tt.delete
err = CheckPolicyChange(t.Context(), basePolicies, func(cur []Policy) []Policy {
return slices.DeleteFunc(cur, func(c Policy) bool { return samePolicy(c, d) })
}, orgs, principals)
}
if !errors.Is(err, tt.want) {
t.Fatalf("err = %v, want %v", err, tt.want)
}
})
}
}
// TestCustomRoleAndMemberStatePolicy pins that Role accepts any stable
// identifier and that starter admin vs owner member management boundaries live
// in the Cedar policy rather than Go code.
func TestCustomRoleAndMemberStatePolicy(t *testing.T) {
for _, tc := range []struct {
role Role
valid bool
}{
{Role("sre"), true},
{Role("secops"), true},
{Role("on-call.lead"), true},
{Role("Admin"), false},
{Role("bad/role"), false},
{Role(""), false},
} {
err := tc.role.Validate()
if (err == nil) != tc.valid {
t.Fatalf("Role(%q).Validate() = %v, want valid=%v", tc.role, err, tc.valid)
}
if !tc.valid && !errors.Is(err, ErrInvalidRole) {
t.Fatalf("Role(%q).Validate() = %v, want ErrInvalidRole", tc.role, err)
}
}
const acme = OrgID("acme")
engine := NewEngine(ShippedOrgPolicies(acme))
principal := func(id IdentityID, role Role) Principal {
return Principal{
IdentityID: id,
Org: acme,
Memberships: []Membership{{IdentityID: id, OrgID: acme, Role: role}},
}
}
tests := []struct {
name string
role Role
target string
wantAllow bool
}{
{"admin grants developer", RoleAdmin, string(RoleDeveloper), true},
{"admin cannot grant owner", RoleAdmin, string(RoleOwner), false},
{"owner grants developer", RoleOwner, string(RoleDeveloper), true},
{"owner grants owner", RoleOwner, string(RoleOwner), true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
res := Resource{Kind: KindMember, Org: acme, State: tt.target}
got := engine.Authorize(t.Context(), principal("actor", tt.role), ActionManageMembers, res, AccessContext{})
if got.Allowed != tt.wantAllow {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.wantAllow, got)
}
})
}
}
// fakePolicySeed records the one atomic seed the module asks for.
type fakePolicySeed struct {
calls int
ids []string
rows []store.PolicyRow
err error
}
func (f *fakePolicySeed) SeedOrgPolicies(_ context.Context, _ string, shippedIDs []string, rows []store.PolicyRow) error {
f.calls++
f.ids, f.rows = shippedIDs, rows
return f.err
}
// TestSeedShippedPolicies guards that the shipped set is written in one call
// rather than one policy at a time, which is what left an org holding only some
// of its role policies. The transaction, the zero-count check under the lock and
// how deletions and edits survive are proven against Postgres in the binary's
// smoke test.
func TestSeedShippedPolicies(t *testing.T) {
seeder := &fakePolicySeed{}
if err := seedShippedPolicies(t.Context(), seeder, DefaultOrgID); err != nil {
t.Fatalf("seed: %v", err)
}
shipped := ShippedOrgPolicies(DefaultOrgID)
if seeder.calls != 1 {
t.Fatalf("seed calls = %d, want 1", seeder.calls)
}
if len(seeder.rows) != len(shipped) || len(seeder.ids) != len(shipped) {
t.Fatalf("seeded %d rows and %d ids, want %d of each", len(seeder.rows), len(seeder.ids), len(shipped))
}
for i, p := range shipped {
if seeder.rows[i].PolicyID != p.ID || seeder.ids[i] != p.ID {
t.Fatalf("row %d = %s, want %s", i, seeder.rows[i].PolicyID, p.ID)
}
}
if err := seedShippedPolicies(t.Context(), &fakePolicySeed{err: errors.New("connection reset by peer")}, DefaultOrgID); err == nil {
t.Fatal("a failed seed returned no error")
}
}