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