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") } }