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.
341 lines
13 KiB
Go
341 lines
13 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"pageswiki/internal/store"
|
|
)
|
|
|
|
func periodicalFixture(t *testing.T) (*Server, string, string, string) {
|
|
t.Helper()
|
|
s, token, domain := configFixture(t)
|
|
s.mux.HandleFunc("/v/diary", s.handlePeriodical)
|
|
s.mux.HandleFunc("/v/diary/", s.handlePeriodical)
|
|
s.mux.HandleFunc("/v/blog", s.handlePeriodical)
|
|
s.mux.HandleFunc("/v/blog/", s.handlePeriodical)
|
|
s.mux.HandleFunc("/_/api/v1/extension/", s.handleSystemExtensions)
|
|
p, err := s.store.PrincipalForSession(domain, token)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s, token, domain, p.UUID
|
|
}
|
|
|
|
func periodicalRequest(s *Server, token, method, target, body string) *httptest.ResponseRecorder {
|
|
r := httptest.NewRequest(method, "http://localhost"+target, strings.NewReader(body))
|
|
if token != "" {
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
r.Header.Set("Content-Type", "application/json")
|
|
r.Header.Set("Accept", "application/json")
|
|
w := httptest.NewRecorder()
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
return w
|
|
}
|
|
|
|
func TestPeriodicalPrefixPlannerAndHome(t *testing.T) {
|
|
s, token, domain, actor := periodicalFixture(t)
|
|
ctx := context.Background()
|
|
s.mux.HandleFunc("/", s.handleHome)
|
|
base := "/_/api/v1/extension/content.diary/"
|
|
for _, test := range []struct {
|
|
method, target, body string
|
|
status int
|
|
}{
|
|
{"GET", base + "settings", "", 200},
|
|
{"GET", base + "plan?date=2026-09-17", "", 409},
|
|
{"POST", base + "settings", `{"enabled":true,"prefix":"/journal"}`, 200},
|
|
{"POST", base + "settings", `{"enabled":false,"prefix":"/../invalid"}`, 400},
|
|
{"GET", base + "plan?date=2026-09-17&keyword=walk", "", 200},
|
|
{"GET", base + "plan?date=2026-09-17&keyword=..", "", 400},
|
|
{"POST", base + "plan", `{}`, 403},
|
|
} {
|
|
w := periodicalRequest(s, token, test.method, test.target, test.body)
|
|
if w.Code != test.status {
|
|
t.Fatalf("%s %s: %d %s", test.method, test.target, w.Code, w.Body.String())
|
|
}
|
|
}
|
|
prefix, err := s.store.PeriodicalPrefix(ctx, domain, "diary")
|
|
if err != nil || prefix != "/journal" {
|
|
t.Fatal(prefix, err)
|
|
}
|
|
w := periodicalRequest(s, token, "GET", base+"plan?date=2026-09-17&keyword=walk", "")
|
|
if !strings.Contains(w.Body.String(), `"path":"/journal/2026/09/17/walk"`) {
|
|
t.Fatal(w.Body.String())
|
|
}
|
|
if _, err = s.store.ResolvePathInDomain(domain, "/journal/2026/09/17/walk"); !errors.Is(err, sql.ErrNoRows) {
|
|
t.Fatal("planning created a Page")
|
|
}
|
|
for _, p := range []string{"/journal/2026/09/17", "/journal/2026/09/17/walk"} {
|
|
u, err := s.store.CreatePageAtPathInDomain(domain, p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.store.SaveRevision(u, "<p>Body</p>", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entry := store.PeriodicalEntry{Path: p, Title: p, Date: "2026-09-17", Timezone: "UTC"}
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if w = periodicalRequest(s, token, "GET", base+"plan?date=2026-09-17", ""); w.Code != 409 {
|
|
t.Fatal(w.Code)
|
|
}
|
|
if err = s.store.SetConfigInDomain(domain, "home_layout", "diary"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = periodicalRequest(s, token, "GET", "/", "")
|
|
if w.Code != 200 || !strings.Contains(w.Body.String(), `href="/v/diary/`) {
|
|
t.Fatal(w.Code, w.Body.String())
|
|
}
|
|
if w = periodicalRequest(s, "", "GET", base+"plan?date=2026-09-17", ""); w.Code != 401 {
|
|
t.Fatal(w.Code)
|
|
}
|
|
if w = periodicalRequest(s, "", "GET", "/", ""); w.Code == 200 {
|
|
t.Fatal("private root leaked")
|
|
}
|
|
if w = periodicalRequest(s, token, "POST", base+"settings", `{"enabled":true,"prefix":"/"}`); w.Code != 200 {
|
|
t.Fatal(w.Code)
|
|
}
|
|
if _, err = s.store.ResolvePathInDomain(domain, "/journal/2026/09/17/walk"); err != nil {
|
|
t.Fatal("prefix changed old Path", err)
|
|
}
|
|
if w = periodicalRequest(s, token, "GET", base+"plan?date=2026-09-17&keyword=new", ""); w.Code != 200 || !strings.Contains(w.Body.String(), `"path":"/2026/09/17/new"`) {
|
|
t.Fatal(w.Code, w.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestPeriodicalLifecycleAndRename(t *testing.T) {
|
|
s, token, domain, actor := periodicalFixture(t)
|
|
ctx := context.Background()
|
|
for _, kind := range []string{"diary", "blog"} {
|
|
if enabled, err := s.store.PeriodicalEnabled(ctx, domain, kind); err != nil || enabled {
|
|
t.Fatal("new plugin must be disabled", err)
|
|
}
|
|
w := periodicalRequest(s, token, "POST", "/_/api/v1/extension/content."+kind+"/settings", `{"enabled":true}`)
|
|
if w.Code != 200 {
|
|
t.Fatal(w.Code, w.Body.String())
|
|
}
|
|
}
|
|
page, err := s.store.CreatePageAtPathInDomain(domain, "/notes/first")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.store.SaveRevision(page, "<h1>Canonical unchanged</h1>", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entry := store.PeriodicalEntry{Path: "/notes/first", Title: "<b>Diary title</b>", Date: "2026-09-16", Category: "Test", Timezone: "Asia/Tokyo", Owner: "forged"}
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
list, err := s.store.ListPeriodicalEntries(ctx, domain, "diary")
|
|
if err != nil || len(list) != 1 || list[0].Owner != actor {
|
|
t.Fatal("server owner", list, err)
|
|
}
|
|
entry = list[0]
|
|
if err = s.store.RenamePathInDomain(domain, "/notes/first", "/notes/renamed"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w := periodicalRequest(s, token, "GET", "/v/diary/2026/09", "")
|
|
if w.Code != 200 || !strings.Contains(w.Body.String(), `href="/notes/renamed"`) || strings.Contains(w.Body.String(), "<b>Diary title</b>") || !strings.Contains(w.Body.String(), "has-entries") || !strings.Contains(w.Header().Get("Content-Security-Policy"), "nonce-") {
|
|
t.Fatalf("calendar %d %s", w.Code, w.Body.String())
|
|
}
|
|
entry.Path = "/notes/renamed"
|
|
entry.Title = "Updated"
|
|
entry.Timezone = "UTC"
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rows, err := s.store.ListPeriodicalEntries(ctx, domain, "diary"); err != nil || rows[0].Timezone != "Asia/Tokyo" {
|
|
t.Fatal("editing changed original timezone", err)
|
|
}
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); !errors.Is(err, store.ErrPeriodicalConflict) {
|
|
t.Fatal("stale update", err)
|
|
}
|
|
entry.Version = 2
|
|
entry.Remove = true
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if object, err := s.store.ResolvePathInDomain(domain, entry.Path); err != nil || object != page {
|
|
t.Fatal("unregister deleted Page", err)
|
|
}
|
|
entry.Remove = false
|
|
entry.Version = 0
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
list, _ = s.store.ListPeriodicalEntries(ctx, domain, "diary")
|
|
if list[0].Version != 4 {
|
|
t.Fatal("ABA generation reset", list)
|
|
}
|
|
entry.Version = 1
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", nil, &entry); !errors.Is(err, store.ErrPeriodicalConflict) {
|
|
t.Fatal("pre-delete request replay", err)
|
|
}
|
|
off := false
|
|
if err = s.store.ChangePeriodical(ctx, domain, actor, "diary", &off, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = periodicalRequest(s, token, "GET", "/_/api/v1/extension/content.diary/entries", "")
|
|
if w.Code != 200 || strings.Contains(w.Body.String(), "Updated") {
|
|
t.Fatal("disabled index exposed", w.Body.String())
|
|
}
|
|
if list, _ = s.store.ListPeriodicalEntries(ctx, domain, "diary"); len(list) != 1 {
|
|
t.Fatal("disable deleted metadata")
|
|
}
|
|
}
|
|
|
|
func TestPeriodicalPermissionsAndConstraints(t *testing.T) {
|
|
s, token, domain, admin := periodicalFixture(t)
|
|
ctx := context.Background()
|
|
on := true
|
|
if err := s.store.ChangePeriodical(ctx, domain, admin, "diary", &on, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
user, err := s.store.CreatePasswordAccount(domain, "writer", "a very long password", "Writer", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
userToken, err := s.store.CreateAuthSession(domain, user.UUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.store.DB.Exec(`DELETE FROM auth_role_bindings WHERE membership_uuid IN (SELECT uuid FROM domain_memberships WHERE principal_uuid=?)`, user.UUID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
group, err := s.store.CreateGroup(domain, admin, "journalers", "Journalers", "", "members")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = s.store.AddGroupMemberByUsername(domain, group.UUID, "writer", "member"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = s.store.SetGroupPermission(group.UUID, "/journal", "read_write"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, p := range []string{"/journal/one", "/journal/two", "/private/three"} {
|
|
o, e := s.store.CreatePageAtPathInDomain(domain, p)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, e = s.store.SaveRevision(o, "Body", ""); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
}
|
|
entry := store.PeriodicalEntry{Path: "/journal/one", Title: "VISIBLE-ENTRY", Date: "2024-02-29", Timezone: "UTC", Category: "VISIBLE-CATEGORY"}
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entry.Path = "/journal/two"
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", nil, &entry); err != nil {
|
|
t.Fatal("multiple diary articles per day", err)
|
|
}
|
|
entry.Path = "/journal/one"
|
|
entry.PageUUID, _ = s.store.ResolvePathInDomain(domain, entry.Path)
|
|
entry.Version = 1
|
|
entry.Date = "2023-02-29"
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", nil, &entry); !errors.Is(err, store.ErrPeriodicalInvalid) {
|
|
t.Fatal("invalid date", err)
|
|
}
|
|
entry.Date = "2024-03-01"
|
|
entry.PageUUID = ""
|
|
entry.Version = 0
|
|
entry.Path = "/private/three"
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", nil, &entry); !errors.Is(err, store.ErrAccessDenied) {
|
|
t.Fatal("write boundary", err)
|
|
}
|
|
entry.Title = "PRIVATE-ENTRY"
|
|
entry.Category = "PRIVATE-CATEGORY"
|
|
if err = s.store.ChangePeriodical(ctx, domain, admin, "diary", nil, &entry); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w := periodicalRequest(s, userToken, "GET", "/v/diary/2024/02", "")
|
|
if w.Code != 200 || !strings.Contains(w.Body.String(), "VISIBLE-ENTRY") || strings.Contains(w.Body.String(), "PRIVATE-") {
|
|
t.Fatal("permission-filtered widgets", w.Code, w.Body.String())
|
|
}
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", &on, nil); !errors.Is(err, store.ErrAccessDenied) {
|
|
t.Fatal("nonadmin enabled", err)
|
|
}
|
|
if err = s.store.ChangePeriodical(ctx, "other-domain", user.UUID, "diary", &on, nil); !errors.Is(err, store.ErrAccessDenied) {
|
|
t.Fatal("domain crossing", err)
|
|
}
|
|
if _, err = s.store.CreatePageAtPathInDomain(domain, "/u/writer/diary/day"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
own := store.PeriodicalEntry{Path: "/u/writer/diary/day", Title: "Personal diary", Date: "2024-03-02", Timezone: "UTC"}
|
|
if err = s.store.ChangePeriodical(ctx, domain, user.UUID, "diary", nil, &own); err != nil {
|
|
t.Fatal("own Wiki authority", err)
|
|
}
|
|
if _, err = s.store.DB.Exec(`DELETE FROM group_members WHERE group_uuid=?`, group.UUID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = periodicalRequest(s, userToken, "GET", "/v/diary/2024/02", "")
|
|
if w.Code != 200 || strings.Contains(w.Body.String(), "VISIBLE-") || strings.Contains(w.Body.String(), "PRIVATE-") {
|
|
t.Fatal("membership revocation", w.Code, w.Body.String())
|
|
}
|
|
for _, target := range []string{"/v/diary", "/v/blog", "/_/api/v1/extension/content.diary/entries"} {
|
|
w = periodicalRequest(s, "", "GET", target, "")
|
|
if w.Code == 200 {
|
|
t.Fatal("anonymous metadata exposed", target)
|
|
}
|
|
}
|
|
for _, body := range []string{`{"enabled":true,"extra":1}`, `{"enabled":true} {}`, `{}`} {
|
|
w = periodicalRequest(s, token, "POST", "/_/api/v1/extension/content.diary/settings", body)
|
|
if w.Code != 400 {
|
|
t.Fatal("strict JSON", w.Code)
|
|
}
|
|
}
|
|
w = periodicalRequest(s, token, "DELETE", "/_/api/v1/extension/content.diary/entries", "")
|
|
if w.Code < 400 {
|
|
t.Fatal("undefined method")
|
|
}
|
|
}
|
|
|
|
func TestPeriodicalAuditRollbackAndAPI(t *testing.T) {
|
|
s, token, domain, actor := periodicalFixture(t)
|
|
ctx := context.Background()
|
|
on := true
|
|
if err := s.store.ChangePeriodical(ctx, domain, actor, "blog", &on, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
page, err := s.store.CreatePageAtPathInDomain(domain, "/post")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.store.DB.Exec(`CREATE TRIGGER fail_periodical_event BEFORE INSERT ON periodical_events BEGIN SELECT RAISE(ABORT,'fixture'); END`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
body := `{"path":"/post","title":"Blog article","date":"2026-09-16","category":"News","version":0}`
|
|
w := periodicalRequest(s, token, "POST", "/_/api/v1/extension/content.blog/entries", body)
|
|
if w.Code != 500 {
|
|
t.Fatal(w.Code)
|
|
}
|
|
list, err := s.store.ListPeriodicalEntries(ctx, domain, "blog")
|
|
if err != nil || len(list) != 0 {
|
|
t.Fatal("journal failure did not roll back", list, err)
|
|
}
|
|
if _, err = s.store.DB.Exec(`DROP TRIGGER fail_periodical_event`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w = periodicalRequest(s, token, "POST", "/_/api/v1/extension/content.blog/entries", body)
|
|
if w.Code != 200 {
|
|
t.Fatal(w.Code, w.Body.String())
|
|
}
|
|
w = periodicalRequest(s, token, "GET", "/_/api/v1/extension/content.blog/entries", "")
|
|
var result struct{ Entries []store.PeriodicalEntry }
|
|
if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil || len(result.Entries) != 1 || result.Entries[0].PageUUID != page {
|
|
t.Fatal("API entry", w.Body.String(), err)
|
|
}
|
|
if w = periodicalRequest(s, token, "GET", "/v/blog?category=News", ""); w.Code != 200 || !strings.Contains(w.Body.String(), "Blog article") {
|
|
t.Fatal("blog view", w.Code, w.Body.String())
|
|
}
|
|
}
|