package server import ( "context" "encoding/json" "net/http/httptest" "strings" "testing" "pageswiki/internal/store" ) func TestLocalityUserGroupAccess(t *testing.T) { s, adminToken, domain := configFixture(t) ctx := context.Background() s.mux.HandleFunc("/_/api/v1/city/", s.handleCityAPI) s.mux.HandleFunc("/_/api/v1/revisions/save", s.handleSaveRevisionAPI) s.mux.HandleFunc("/_/api/v1/render/markdown", s.handleMarkdownRenderAPI) s.mux.HandleFunc("/o/", s.handleObjectView) s.mux.HandleFunc("/v/raw/", s.handleRawView) s.mux.HandleFunc("/", s.handleHome) admin, err := s.store.PrincipalForSession(domain, adminToken) if err != nil { t.Fatal(err) } q, err := s.store.CreateZoneAtPath(domain, admin.UUID, "quartier", "", "life", "Life", "", "/life") if err != nil { t.Fatal(err) } st, err := s.store.CreateZoneAtPath(domain, admin.UUID, "street", q, "work", "Work", "", "/life/work") if err != nil { t.Fatal(err) } spot, err := s.store.CreateSpotAtPath(domain, admin.UUID, st, "desk", "Desk", "", "/life/work/desk") if err != nil { t.Fatal(err) } object, err := s.store.CreatePageAtPathInDomain(domain, "/life/work/desk/page") if err != nil { t.Fatal(err) } rev, err := s.store.SaveRevisionContent(object, []byte("

Protected content

"), "", "und", "text/html", "") if err != nil { t.Fatal(err) } users := map[string]*store.Principal{} tokens := map[string]string{} for _, name := range []string{"alice", "bob", "charlie", "delegate"} { users[name], err = s.store.CreatePasswordAccount(domain, name, "a long test password", name, "") if err != nil { t.Fatal(err) } tokens[name], err = s.store.CreateAuthSession(domain, users[name].UUID) if err != nil { t.Fatal(err) } } group, err := s.store.CreateGroup(domain, admin.UUID, "editors", "Editors", "", "members") if err != nil { t.Fatal(err) } if err = s.store.AddGroupMemberByUsername(domain, group.UUID, "bob", "member"); err != nil { t.Fatal(err) } set := func(actor, kind, id, mode string, entries []store.LocalityAccessEntry) store.LocalityAccess { t.Helper() a, e := s.store.LocalityAccess(ctx, domain, actor, kind, id, nil) if e != nil { t.Fatal(e) } a.Mode = mode a.Entries = entries a, e = s.store.LocalityAccess(ctx, domain, actor, kind, id, &a) if e != nil { t.Fatal(e) } return a } entry := func(kind, name, perm string) store.LocalityAccessEntry { return store.LocalityAccessEntry{Kind: kind, Name: name, Permission: perm} } set(admin.UUID, "quartier", q, "restricted", []store.LocalityAccessEntry{entry("user", "alice", "read"), entry("group", "editors", "read_write")}) check := func(name, cap string, want bool) { t.Helper() err := s.store.Authorize(store.AuthorizationRequest{DomainUUID: domain, PrincipalUUID: users[name].UUID, Capability: cap, TargetType: "path", TargetID: "/life/work/desk/page"}) if (err == nil) != want { t.Fatalf("%s %s=%v want %v", name, cap, err, want) } if cap == "read" { p, e := s.store.LoadReadPathPolicy(domain, users[name].UUID) if e != nil || p.Allows("/life/work/desk/page") != want { t.Fatalf("list policy %s=%v", name, e) } } } check("alice", "read", true) check("alice", "write", false) check("bob", "read", true) check("bob", "write", true) check("bob", "delete", false) check("charlie", "read", false) if err = s.store.SetConfigInDomain(domain, "authorization_mode", "legacy"); err == nil { t.Fatal("ACL could be bypassed by legacy mode") } call := func(token, method, path string, body any) *httptest.ResponseRecorder { b, _ := json.Marshal(body) r := httptest.NewRequest(method, "http://localhost"+path, 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 } for _, path := range []string{"/life/work/desk/page", "/o/uuid:" + object, "/v/raw/uuid:" + object, "/v/raw/rev:" + rev.UUID} { w := call(tokens["charlie"], "GET", path, nil) if w.Code == 200 { t.Fatalf("denied alias leaked: %s", path) } } if w := call(tokens["alice"], "POST", "/_/api/v1/revisions/save", map[string]string{"object_uuid": object, "body": "bad", "lang": "und"}); w.Code != 403 { t.Fatalf("read-only save=%d", w.Code) } if w := call(tokens["bob"], "POST", "/_/api/v1/revisions/save", map[string]string{"object_uuid": object, "body": "

edited

", "lang": "und"}); w.Code != 200 { t.Fatalf("write save=%d %s", w.Code, w.Body.String()) } if w := call(tokens["bob"], "POST", "/_/api/v1/render/markdown", map[string]any{"html": "

Preview

", "path": "/life/work/desk/page", "projection": true}); w.Code != 200 { t.Fatalf("scoped editor preview=%d %s", w.Code, w.Body.String()) } if _, err = s.store.DB.Exec(`UPDATE principals SET state='readonly' WHERE uuid=?`, users["bob"].UUID); err != nil { t.Fatal(err) } check("bob", "read", true) check("bob", "write", false) if _, err = s.store.DB.Exec(`UPDATE principals SET state='active' WHERE uuid=?`, users["bob"].UUID); err != nil { t.Fatal(err) } set(admin.UUID, "spot", spot, "restricted", []store.LocalityAccessEntry{entry("user", "alice", "read_write"), entry("group", "editors", "read")}) check("alice", "write", false) check("bob", "write", false) check("bob", "read", true) // Namespace guards apply even to direct SQL/CLI callers and prevent a private // binding from being moved or aliased out of its restrictive scope. for _, query := range []string{`UPDATE paths SET path='/escaped' WHERE object_uuid=?`, `DELETE FROM paths WHERE object_uuid=?`, `INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) SELECT domain_uuid,'/escape',object_uuid,0,0 FROM paths WHERE object_uuid=?`} { if _, err = s.store.DB.Exec(query, object); err == nil { t.Fatalf("namespace escaped: %s", query) } } if _, err = s.store.CreatePageAtPathInDomain(domain, "/life/work/desk/new"); err != nil { t.Fatalf("new documents blocked: %v", err) } if _, err = s.store.DB.Exec(`UPDATE spots SET path_prefix='/escape' WHERE uuid=?`, spot); err == nil { t.Fatal("City boundary escaped") } // Membership removal is observed on the very next request. if _, err = s.store.DB.Exec(`DELETE FROM group_members WHERE group_uuid=? AND membership_uuid IN (SELECT uuid FROM domain_memberships WHERE principal_uuid=?)`, group.UUID, users["bob"].UUID); err != nil { t.Fatal(err) } check("bob", "read", false) // Delegates may narrow but cannot invent a new positive grant. var member string if err = s.store.DB.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?`, domain, users["delegate"].UUID).Scan(&member); err != nil { t.Fatal(err) } g, err := s.store.CityGovernance(ctx, domain, admin.UUID, "quartier", q) if err != nil { t.Fatal(err) } owners := []string{member} if _, err = s.store.ChangeCityGovernance(ctx, domain, admin.UUID, "quartier", q, store.CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Owners: &owners}, false); err != nil { t.Fatal(err) } delegated, err := s.store.LocalityAccess(ctx, domain, users["delegate"].UUID, "spot", spot, nil) if err != nil { t.Fatal(err) } delegated.Entries = []store.LocalityAccessEntry{entry("user", "charlie", "read_write")} if _, err = s.store.LocalityAccess(ctx, domain, users["delegate"].UUID, "spot", spot, &delegated); err != store.ErrGovernanceCeiling { t.Fatalf("delegate widened superior ACL: %v", err) } set(admin.UUID, "spot", spot, "inherit", nil) set(users["delegate"].UUID, "spot", spot, "restricted", []store.LocalityAccessEntry{entry("user", "charlie", "read_write")}) check("charlie", "read", false) if _, err = s.store.LocalityAccess(ctx, domain, users["charlie"].UUID, "spot", spot, nil); err != store.ErrAccessDenied { t.Fatal("ordinary user altered ACL") } set(admin.UUID, "spot", spot, "inherit", nil) set(admin.UUID, "quartier", q, "inherit", nil) if _, err = s.store.DB.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES(?,'/other-alias',?,0,0)`, domain, object); err != nil { t.Fatal(err) } a, err := s.store.LocalityAccess(ctx, domain, admin.UUID, "quartier", q, nil) if err != nil { t.Fatal(err) } a.Mode = "restricted" a.Entries = []store.LocalityAccessEntry{entry("user", "alice", "read")} if _, err = s.store.LocalityAccess(ctx, domain, admin.UUID, "quartier", q, &a); err != store.ErrLocalityAccessAlias { t.Fatalf("cross-scope alias accepted: %v", err) } }