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

212 lines
9.8 KiB
Go

package server
import (
"context"
"database/sql"
"errors"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"pageswiki/internal/store"
)
func enableDomainPublicCeiling(t *testing.T, s *Server, domain, actor string) {
t.Helper()
g, err := s.store.CityGovernance(context.Background(), domain, actor, "domain", domain)
if err != nil {
t.Fatal(err)
}
policy := "public"
_, err = s.store.ChangeCityGovernance(context.Background(), domain, actor, "domain", domain, store.CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: &policy, ConfirmRelaxation: true}, false)
if err != nil {
t.Fatal(err)
}
}
func createUserSpacePage(t *testing.T, s *Server, domain, target, body string) {
t.Helper()
object, err := s.store.CreatePageAtPathInDomain(domain, target)
if err != nil {
t.Fatal(err)
}
if _, err = s.store.SaveRevisionContent(object, []byte(body), "", "en", "text/html; charset=utf-8", target+".html"); err != nil {
t.Fatal(err)
}
}
func TestUserSpacePolicyAndPublicRevision(t *testing.T) {
s, token, domain := configFixture(t)
owner, err := s.store.PrincipalForSession(domain, token)
if err != nil {
t.Fatal(err)
}
createUserSpacePage(t, s, domain, "/u/admin", "<h1>Public profile Wiki</h1>")
createUserSpacePage(t, s, domain, "/u/admin/public", "<p>public child</p>")
createUserSpacePage(t, s, domain, "/u/admin/private", "<p>private child</p>")
proposal := store.UserSpacePolicy{PrincipalUUID: owner.UUID, Username: owner.Username, ProfileVisibility: "public", AvatarVisibility: "public", RootVisibility: "public", DescendantVisibility: "public"}
if _, err = s.store.SaveUserSpacePolicy(context.Background(), domain, owner.UUID, proposal); !errors.Is(err, store.ErrGovernanceCeiling) {
t.Fatalf("public without ceiling: %v", err)
}
enableDomainPublicCeiling(t, s, domain, owner.UUID)
proposal.Overrides = []store.UserSpacePathPolicy{{Path: "/u/admin/private", Visibility: "private"}}
saved, err := s.store.SaveUserSpacePolicy(context.Background(), domain, owner.UUID, proposal)
if err != nil || saved.Version != 1 {
t.Fatalf("save=%+v err=%v", saved, err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin", []string{"en"}); err != nil {
t.Fatal(err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin/public", []string{"en"}); err != nil {
t.Fatal(err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin/private", []string{"en"}); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("private child published: %v", err)
}
if _, err = s.store.RenamePathsInDomain(domain, "/u/admin/private", "/u/admin/renamed-private", false); err != nil {
t.Fatal(err)
}
reloaded, err := s.store.UserSpacePolicy(context.Background(), domain, owner.UUID)
if err != nil || len(reloaded.Overrides) != 1 || reloaded.Overrides[0].Path != "/u/admin/renamed-private" {
t.Fatalf("override did not follow rename: %+v err=%v", reloaded.Overrides, err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin/renamed-private", []string{"en"}); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("renamed private child published: %v", err)
}
if _, err = s.store.RenamePathsInDomain(domain, "/u/admin/renamed-private", "/outside", false); err == nil {
t.Fatal("protected override moved outside its owner namespace")
}
if _, err = s.store.SaveUserSpacePolicy(context.Background(), domain, owner.UUID, proposal); !errors.Is(err, store.ErrGovernanceConflict) {
t.Fatalf("stale save: %v", err)
}
publicObject, err := s.store.ResolvePathInDomain(domain, "/u/admin/public")
if err != nil {
t.Fatal(err)
}
if err = s.store.BindPathInDomain(domain, "/alias", publicObject); err != nil {
t.Fatal(err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin/public", []string{"en"}); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("aliased object published: %v", err)
}
governance, err := s.store.CityGovernance(context.Background(), domain, owner.UUID, "domain", domain)
if err != nil {
t.Fatal(err)
}
closed := "authenticated_acl"
if _, err = s.store.ChangeCityGovernance(context.Background(), domain, owner.UUID, "domain", domain, store.CityGovernanceChange{Epoch: governance.Epoch, TopologyVersion: governance.TopologyVersion, Policy: &closed}, false); err != nil {
t.Fatal(err)
}
if _, err = s.store.PublicUserSpaceRevision(context.Background(), domain, "admin", "/u/admin", []string{"en"}); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("domain ceiling revocation did not close user space: %v", err)
}
}
func TestPublicUserSpaceHTTP(t *testing.T) {
s, token, domain := configFixture(t)
owner, err := s.store.PrincipalForSession(domain, token)
if err != nil {
t.Fatal(err)
}
enableDomainPublicCeiling(t, s, domain, owner.UUID)
createUserSpacePage(t, s, domain, "/u/admin", `<h1>Public profile Wiki</h1><p>{{children}}</p>`)
createUserSpacePage(t, s, domain, "/u/admin/public", "<h1>Public child</h1>")
createUserSpacePage(t, s, domain, "/u/admin/private", "<h1>Private child</h1>")
if err = s.store.SetPrincipalAvatar(owner.UUID, "image/png", []byte("not-a-real-image")); err != nil {
t.Fatal(err)
}
_, err = s.store.SaveUserSpacePolicy(context.Background(), domain, owner.UUID, store.UserSpacePolicy{
PrincipalUUID: owner.UUID, Username: owner.Username, ProfileVisibility: "public", AvatarVisibility: "public", RootVisibility: "public", DescendantVisibility: "public",
Overrides: []store.UserSpacePathPolicy{{Path: "/u/admin/private", Visibility: "private"}},
})
if err != nil {
t.Fatal(err)
}
s.mux.HandleFunc("/u/", s.handleUserProfile)
s.mux.HandleFunc("/v/children", s.handleChildrenProjection)
call := func(target string, authenticated bool) *httptest.ResponseRecorder {
r := httptest.NewRequest(http.MethodGet, "http://localhost"+target, nil)
if authenticated {
r.Header.Set("Authorization", "Bearer "+token)
}
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
if w := call("/u/admin", false); w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "Public profile Wiki") || !strings.Contains(w.Body.String(), "Test Admin") {
t.Fatalf("public profile status=%d body=%s", w.Code, w.Body.String())
} else if !strings.Contains(w.Body.String(), `data-children-src="/v/children?path=%2Fu%2Fadmin"`) {
t.Fatalf("profile children projection missing: %s", w.Body.String())
}
if w := call("/u/admin/public", false); w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "Public child") {
t.Fatalf("public child status=%d body=%s", w.Code, w.Body.String())
}
if w := call("/u/admin/private", false); w.Code != http.StatusSeeOther {
t.Fatalf("private child status=%d body=%s", w.Code, w.Body.String())
}
if w := call("/v/raw/path:/u/admin/public", false); w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "Public child") {
t.Fatalf("public raw status=%d body=%s", w.Code, w.Body.String())
}
if w := call("/v/raw/path:/u/admin/private", false); w.Code != http.StatusSeeOther {
t.Fatalf("private raw status=%d body=%s", w.Code, w.Body.String())
}
if w := call("/v/children?path=/u/admin", false); w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "/u/admin/public") || strings.Contains(w.Body.String(), "/u/admin/private") {
t.Fatalf("children status=%d body=%s", w.Code, w.Body.String())
}
if w := call("/u/admin/_/avatar", false); w.Code != http.StatusOK || w.Header().Get("Content-Type") != "image/png" {
t.Fatalf("avatar status=%d", w.Code)
}
if w := call("/u/admin/_/edit", true); w.Code != http.StatusOK || !strings.Contains(w.Body.String(), `name="profile_visibility"`) {
t.Fatalf("settings status=%d body=%s", w.Code, w.Body.String())
}
reader, err := s.store.CreatePasswordAccount(domain, "reader", "long enough test password", "Reader", "")
if err != nil {
t.Fatal(err)
}
readerToken, err := s.store.CreateAuthSession(domain, reader.UUID)
if err != nil {
t.Fatal(err)
}
r := httptest.NewRequest(http.MethodGet, "http://localhost/v/children?path=/u/admin", nil)
r.Header.Set("Authorization", "Bearer "+readerToken)
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != http.StatusOK || !strings.Contains(w.Body.String(), "/u/admin/public") || strings.Contains(w.Body.String(), "/u/admin/private") {
t.Fatalf("authenticated children audience status=%d body=%s", w.Code, w.Body.String())
}
privateObject, err := s.store.ResolvePathInDomain(domain, "/u/admin/private")
if err != nil {
t.Fatal(err)
}
privateRevision, err := s.store.GetLatestRevision(privateObject)
if err != nil {
t.Fatal(err)
}
if err = s.authorizePrincipalObject(domain, reader.UUID, "read", privateObject); !errors.Is(err, store.ErrAccessDenied) {
t.Fatalf("private user object authorization=%v", err)
}
if err = s.authorizePrincipalRevision(domain, reader.UUID, "read", privateRevision.UUID); !errors.Is(err, store.ErrAccessDenied) {
t.Fatalf("private user revision authorization=%v", err)
}
form := url.Values{
"action": {"visibility"},
"visibility_version": {"1"},
"profile_visibility": {"public"},
"avatar_visibility": {"public"},
"root_visibility": {"public"},
"descendant_visibility": {"public"},
"visibility_path": {"/u/admin/private"},
"visibility_value": {"private"},
}
r = httptest.NewRequest(http.MethodPost, "http://localhost/u/admin/_/edit", strings.NewReader(form.Encode()))
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
w = httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != http.StatusSeeOther || w.Header().Get("Location") != "/u/admin/_/edit?visibility=saved" {
t.Fatalf("urlencoded visibility save status=%d location=%q body=%s", w.Code, w.Header().Get("Location"), w.Body.String())
}
}