Files
pages/internal/server/city_governance_test.go
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

239 lines
9.4 KiB
Go

package server
import (
"context"
"encoding/json"
"net/http/httptest"
"strings"
"sync"
"testing"
"pageswiki/internal/store"
)
func TestCityGovernanceDelegationAndCaps(t *testing.T) {
s, admin, domain := configFixture(t)
s.mux.HandleFunc("/_/api/v1/city/", s.handleCityAPI)
q, err := s.store.CreateZoneAtPath(domain, "test", "quartier", "", "life", "Life", "", "/life")
if err != nil {
t.Fatal(err)
}
street, err := s.store.CreateZoneAtPath(domain, "test", "street", q, "home", "Home", "", "/life/home")
if err != nil {
t.Fatal(err)
}
spot, err := s.store.CreateSpotAtPath(domain, "test", street, "desk", "Desk", "", "/life/home/desk")
if err != nil {
t.Fatal(err)
}
q2, err := s.store.CreateZoneAtPath(domain, "test", "quartier", "", "work", "Work", "", "/work")
if err != nil {
t.Fatal(err)
}
tokens, members, principals := map[string]string{}, map[string]string{}, map[string]string{}
for _, name := range []string{"quartierowner", "spotowner", "coowner", "outsider"} {
p, e := s.store.CreatePasswordAccount(domain, name, "a long test password", name, "")
if e != nil {
t.Fatal(e)
}
principals[name] = p.UUID
tokens[name], e = s.store.CreateAuthSession(domain, p.UUID)
if e != nil {
t.Fatal(e)
}
var membership string
if e = s.store.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?`, domain, p.UUID).Scan(&membership); e != nil {
t.Fatal(e)
}
members[name] = membership
// Do not let default author grants accidentally admit the owner API.
if _, e = s.store.DB.Exec(`DELETE FROM auth_capability_grants WHERE role_uuid IN (SELECT role_uuid FROM auth_role_bindings WHERE membership_uuid=?)`, members[name]); e != nil {
t.Fatal(e)
}
}
call := func(token, method, url string, body any) *httptest.ResponseRecorder {
b, _ := json.Marshal(body)
r := httptest.NewRequest(method, "http://localhost"+url, strings.NewReader(string(b)))
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
dURL, qURL, sURL := governanceEndpoint("domain", domain), governanceEndpoint("quartier", q), governanceEndpoint("spot", spot)
read := func(token, url string) store.CityGovernance {
t.Helper()
w := call(token, "GET", url, nil)
if w.Code != 200 {
t.Fatalf("GET %s=%d %s", url, w.Code, w.Body.String())
}
var g store.CityGovernance
if e := json.Unmarshal(w.Body.Bytes(), &g); e != nil {
t.Fatal(e)
}
return g
}
change := func(token, url, policy string, owners *[]string, confirm bool, code int) store.CityGovernance {
t.Helper()
g := read(token, url)
c := store.CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Owners: owners, ConfirmRelaxation: confirm}
if policy != "" {
c.Policy = &policy
}
w := call(token, "PATCH", url, c)
if w.Code != code {
t.Fatalf("PATCH %s=%d want %d: %s", url, w.Code, code, w.Body.String())
}
if code == 200 {
_ = json.Unmarshal(w.Body.Bytes(), &g)
}
return g
}
if g := read(admin, dURL); g.Policy != "authenticated_acl" || g.DraftEffectivePublic || g.PublicationEnabled {
t.Fatalf("unsafe default: %+v", g)
}
change(admin, qURL, "public", nil, true, 400)
change(admin, dURL, "public", nil, false, 400)
if g := change(admin, dURL, "public", nil, true, 200); g.DraftEffectivePublic {
t.Fatal("Domain ceiling published root")
}
qs := []string{members["quartierowner"]}
change(admin, qURL, "", &qs, false, 200)
qg := read(tokens["quartierowner"], qURL)
if qg.CanAppoint {
t.Fatal("Quartier owner can appoint peers")
}
w := call(tokens["quartierowner"], "PATCH", qURL, store.CityGovernanceChange{Epoch: qg.Epoch, TopologyVersion: qg.TopologyVersion, Owners: &qs})
if w.Code != 403 {
t.Fatalf("peer appointment=%d", w.Code)
}
if w = call(tokens["quartierowner"], "GET", governanceEndpoint("quartier", q2), nil); w.Code != 403 {
t.Fatal("foreign Quartier accessible")
}
ss := []string{members["spotowner"], members["coowner"]}
change(tokens["quartierowner"], sURL, "", &ss, false, 200)
if g := read(tokens["spotowner"], sURL); len(g.Owners) != 2 || g.CanAppoint {
t.Fatalf("co-owners: %+v", g)
}
if w = call(tokens["spotowner"], "GET", sURL+"/members", nil); w.Code != 403 {
t.Fatal("Spot owner enumerated appointment candidates")
}
if w = call(tokens["outsider"], "GET", sURL, nil); w.Code != 403 {
t.Fatal("outsider governance")
}
if w = call(tokens["spotowner"], "POST", "/_/api/v1/city/spots/"+spot+"/title", map[string]any{"title": "changed"}); w.Code != 403 {
t.Fatal("ownership granted topology write")
}
change(tokens["spotowner"], sURL, "public", nil, true, 200)
change(tokens["quartierowner"], qURL, "authenticated_acl", nil, false, 200)
if g := read(tokens["spotowner"], sURL); g.DraftEffectivePublic || g.SuperiorAllowsPublic || g.Policy != "public" {
t.Fatal("ancestor narrowing did not clamp preserved intent")
}
change(tokens["spotowner"], sURL, "public", nil, true, 400)
change(tokens["quartierowner"], qURL, "inherit", nil, false, 400)
change(tokens["quartierowner"], qURL, "inherit", nil, true, 200)
if !read(tokens["spotowner"], sURL).DraftEffectivePublic {
t.Fatal("intent lost after relaxation")
}
change(tokens["spotowner"], sURL, "authenticated_acl", nil, false, 200)
change(tokens["quartierowner"], qURL, "public", nil, true, 200)
if read(tokens["spotowner"], sURL).DraftEffectivePublic {
t.Fatal("parent bypassed child restriction")
}
// Policy preview changes neither epoch nor persistence, even on relaxation.
g := read(tokens["spotowner"], sURL)
policy := "inherit"
patch := store.CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: &policy}
if w = call(tokens["spotowner"], "POST", sURL+"/preview", patch); w.Code != 200 || !strings.Contains(w.Body.String(), `"draft_effective_public":true`) {
t.Fatalf("preview=%d %s", w.Code, w.Body.String())
}
if after := read(tokens["spotowner"], sURL); after.Epoch != g.Epoch || after.Policy != g.Policy {
t.Fatal("preview persisted")
}
change(tokens["spotowner"], sURL, "inherit", nil, true, 200)
if w = call(tokens["spotowner"], "PATCH", sURL, patch); w.Code != 409 {
t.Fatal("stale epoch accepted")
}
// Same-version writers cannot both commit, even when both are legitimate co-owners.
g = read(tokens["spotowner"], sURL)
policy = "authenticated_acl"
patch = store.CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: &policy}
var wg sync.WaitGroup
codes := make(chan int, 2)
for _, name := range []string{"spotowner", "coowner"} {
wg.Add(1)
go func(token string) { defer wg.Done(); codes <- call(token, "PATCH", sURL, patch).Code }(tokens[name])
}
wg.Wait()
close(codes)
success, conflict := 0, 0
for c := range codes {
if c == 200 {
success++
}
if c == 409 {
conflict++
}
}
if success != 1 || conflict != 1 {
t.Fatalf("concurrent saves: %d success %d conflicts", success, conflict)
}
g = read(tokens["spotowner"], sURL)
patch.Epoch = g.Epoch
patch.TopologyVersion = g.TopologyVersion
if _, err = s.store.DB.Exec(`UPDATE domain_topology_versions SET version=version+1 WHERE domain_uuid=?`, domain); err != nil {
t.Fatal(err)
}
if w = call(tokens["spotowner"], "PATCH", sURL, patch); w.Code != 409 {
t.Fatal("stale topology accepted")
}
// Browser-origin fencing remains ahead of the handler-owned permission path.
r := httptest.NewRequest("PATCH", "http://localhost"+sURL, strings.NewReader(`{}`))
r.Header.Set("Authorization", "Bearer "+admin)
r.Header.Set("Origin", "https://untrusted.invalid")
r.Header.Set("Sec-Fetch-Site", "cross-site")
w = httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != 403 {
t.Fatal("governance bypassed browser-origin fencing")
}
// Revocation is live and does not depend on an in-memory principal cache.
if _, err = s.store.DB.Exec(`UPDATE principals SET state='suspended' WHERE uuid=?`, principals["spotowner"]); err != nil {
t.Fatal(err)
}
if _, err = s.store.CityGovernance(context.Background(), domain, principals["spotowner"], "spot", spot); err != store.ErrAccessDenied {
t.Fatalf("suspended owner=%v", err)
}
if _, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE uuid=?`, members["coowner"]); err != nil {
t.Fatal(err)
}
if _, err = s.store.CityGovernance(context.Background(), domain, principals["coowner"], "spot", spot); err != store.ErrAccessDenied {
t.Fatalf("revoked member=%v", err)
}
bad := []string{members["coowner"]}
change(admin, sURL, "", &bad, false, 400)
bad = []string{"foreign-membership"}
change(admin, sURL, "", &bad, false, 400)
if w = call(admin, "DELETE", sURL, nil); w.Code != 405 {
t.Fatal("unsupported method")
}
if w = call(admin, "GET", governanceEndpoint("domain", "foreign"), nil); w.Code != 403 {
t.Fatal("foreign Domain")
}
var events int
if err = s.store.DB.QueryRow(`SELECT COUNT(*) FROM city_governance_events WHERE domain_uuid=?`, domain).Scan(&events); err != nil || events < 8 {
t.Fatalf("audit events=%d %v", events, err)
}
none := []string{}
change(admin, qURL, "", &none, false, 200)
if w = call(tokens["quartierowner"], "GET", qURL, nil); w.Code != 403 {
t.Fatal("removed ownership remained effective")
}
if _, err = s.store.DB.Exec(`UPDATE groups SET state='suspended' WHERE domain_uuid=? AND builtin_key='domain_admin'`, domain); err != nil {
t.Fatal(err)
}
if w = call(admin, "GET", dURL, nil); w.Code != 403 {
t.Fatal("revoked admin remained authoritative")
}
}