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/lagoon" "git.golem15.com/golem15/summercms/modules/pact" "gorm.io/gorm" ) // accessEvents records the in-transaction BackendAccessRevokedEvents and // the after-commit pact.MCPSubjectChanged events of one app, and counts the // after-commit callbacks the revoked listener registers on the event's Tx // that ran (as a listener that fires session events after the commit // does); 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 committed atomic.Int64 } func listenAccessEvents(app *backpack.App) *accessEvents { rec := &accessEvents{} app.Events.Listen("test-revoked", func(ctx context.Context, ev *cabana.BackendAccessRevokedEvent) error { rec.mu.Lock() rec.revoked = append(rec.revoked, *ev) rec.mu.Unlock() lagoon.AfterCommit(ctx, ev.Tx, func(context.Context, *gorm.DB) { rec.committed.Add(1) }) 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() before := rec.committed.Load() 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) // The command commits through lagoon, so after-commit work a // listener registers on the event's Tx runs, once. if got := rec.committed.Load() - before; got != 1 { t.Fatalf("after-commit callbacks run by the reset = %d, want 1", got) } }) 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() committed := rec.committed.Load() 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") } if rec.committed.Load() != committed { t.Fatal("after-commit work ran for a rolled-back reset") } 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) } }) }