Files
summercms/modules/cabana/backend_access_revoked_test.go
Jakub Zych 7ecfa6087d test(32.2-05): unit tests for administrator MCP grants, admin consent, account items and access revocation
- wristband: TestAuthorizeConsentPath, TestAuthorizeDefaultScopes
- pier: TestBackendOnlyGrant, TestLinkedGrantNoScopeLimit (Docker)
- cabana: TestTokenScopeNames, TestMCPAdminConsent, TestAccountContributionItems,
  TestBackendAccessRevokedEvent (Docker); export_test.go exposes the event
  helper for the de-duplication case
2026-11-21 02:00:16 +01:00

302 lines
12 KiB
Go

package cabana_test
import (
"bytes"
"context"
"errors"
"net/http"
"slices"
"sync"
"sync/atomic"
"testing"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/bonfire"
"git.golem15.com/golem15/summercms/modules/cabana"
"git.golem15.com/golem15/summercms/modules/pact"
)
// accessEvents records the in-transaction BackendAccessRevokedEvents and
// the after-commit pact.MCPSubjectChanged events of one app; while fail is
// set the first listener answers an error, so the save rolls back.
type accessEvents struct {
mu sync.Mutex
revoked []cabana.BackendAccessRevokedEvent
subjects []pact.MCPSubjectChanged
fail atomic.Bool
}
func listenAccessEvents(app *backpack.App) *accessEvents {
rec := &accessEvents{}
app.Events.Listen("test-revoked", func(_ context.Context, ev *cabana.BackendAccessRevokedEvent) error {
rec.mu.Lock()
rec.revoked = append(rec.revoked, *ev)
rec.mu.Unlock()
if rec.fail.Load() {
return errors.New("listener refused")
}
return nil
})
app.Events.Listen("test-subjects", func(_ context.Context, ev *pact.MCPSubjectChanged) error {
rec.mu.Lock()
rec.subjects = append(rec.subjects, *ev)
rec.mu.Unlock()
return nil
})
return rec
}
// take answers and clears what was recorded.
func (r *accessEvents) take() ([]cabana.BackendAccessRevokedEvent, []pact.MCPSubjectChanged) {
r.mu.Lock()
defer r.mu.Unlock()
revoked, subjects := r.revoked, r.subjects
r.revoked, r.subjects = nil, nil
return revoked, subjects
}
// sortedIDs answers ids sorted, for an order-free comparison.
func sortedIDs(ids []uint) []uint {
out := slices.Clone(ids)
slices.Sort(out)
return out
}
// TestBackendAccessRevokedEvent locks every D-13 site of
// cabana.BackendAccessRevokedEvent on Postgres (SC-3, D-13): deleting,
// deactivating, another administrator setting a password, an own password
// change, admin:reset-password, a role, own-permissions or superuser change
// and a role's permission change (once, with every holder) each fire one
// event with the right reason, ids and a non-nil Tx; the helper
// de-duplicates ids; a listener error rolls the delete and the role save
// back; a name-only edit fires nothing; and the after-commit
// pact.MCPSubjectChanged emissions of the same saves still happen (none
// for a rolled-back save). Needs Docker; skips under -short.
func TestBackendAccessRevokedEvent(t *testing.T) {
env := newScreensEnv(t)
rec := listenAccessEvents(env.app)
_, rootToken := env.admin(t, "access-root", true, "")
expectRevoked := func(t *testing.T, reason string, ids ...uint) []pact.MCPSubjectChanged {
t.Helper()
revoked, subjects := rec.take()
if len(revoked) != 1 {
t.Fatalf("%s: %d BackendAccessRevokedEvents, want 1: %+v", reason, len(revoked), revoked)
}
ev := revoked[0]
if ev.Reason != reason || !slices.Equal(sortedIDs(ev.AdminIDs), sortedIDs(ids)) || ev.Tx == nil {
t.Fatalf("%s: event %+v, want ids %v with a transaction", reason, ev, ids)
}
return subjects
}
expectSubjects := func(t *testing.T, subjects []pact.MCPSubjectChanged, kind string, ids ...uint) {
t.Helper()
var got []uint
for _, s := range subjects {
if s.Guard != "backend" || s.Kind != kind {
t.Fatalf("MCPSubjectChanged %+v, want guard backend kind %s", s, kind)
}
got = append(got, s.UserID)
}
if !slices.Equal(sortedIDs(got), sortedIDs(ids)) {
t.Fatalf("MCPSubjectChanged ids %v, want %v", got, ids)
}
}
rec.take()
t.Run("delete", func(t *testing.T) {
gone, _ := env.admin(t, "access-gone", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodDelete, userURL(gone.ID), rootToken, nil)
expectSubjects(t, expectRevoked(t, cabana.BackendAccessDeleted, gone.ID), pact.MCPSubjectDeleted, gone.ID)
})
t.Run("deactivate", func(t *testing.T) {
target, _ := env.admin(t, "access-off", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodPost, userURL(target.ID, "actions", "deactivate"), rootToken, map[string]any{})
expectSubjects(t, expectRevoked(t, cabana.BackendAccessDeactivated, target.ID), pact.MCPSubjectDeleted, target.ID)
})
t.Run("password set by another administrator", func(t *testing.T) {
target, _ := env.admin(t, "access-pw", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, userURL(target.ID), rootToken,
map[string]any{"login": target.Login, "email": target.Email, "password": "pass-5678", "password_confirmation": "pass-5678"})
expectRevoked(t, cabana.BackendAccessPasswordSet, target.ID)
})
t.Run("own password change", func(t *testing.T) {
self, selfToken := env.admin(t, "access-self", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, "/account", selfToken,
map[string]any{"email": self.Email, "current_password": adminTestPassword, "password": "brand-new-secret", "password_confirmation": "brand-new-secret"})
expectRevoked(t, cabana.BackendAccessPasswordChanged, self.ID)
})
t.Run("admin:reset-password", func(t *testing.T) {
target, _ := env.admin(t, "access-reset", false, "")
rec.take()
reset := commandByName(t, cabana.RuntimeCommands(env.app), "admin:reset-password")
var buf bytes.Buffer
if err := reset.Run(context.Background(), flagInput{
args: []string{target.Login},
flags: map[string]string{"password": "reset-replacement-password"},
}, bonfire.NewOutput(nil, &buf, &buf)); err != nil {
t.Fatalf("admin:reset-password: %v", err)
}
expectRevoked(t, cabana.BackendAccessPasswordReset, target.ID)
})
t.Run("admin:reset-password rolls back on a listener error", func(t *testing.T) {
target, _ := env.admin(t, "access-reset-veto", false, "")
before := env.storedUser(t, target.ID).Password
rec.take()
rec.fail.Store(true)
reset := commandByName(t, cabana.RuntimeCommands(env.app), "admin:reset-password")
var buf bytes.Buffer
err := reset.Run(context.Background(), flagInput{
args: []string{target.Login},
flags: map[string]string{"password": "reset-replacement-password"},
}, bonfire.NewOutput(nil, &buf, &buf))
rec.fail.Store(false)
if err == nil {
t.Fatal("a vetoed reset succeeded")
}
if env.storedUser(t, target.ID).Password != before {
t.Fatal("a vetoed reset wrote the new hash")
}
expectRevoked(t, cabana.BackendAccessPasswordReset, target.ID)
})
t.Run("role change", func(t *testing.T) {
target, _ := env.admin(t, "access-role", false, "")
other := env.seedRole(t, roleSeed{Name: "access-other"})
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, userURL(target.ID), rootToken,
map[string]any{"login": target.Login, "email": target.Email, "role": other.ID})
expectSubjects(t, expectRevoked(t, cabana.BackendAccessPermissions, target.ID), pact.MCPSubjectPermissions, target.ID)
})
t.Run("own permissions change", func(t *testing.T) {
target, _ := env.admin(t, "access-perms", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, userURL(target.ID), rootToken,
map[string]any{"login": target.Login, "email": target.Email, "permissions": map[string]any{pingPermission: 1}})
expectSubjects(t, expectRevoked(t, cabana.BackendAccessPermissions, target.ID), pact.MCPSubjectPermissions, target.ID)
})
t.Run("superuser change", func(t *testing.T) {
target, _ := env.admin(t, "access-super", false, "")
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, userURL(target.ID), rootToken,
map[string]any{"login": target.Login, "email": target.Email, "is_superuser": true})
expectSubjects(t, expectRevoked(t, cabana.BackendAccessPermissions, target.ID), pact.MCPSubjectPermissions, target.ID)
if !env.storedUser(t, target.ID).IsSuperuser {
t.Fatal("the superuser flag was not saved")
}
})
t.Run("a role's permission change fires once with every holder", func(t *testing.T) {
role := env.seedRole(t, roleSeed{Name: "access-shared", Permissions: map[string]int{"acme.demo.access": 1}})
a := env.seedAdmin(t, adminSeed{Name: "access-holder-a", Role: role.ID})
b := env.seedAdmin(t, adminSeed{Name: "access-holder-b", Role: role.ID})
bystander := env.seedAdmin(t, adminSeed{Name: "access-bystander"})
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, roleURL(role.ID), rootToken,
roleBody(role, map[string]any{"permissions": map[string]any{"acme.demo.access": 1, pingPermission: 1}}))
subjects := expectRevoked(t, cabana.BackendAccessPermissions, a.ID, b.ID)
expectSubjects(t, subjects, pact.MCPSubjectPermissions, a.ID, b.ID)
for _, s := range subjects {
if s.UserID == bystander.ID {
t.Fatal("a bystander got a subject event")
}
}
})
t.Run("no event for unrelated edits", func(t *testing.T) {
target, _ := env.admin(t, "access-name", false, "")
role := env.seedRole(t, roleSeed{Name: "access-quiet", Permissions: map[string]int{"acme.demo.access": 1}})
env.seedAdmin(t, adminSeed{Name: "access-quiet-holder", Role: role.ID})
rec.take()
env.expect(t, http.StatusOK, http.MethodPut, userURL(target.ID), rootToken,
map[string]any{"login": target.Login, "email": target.Email, "first_name": "Renamed"})
env.expect(t, http.StatusOK, http.MethodPut, roleURL(role.ID), rootToken,
roleBody(role, map[string]any{"description": "Only the description", "permissions": map[string]any{"acme.demo.access": 1}}))
if revoked, subjects := rec.take(); len(revoked) != 0 || len(subjects) != 0 {
t.Fatalf("unrelated edits fired %+v and %+v", revoked, subjects)
}
})
t.Run("a listener error rolls the delete back", func(t *testing.T) {
kept, _ := env.admin(t, "access-veto-delete", false, "")
rec.take()
rec.fail.Store(true)
res := env.call(t, http.MethodDelete, userURL(kept.ID), rootToken, nil)
rec.fail.Store(false)
if res.Code >= 200 && res.Code < 300 {
t.Fatalf("vetoed delete answered %d %s", res.Code, res.Body.String())
}
if env.storedUser(t, kept.ID).DeletedAt.Valid {
t.Fatal("a vetoed delete deleted the administrator")
}
revoked, subjects := rec.take()
if len(revoked) != 1 || revoked[0].Reason != cabana.BackendAccessDeleted {
t.Fatalf("vetoed delete events %+v", revoked)
}
if len(subjects) != 0 {
t.Fatalf("a rolled-back delete fired MCPSubjectChanged %+v", subjects)
}
})
t.Run("a listener error rolls the role save back", func(t *testing.T) {
role := env.seedRole(t, roleSeed{Name: "access-veto-role", Permissions: map[string]int{"acme.demo.access": 1}})
holder := env.seedAdmin(t, adminSeed{Name: "access-veto-holder", Role: role.ID})
var before string
if err := env.gdb.Raw(`SELECT permissions FROM backend_user_roles WHERE id = ?`, role.ID).Scan(&before).Error; err != nil {
t.Fatal(err)
}
rec.take()
rec.fail.Store(true)
res := env.call(t, http.MethodPut, roleURL(role.ID), rootToken,
roleBody(role, map[string]any{"permissions": map[string]any{"acme.demo.access": 1, pingPermission: 1}}))
rec.fail.Store(false)
if res.Code >= 200 && res.Code < 300 {
t.Fatalf("vetoed role save answered %d %s", res.Code, res.Body.String())
}
var after string
if err := env.gdb.Raw(`SELECT permissions FROM backend_user_roles WHERE id = ?`, role.ID).Scan(&after).Error; err != nil {
t.Fatal(err)
}
if after != before {
t.Fatalf("a vetoed role save wrote permissions %s (was %s)", after, before)
}
revoked, subjects := rec.take()
if len(revoked) != 1 || !slices.Equal(revoked[0].AdminIDs, []uint{holder.ID}) {
t.Fatalf("vetoed role save events %+v", revoked)
}
if len(subjects) != 0 {
t.Fatalf("a rolled-back role save fired MCPSubjectChanged %+v", subjects)
}
})
t.Run("the helper de-duplicates ids", func(t *testing.T) {
rec.take()
if err := cabana.FireBackendAccessRevokedForTest(context.Background(), env.app, env.gdb, cabana.BackendAccessPermissions, 7, 0, 7, 9, 9, 7); err != nil {
t.Fatal(err)
}
revoked, _ := rec.take()
if len(revoked) != 1 || !slices.Equal(revoked[0].AdminIDs, []uint{7, 9}) {
t.Fatalf("events %+v, want one with [7 9] in first-seen order", revoked)
}
if err := cabana.FireBackendAccessRevokedForTest(context.Background(), env.app, env.gdb, cabana.BackendAccessPermissions, 0); err != nil {
t.Fatal(err)
}
if err := cabana.FireBackendAccessRevokedForTest(context.Background(), nil, nil, cabana.BackendAccessPermissions, 7); err != nil {
t.Fatal(err)
}
if revoked, _ := rec.take(); len(revoked) != 0 {
t.Fatalf("no ids or no app fired %+v", revoked)
}
})
}