- 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
302 lines
12 KiB
Go
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)
|
|
}
|
|
})
|
|
}
|