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", "
Public profile Wiki
")
createUserSpacePage(t, s, domain, "/u/admin/public", "public child
")
createUserSpacePage(t, s, domain, "/u/admin/private", "private child
")
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", `Public profile Wiki
{{children}}
`)
createUserSpacePage(t, s, domain, "/u/admin/public", "Public child
")
createUserSpacePage(t, s, domain, "/u/admin/private", "Private child
")
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())
}
}