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

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