Files
pages/internal/store/governance_backend_test.go
2026-11-15 05:47:14 +09:00

170 lines
6.8 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"testing"
)
func TestGovernanceBackendOwnershipAndCeilings(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := localityBackendStore(t, b)
ctx := context.Background()
exec := func(q string, args ...any) {
t.Helper()
if _, err := s.DB.Exec(q, args...); err != nil {
t.Fatal(err)
}
}
admin, err := s.BootstrapOwner(d, "admin", "synthetic governance test password", "Administrator", "")
if err != nil {
t.Fatal(err)
}
quarter, err := s.CreatePasswordAccount(d, "quarter", "synthetic governance test password", "Quartier owner", "")
if err != nil {
t.Fatal(err)
}
spot, err := s.CreatePasswordAccount(d, "spot", "synthetic governance test password", "Spot owner", "")
if err != nil {
t.Fatal(err)
}
member := func(p string) string {
t.Helper()
var m string
if err := s.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE principal_uuid=`+s.sqlParam(1), p).Scan(&m); err != nil {
t.Fatal(err)
}
return m
}
exec(`INSERT INTO zones(uuid,domain_uuid,kind,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(7)+`)`, "q", d, "quartier", "life", "/life", 1, 1)
exec(`INSERT INTO zones(uuid,domain_uuid,kind,parent_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(8)+`)`, "st", d, "street", "q", "home", "/life/home", 1, 1)
exec(`INSERT INTO spots(uuid,domain_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(6)+`)`, "sp", d, "room", "/life/home/room", 1, 1)
exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES('st','sp',1)`)
set := func(actor, kind, id, policy string, owners *[]string, preview bool) (CityGovernance, error) {
t.Helper()
g, err := s.CityGovernance(ctx, d, actor, kind, id)
if err != nil {
return g, err
}
var p *string
if policy != "" {
p = &policy
}
return s.ChangeCityGovernance(ctx, d, actor, kind, id, CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: p, Owners: owners, ConfirmRelaxation: true}, preview)
}
// A child cannot broaden an authenticated-only Domain ceiling.
if _, err = set(admin.UUID, "quartier", "q", "public", nil, false); !errors.Is(err, ErrGovernanceCeiling) {
t.Fatal("ceiling bypass", err)
}
if _, err = set(admin.UUID, "domain", d, "public", nil, false); err != nil {
t.Fatal(err)
}
owners := []string{member(quarter.UUID)}
if _, err = set(admin.UUID, "quartier", "q", "public", &owners, false); err != nil {
t.Fatal(err)
}
owners = []string{member(spot.UUID)}
if _, err = set(quarter.UUID, "spot", "sp", "public", &owners, false); err != nil {
t.Fatal(err)
}
g, err := s.CityGovernance(ctx, d, spot.UUID, "spot", "sp")
if err != nil || g.CanAppoint || !g.DraftEffectivePublic || g.PublicationEnabled {
t.Fatal("ownership or publication intent mismatch", g, err)
}
if _, err = set(spot.UUID, "quartier", "q", "authenticated_acl", nil, false); !errors.Is(err, ErrAccessDenied) {
t.Fatal("spot owner controls ancestor", err)
}
if _, err = set(spot.UUID, "spot", "sp", "", &owners, false); !errors.Is(err, ErrAccessDenied) {
t.Fatal("spot owner appoints owner", err)
}
candidates, err := s.CityGovernanceMembers(ctx, d, quarter.UUID, "spot", "sp", "SPOT")
if err != nil || len(candidates) != 1 || candidates[0].Username != "spot" {
t.Fatal("candidate lookup", candidates, err)
}
old := g
if _, err = set(quarter.UUID, "spot", "sp", "authenticated_acl", nil, true); err != nil {
t.Fatal(err)
}
g, err = s.CityGovernance(ctx, d, spot.UUID, "spot", "sp")
if err != nil || g.Policy != old.Policy || g.Epoch != old.Epoch {
t.Fatal("preview mutated policy", err)
}
if _, err = set(quarter.UUID, "quartier", "q", "authenticated_acl", nil, false); err != nil {
t.Fatal(err)
}
if _, err = set(spot.UUID, "spot", "sp", "public", nil, false); !errors.Is(err, ErrGovernanceCeiling) {
t.Fatal("lower owner broadened ceiling", err)
}
p := "inherit"
if _, err = s.ChangeCityGovernance(ctx, d, spot.UUID, "spot", "sp", CityGovernanceChange{Epoch: old.Epoch, TopologyVersion: old.TopologyVersion, Policy: &p}, false); !errors.Is(err, ErrGovernanceConflict) {
t.Fatal("stale governance edit accepted", err)
}
if err = s.SetConfigInDomain(d, "authorization_mode", "enforcing"); err != nil {
t.Fatal(err)
}
acl, err := s.LocalityAccess(ctx, d, admin.UUID, "spot", "sp", nil)
if err != nil {
t.Fatal(err)
}
acl.Mode = "restricted"
acl.Entries = []LocalityAccessEntry{{Kind: "user", Name: "spot", Permission: "read"}}
acl, err = s.LocalityAccess(ctx, d, admin.UUID, "spot", "sp", &acl)
if err != nil || acl.AuthorityRank != 3 || !acl.GrantsAccess {
t.Fatal("administrator ACL", acl, err)
}
acl.Entries[0].Permission = "read_write"
if _, err = s.LocalityAccess(ctx, d, spot.UUID, "spot", "sp", &acl); !errors.Is(err, ErrGovernanceCeiling) {
t.Fatal("lower owner expanded ACL", err)
}
acl.Entries = nil
acl, err = s.LocalityAccess(ctx, d, spot.UUID, "spot", "sp", &acl)
if err != nil || acl.AuthorityRank != 3 {
t.Fatal("lower owner could not narrow ACL", err)
}
if _, err := s.DB.Exec(`UPDATE spots SET path_prefix='/elsewhere' WHERE uuid='sp'`); err == nil {
t.Fatal("City path bypassed protected ACL")
}
if _, err := s.DB.Exec(`DELETE FROM street_spots WHERE spot_uuid='sp'`); err == nil {
t.Fatal("City membership bypassed protected ACL")
}
// Audit failure must roll back policy and epoch together.
concurrent, err := s.CityGovernance(ctx, d, admin.UUID, "domain", d)
if err != nil {
t.Fatal(err)
}
results := make(chan error, 2)
for i := 0; i < 2; i++ {
go func() {
_, e := s.ChangeCityGovernance(ctx, d, admin.UUID, "domain", d, CityGovernanceChange{Epoch: concurrent.Epoch, TopologyVersion: concurrent.TopologyVersion, Policy: &concurrent.Policy}, false)
results <- e
}()
}
winners := 0
for i := 0; i < 2; i++ {
if e := <-results; e == nil {
winners++
} else if !errors.Is(e, ErrGovernanceConflict) {
t.Fatal(e)
}
}
if winners != 1 {
t.Fatal("concurrent governance updates lost CAS", winners)
}
before, err := s.CityGovernance(ctx, d, admin.UUID, "domain", d)
if err != nil {
t.Fatal(err)
}
exec(`ALTER TABLE city_governance_events RENAME COLUMN after_json TO unavailable_after`)
if _, err = set(admin.UUID, "domain", d, "authenticated_acl", nil, false); err == nil {
t.Fatal("missing audit accepted")
}
after, err := s.CityGovernance(ctx, d, admin.UUID, "domain", d)
if err != nil || before.Epoch != after.Epoch || before.Policy != after.Policy {
t.Fatal("partial governance commit", err)
}
})
}
}