Files
pages/internal/store/groups_inheritance_test.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

393 lines
14 KiB
Go

package store
import (
"database/sql"
"errors"
"strings"
"testing"
)
func campusInheritanceFixture(t *testing.T) (*Store, map[string]string) {
t.Helper()
database, err := sql.Open("sqlite", ":memory:")
if err != nil {
t.Fatal(err)
}
database.SetMaxOpenConns(1)
t.Cleanup(func() { _ = database.Close() })
st := &Store{DB: database, authKey: make([]byte, 32)}
if _, err := database.Exec(`CREATE TABLE domains(uuid TEXT PRIMARY KEY,campus_uuid TEXT,enabled INTEGER NOT NULL DEFAULT 1);
INSERT INTO domains(uuid,campus_uuid) VALUES('d1','c1'),('d2','c1'),('d3','c1'),('outside','c2')`); err != nil {
t.Fatal(err)
}
if err := st.EnsureAuthSchema(); err != nil {
t.Fatal(err)
}
if err := st.EnsureBuiltinAdminGroups(); err != nil {
t.Fatal(err)
}
groups := map[string]string{}
for _, domain := range []string{"d1", "d2", "d3", "outside"} {
group, err := st.GroupByName(domain, "campus_admin")
if err != nil {
t.Fatal(err)
}
groups[domain] = group.UUID
}
return st, groups
}
func campusLocalIdentity(t *testing.T, st *Store, domain, name string) string {
t.Helper()
if _, err := st.DB.Exec(`INSERT OR IGNORE INTO principals(uuid,display_name,state,created_at_ms,updated_at_ms) VALUES(?,?,'active',1,1)`, name, name); err != nil {
t.Fatal(err)
}
if _, err := st.DB.Exec(`INSERT OR IGNORE INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,'password',?,1)`, name, name, name); err != nil {
t.Fatal(err)
}
if _, err := st.DB.Exec(`INSERT OR IGNORE INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,'active',1)`, domain+":"+name, domain, name); err != nil {
t.Fatal(err)
}
var id string
if err := st.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?`, domain, name).Scan(&id); err != nil {
t.Fatal(err)
}
return id
}
func requireCampusMember(t *testing.T, st *Store, domain, principal string, want bool) {
t.Helper()
var got bool
if err := st.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?)`, domain, principal).Scan(&got); err != nil {
t.Fatal(err)
}
if got != want {
t.Fatalf("membership %s/%s = %v, want %v", domain, principal, got, want)
}
}
func TestCampusAdminDisableRevokesDerivedMembershipsAndSessions(t *testing.T) {
st, groups := campusInheritanceFixture(t)
campusLocalIdentity(t, st, "d1", "alice")
if err := st.AddGroupMemberByUsername("d1", groups["d1"], "alice", "owner"); err != nil {
t.Fatal(err)
}
if !st.IsBuiltinGroupAdmin("d2", "alice", "campus_admin") {
t.Fatal("missing inherited administrative access")
}
requireCampusMember(t, st, "outside", "alice", false)
if err := st.SetGroupPermission(groups["d2"], "/secret", "read_write"); err != nil {
t.Fatal(err)
}
req := AuthorizationRequest{DomainUUID: "d2", PrincipalUUID: "alice", Capability: "read", TargetType: "path", TargetID: "/secret/page"}
if err := st.Authorize(req); err != nil {
t.Fatal(err)
}
token, err := st.CreateAuthSession("d2", "alice")
if err != nil {
t.Fatal(err)
}
var before string
if err := st.DB.QueryRow(`SELECT uuid||':'||created_at_ms FROM domain_memberships WHERE domain_uuid='d2' AND principal_uuid='alice'`).Scan(&before); err != nil {
t.Fatal(err)
}
for range 3 {
if err := st.ProjectCampusAdminMemberships(); err != nil {
t.Fatal(err)
}
}
var after string
if err := st.DB.QueryRow(`SELECT uuid||':'||created_at_ms FROM domain_memberships WHERE domain_uuid='d2' AND principal_uuid='alice'`).Scan(&after); err != nil || before != after {
t.Fatalf("projection changed identity: before=%s after=%s err=%v", before, after, err)
}
for range 2 {
if err := st.SetCampusAdminInheritance(groups["d1"], false); err != nil {
t.Fatal(err)
}
}
for _, domain := range []string{"d2", "d3"} {
requireCampusMember(t, st, domain, "alice", false)
if st.IsBuiltinGroupAdmin(domain, "alice", "campus_admin") {
t.Fatal("inherited administrative access survived disable")
}
}
if !st.IsBuiltinGroupAdmin("d1", "alice", "campus_admin") {
t.Fatal("disable removed independent source rights")
}
if err := st.Authorize(req); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("derived group permission survived: %v", err)
}
if _, err := st.PrincipalForSession("d2", token); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("derived-only session survived: %v", err)
}
if err := st.SetCampusAdminInheritance(groups["d1"], true); err != nil {
t.Fatal(err)
}
if !st.IsBuiltinGroupAdmin("d2", "alice", "campus_admin") {
t.Fatal("re-enable did not restore derived grants")
}
if _, err := st.PrincipalForSession("d2", token); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("re-enable revived a revoked session: %v", err)
}
}
func TestCampusAdminMultipleRootsAndLocalRolePreservation(t *testing.T) {
t.Run("multiple roots do not amplify", func(t *testing.T) {
st, groups := campusInheritanceFixture(t)
campusLocalIdentity(t, st, "d1", "alice")
for _, domain := range []string{"d1", "d2"} {
if err := st.AddGroupMemberByUsername(domain, groups[domain], "alice", "owner"); err != nil {
t.Fatal(err)
}
}
for range 3 {
if err := st.ProjectCampusAdminMemberships(); err != nil {
t.Fatal(err)
}
}
var count int
if err := st.DB.QueryRow(`SELECT COUNT(*) FROM campus_admin_grants WHERE source=?`, campusAdminInheritancePrefix+groups["d3"]).Scan(&count); err != nil || count != 0 {
t.Fatalf("derived-only Domain became a root: count=%d err=%v", count, err)
}
if err := st.SetCampusAdminInheritance(groups["d1"], false); err != nil {
t.Fatal(err)
}
if !st.IsBuiltinGroupAdmin("d3", "alice", "campus_admin") {
t.Fatal("revoking first root lost independently granted second root")
}
if err := st.SetCampusAdminInheritance(groups["d2"], false); err != nil {
t.Fatal(err)
}
requireCampusMember(t, st, "d3", "alice", false)
for _, domain := range []string{"d1", "d2"} {
if !st.IsBuiltinGroupAdmin(domain, "alice", "campus_admin") {
t.Fatalf("lost direct grant in %s", domain)
}
}
})
t.Run("weaker local role reappears", func(t *testing.T) {
st, groups := campusInheritanceFixture(t)
campusLocalIdentity(t, st, "d1", "alice")
campusLocalIdentity(t, st, "d2", "alice")
if err := st.AddGroupMemberByUsername("d2", groups["d2"], "alice", "member"); err != nil {
t.Fatal(err)
}
if err := st.AddGroupMemberByUsername("d1", groups["d1"], "alice", "owner"); err != nil {
t.Fatal(err)
}
if role := st.GroupMemberRole(groups["d2"], "alice"); role != "owner" {
t.Fatalf("effective role = %s, want owner", role)
}
if err := st.SetCampusAdminInheritance(groups["d1"], false); err != nil {
t.Fatal(err)
}
if role := st.GroupMemberRole(groups["d2"], "alice"); role != "member" {
t.Fatalf("local role after revoke = %s, want member", role)
}
if st.IsBuiltinGroupAdmin("d2", "alice", "campus_admin") {
t.Fatal("local member retained inherited administration")
}
})
}
func TestCampusAdminPreservesIndependentRoleBindingAndSession(t *testing.T) {
st, groups := campusInheritanceFixture(t)
campusLocalIdentity(t, st, "d1", "alice")
if err := st.AddGroupMemberByUsername("d1", groups["d1"], "alice", "owner"); err != nil {
t.Fatal(err)
}
for _, statement := range []string{
`INSERT INTO auth_roles(uuid,domain_uuid,name,created_at_ms) VALUES('reader','d2','reader',1)`,
`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES('read-grant','reader','read','domain','d2',1)`,
`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) SELECT uuid,'reader',1 FROM domain_memberships WHERE domain_uuid='d2' AND principal_uuid='alice'`,
} {
if _, err := st.DB.Exec(statement); err != nil {
t.Fatal(err)
}
}
token, err := st.CreateAuthSession("d2", "alice")
if err != nil {
t.Fatal(err)
}
if err := st.SetCampusAdminInheritance(groups["d1"], false); err != nil {
t.Fatal(err)
}
requireCampusMember(t, st, "d2", "alice", true)
if st.IsBuiltinGroupAdmin("d2", "alice", "campus_admin") {
t.Fatal("independent read binding preserved inherited administrative access")
}
if err := st.Authorize(AuthorizationRequest{DomainUUID: "d2", PrincipalUUID: "alice", Capability: "read", TargetType: "domain", TargetID: "d2"}); err != nil {
t.Fatalf("lost independent reader binding: %v", err)
}
if _, err := st.PrincipalForSession("d2", token); err != nil {
t.Fatalf("revoked independently authorized session: %v", err)
}
}
func TestCampusAdminSourceRemovalAndIdentitySuspension(t *testing.T) {
t.Run("source member removal", func(t *testing.T) {
st, groups := campusInheritanceFixture(t)
aliceID := campusLocalIdentity(t, st, "d1", "alice")
campusLocalIdentity(t, st, "d1", "bob")
for _, name := range []string{"alice", "bob"} {
if err := st.AddGroupMemberByUsername("d1", groups["d1"], name, "owner"); err != nil {
t.Fatal(err)
}
}
if err := st.RemoveGroupMember(groups["d1"], aliceID); err != nil {
t.Fatal(err)
}
requireCampusMember(t, st, "d2", "alice", false)
if !st.IsBuiltinGroupAdmin("d2", "bob", "campus_admin") {
t.Fatal("source removal revoked another principal")
}
if st.IsCampusAdmin("c1", "alice") {
t.Fatal("source removal left campus authority")
}
})
for _, change := range []string{"suspended", "quarantined", "readonly", "archived group", "removed Domain", "disabled Domain", "moved Domain", "suspended membership"} {
t.Run(change, func(t *testing.T) {
st, groups := campusInheritanceFixture(t)
campusLocalIdentity(t, st, "d1", "alice")
if err := st.AddGroupMemberByUsername("d1", groups["d1"], "alice", "owner"); err != nil {
t.Fatal(err)
}
var err error
switch change {
case "archived group":
_, err = st.DB.Exec(`UPDATE groups SET state='archived' WHERE uuid=?`, groups["d1"])
case "removed Domain":
_, err = st.DB.Exec(`DELETE FROM domains WHERE uuid='d1'`)
case "disabled Domain":
_, err = st.DB.Exec(`UPDATE domains SET enabled=0 WHERE uuid='d1'`)
case "moved Domain":
_, err = st.DB.Exec(`UPDATE domains SET campus_uuid='c2' WHERE uuid='d1'`)
case "suspended membership":
_, err = st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid='d1' AND principal_uuid='alice'`)
default:
err = st.SetPrincipalState("d1", "alice", change)
}
if err != nil {
t.Fatal(err)
}
if err := st.ProjectCampusAdminMemberships(); err != nil {
t.Fatal(err)
}
requireCampusMember(t, st, "d2", "alice", false)
if st.IsBuiltinGroupAdmin("d2", "alice", "campus_admin") {
t.Fatal("invalid source retained derived administrative access")
}
})
}
}
func TestCampusAdminRevocationFailureRollsBackSourceMutation(t *testing.T) {
for _, change := range []string{"disable", "remove", "suspend"} {
t.Run(change, func(t *testing.T) {
st, groups := campusInheritanceFixture(t)
aliceID := campusLocalIdentity(t, st, "d1", "alice")
campusLocalIdentity(t, st, "d1", "bob")
for _, name := range []string{"alice", "bob"} {
if err := st.AddGroupMemberByUsername("d1", groups["d1"], name, "owner"); err != nil {
t.Fatal(err)
}
}
if _, err := st.DB.Exec(`CREATE TRIGGER fail_projection BEFORE DELETE ON group_members
WHEN substr(OLD.source,1,21)='campus_admin_inherit:'
BEGIN SELECT RAISE(ABORT,'injected projection failure'); END`); err != nil {
t.Fatal(err)
}
var err error
switch change {
case "disable":
err = st.SetCampusAdminInheritance(groups["d1"], false)
case "remove":
err = st.RemoveGroupMember(groups["d1"], aliceID)
case "suspend":
err = st.SetPrincipalState("d1", "alice", "suspended")
}
if err == nil || !strings.Contains(err.Error(), "injected projection failure") {
t.Fatalf("expected injected failure, got %v", err)
}
group, err := st.GroupByName("d1", "campus_admin")
if err != nil || !group.InheritMembers {
t.Fatalf("source inheritance update did not roll back: %+v %v", group, err)
}
for _, domain := range []string{"d1", "d2"} {
if !st.IsBuiltinGroupAdmin(domain, "alice", "campus_admin") {
t.Fatalf("partial revocation in %s", domain)
}
}
})
}
}
func TestCampusAdminLegacyProjectionDoesNotReseedDerivedRoots(t *testing.T) {
st, groups := campusInheritanceFixture(t)
for _, domain := range []string{"d1", "d2", "d3"} {
member := campusLocalIdentity(t, st, domain, "alice")
source := "local"
if domain == "d2" {
source = campusAdminInheritancePrefix + groups["d1"]
} else if domain == "d3" {
source = campusAdminInheritancePrefix + groups["d2"]
}
if _, err := st.DB.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?,'owner',?,1)`, groups[domain], member, source); err != nil {
t.Fatal(err)
}
}
if _, err := st.DB.Exec(`DROP TABLE campus_admin_grants; DROP TABLE campus_admin_membership_origins; DROP TABLE campus_admin_migrations`); err != nil {
t.Fatal(err)
}
if err := st.EnsureAuthSchema(); err != nil {
t.Fatal(err)
}
if err := st.EnsureBuiltinAdminGroups(); err != nil {
t.Fatal(err)
}
if err := st.SetCampusAdminInheritance(groups["d1"], false); err != nil {
t.Fatal(err)
}
for _, domain := range []string{"d2", "d3"} {
if st.IsBuiltinGroupAdmin(domain, "alice", "campus_admin") {
t.Fatal("legacy derived source survived revocation")
}
// Old versions did not record whether these were local memberships.
// Preserve ambiguous identity records, but never their derived grants.
requireCampusMember(t, st, domain, "alice", true)
}
}
func TestCampusAdminExplicitRemovalSurvivesBootstrapMigration(t *testing.T) {
st, groups := campusInheritanceFixture(t)
owner, err := st.BootstrapOwner("d1", "original", "correct horse battery staple", "Original", "")
if err != nil {
t.Fatal(err)
}
campusLocalIdentity(t, st, "d1", "replacement")
if err := st.AddGroupMemberByUsername("d1", groups["d1"], "replacement", "owner"); err != nil {
t.Fatal(err)
}
var membership string
if err := st.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid='d1' AND principal_uuid=?`, owner.UUID).Scan(&membership); err != nil {
t.Fatal(err)
}
if err := st.RemoveGroupMember(groups["d1"], membership); err != nil {
t.Fatal(err)
}
for range 2 {
if err := st.EnsureAuthSchema(); err != nil {
t.Fatal(err)
}
if err := st.EnsureBuiltinAdminGroups(); err != nil {
t.Fatal(err)
}
}
if st.IsCampusAdmin("c1", owner.UUID) {
t.Fatal("bootstrap role migration recreated an explicitly removed campus grant")
}
if !st.IsBuiltinGroupAdmin("d1", owner.UUID, "domain_admin") {
t.Fatal("campus revoke destroyed independent Domain administration")
}
}