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.
393 lines
14 KiB
Go
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")
|
|
}
|
|
}
|