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.
This commit is contained in:
Anya Tokugawa committed 2026-09-27 14:44:43 +09:00
1 parent 288e6e94ac
commit c1175d389f
699 files changed
+110197 -4117

No files matched your search

+329
View File
@@ -0,0 +1,329 @@
package server
import (
"context"
"database/sql"
"encoding/json"
"errors"
"net/http/httptest"
"strings"
"sync"
"testing"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func taskFixture(t *testing.T) (*Server, string, string, string) {
t.Helper()
s, token, domain := configFixture(t)
s.registerCalendarRoutes()
s.registerTaskRoutes()
p, err := s.store.PrincipalForSession(domain, token)
if err != nil {
t.Fatal(err)
}
return s, token, domain, p.UUID
}
func taskRequest(s *Server, token, method, suffix string, body any, version string) *httptest.ResponseRecorder {
b, _ := json.Marshal(body)
r := httptest.NewRequest(method, "http://localhost"+tasksAPI+suffix, strings.NewReader(string(b)))
if token != "" {
r.Header.Set("Authorization", "Bearer "+token)
}
r.Header.Set("Content-Type", "application/json")
if version != "" {
r.Header.Set("If-Match", version)
}
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
func newTaskRecord(kind, title string) store.TaskRecord {
return store.TaskRecord{UUID: uuid.NewString(), Kind: kind, Title: title, Notes: "private notes", Status: "todo", Bucket: "inbox", Priority: 1}
}
func TestTasksConditionalWritesPrivacyAndHistory(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
task := newTaskRecord("task", "Private task")
w := taskRequest(s, token, "POST", "items", task, "")
if w.Code != 201 {
t.Fatalf("create: %d %s", w.Code, w.Body)
}
if w.Header().Get("ETag") != `"1"` || !strings.Contains(w.Header().Get("Cache-Control"), "no-store") {
t.Fatal(w.Header())
}
if retry := taskRequest(s, token, "POST", "items", task, ""); retry.Code != 201 {
t.Fatalf("retry: %d %s", retry.Code, retry.Body)
}
var count int
s.store.DB.QueryRow(`SELECT count(*) FROM organizer_revisions`).Scan(&count)
if count != 1 {
t.Fatal("retry created revision", count)
}
if w = taskRequest(s, token, "PUT", "items/"+task.UUID, task, ""); w.Code != 428 {
t.Fatal("missing precondition", w.Code)
}
task.Status = "done"
if w = taskRequest(s, token, "PUT", "items/"+task.UUID, task, `"1"`); w.Code != 200 {
t.Fatalf("complete: %d %s", w.Code, w.Body)
}
if w = taskRequest(s, token, "PUT", "items/"+task.UUID, task, `"1"`); w.Code != 412 {
t.Fatal("stale update", w.Code)
}
loaded, err := s.store.GetTask(ctx, domain, actor, task.UUID)
if err != nil || loaded.CompletedMS == 0 || loaded.Version != 2 {
t.Fatalf("loaded %#v %v", loaded, err)
}
loaded.Status = "todo"
loaded, err = s.store.SaveTask(ctx, domain, actor, loaded, 2)
if err != nil || loaded.CompletedMS != 0 {
t.Fatal(loaded, err)
}
h, err := s.store.TaskHistory(ctx, domain, actor, task.UUID)
if err != nil || len(h) != 3 || h[0].Version != 3 {
t.Fatal(h, err)
}
other, err := s.store.CreatePasswordAccount(domain, "taskother", "other long password", "Other", "")
if err != nil {
t.Fatal(err)
}
otherToken, err := s.store.CreateAuthSession(domain, other.UUID)
if err != nil {
t.Fatal(err)
}
for _, suffix := range []string{"items/" + task.UUID, "items/" + task.UUID + "/history"} {
if w = taskRequest(s, otherToken, "GET", suffix, nil, ""); w.Code != 404 {
t.Fatalf("private %s %d %s", suffix, w.Code, w.Body)
}
}
if w = taskRequest(s, otherToken, "POST", "items", task, ""); w.Code != 404 {
t.Fatal("identity collision leaked", w.Code)
}
if w = taskRequest(s, otherToken, "GET", "items?view=all", nil, ""); w.Code != 200 || strings.Contains(w.Body.String(), task.Title) {
t.Fatal("private list leaked", w.Body)
}
if w = taskRequest(s, "", "GET", "items", nil, ""); w.Code == 200 {
t.Fatal("anonymous access")
}
if _, err = s.store.GetTask(ctx, "other-domain", actor, task.UUID); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("domain boundary", err)
}
if err = s.store.SetPrincipalState(domain, actor, "readonly"); err != nil {
t.Fatal(err)
}
if _, err = s.store.GetTask(ctx, domain, actor, task.UUID); err != nil {
t.Fatal("readonly read", err)
}
if _, err = s.store.SaveTask(ctx, domain, actor, loaded, 3); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("readonly write", err)
}
if _, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
t.Fatal(err)
}
if _, err = s.store.GetTask(ctx, domain, actor, task.UUID); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("revoked membership", err)
}
}
func TestTasksViewsPaginationProjectsAndKillSwitch(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
project, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("project", "Project"), 0)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 7; i++ {
item := newTaskRecord("task", "Task")
item.ProjectUUID = project.UUID
item.DueOn = "2026-09-24"
item.PlannedOn = "2026-09-25"
item.ReviewOn = "2026-09-24"
if _, err = s.store.SaveTask(ctx, domain, actor, item, 0); err != nil {
t.Fatal(err)
}
}
q := store.TaskQuery{Kind: "task", View: "today", Today: "2026-09-24", Limit: 3}
seen := map[string]bool{}
for {
items, next, err := s.store.ListTasks(ctx, domain, actor, q)
if err != nil {
t.Fatal(err)
}
for _, i := range items {
if seen[i.UUID] {
t.Fatal("duplicate page")
}
seen[i.UUID] = true
if i.Notes != "" {
t.Fatal("list includes full notes")
}
}
if next == "" {
break
}
q.Before = next
}
if len(seen) != 7 {
t.Fatal("missing tasks", len(seen))
}
for _, view := range []string{"inbox", "review", "all"} {
items, _, err := s.store.ListTasks(ctx, domain, actor, store.TaskQuery{Kind: "task", View: view, Today: "2026-09-24", Project: project.UUID})
if err != nil || len(items) != 7 {
t.Fatal(view, len(items), err)
}
}
item := newTaskRecord("task", "Bad project")
item.ProjectUUID = uuid.NewString()
if _, err = s.store.SaveTask(ctx, domain, actor, item, 0); !errors.Is(err, store.ErrTaskInvalid) {
t.Fatal("missing project", err)
}
project.Archived = true
project, err = s.store.SaveTask(ctx, domain, actor, project, 1)
if err != nil {
t.Fatal(err)
}
item.ProjectUUID = project.UUID
if _, err = s.store.SaveTask(ctx, domain, actor, item, 0); !errors.Is(err, store.ErrTaskInvalid) {
t.Fatal("archived project", err)
}
for _, view := range []string{"/v/plan/today", "/v/plan/tasks/backlog", "/v/plan/projects", "/v/plan/project/" + project.UUID, "/v/plan/task/-/new"} {
w := configRequest(s, token, "GET", view, nil)
if w.Code != 200 || !strings.Contains(w.Body.String(), "tasks-app") {
t.Fatalf("page %s: %d %s", view, w.Code, w.Body)
}
}
if w := configRequest(s, token, "GET", "/v/plan/task/extra/"+project.UUID, nil); w.Code != 404 {
t.Fatal("malformed route", w.Code)
}
if err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil {
t.Fatal(err)
}
if w := taskRequest(s, token, "GET", "items", nil, ""); w.Code != 404 {
t.Fatal("disabled read", w.Code)
}
if _, err = s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Disabled"), 0); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("disabled store write", err)
}
}
func TestTasksValidationAtomicityAndWikiReference(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
for _, mutate := range []func(*store.TaskRecord){func(i *store.TaskRecord) { i.Title = " " }, func(i *store.TaskRecord) { i.DueOn = "2026-02-30" }, func(i *store.TaskRecord) { i.Status = "pending" }, func(i *store.TaskRecord) { i.Notes = strings.Repeat("a", 16385) }, func(i *store.TaskRecord) { i.PageUUID = "bad" }} {
item := newTaskRecord("task", "Invalid")
mutate(&item)
if _, err := s.store.SaveTask(ctx, domain, actor, item, 0); !errors.Is(err, store.ErrTaskInvalid) {
t.Fatal("invalid accepted", err)
}
}
// Schema changes and fixtures only: never access imported calendar data.
if _, err := s.store.DB.Exec(`CREATE TRIGGER reject_task_journal BEFORE INSERT ON organizer_changes BEGIN SELECT RAISE(ABORT,'test rollback'); END`); err != nil {
t.Fatal(err)
}
item := newTaskRecord("task", "Rollback")
if _, err := s.store.SaveTask(ctx, domain, actor, item, 0); err == nil {
t.Fatal("expected failure")
}
if _, err := s.store.GetTask(ctx, domain, actor, item.UUID); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("partial head", err)
}
if _, err := s.store.DB.Exec(`DROP TRIGGER reject_task_journal`); err != nil {
t.Fatal(err)
}
// Use a regular Wiki page; task-only body is never inserted into Wiki objects.
_, err := s.store.CreatePageAtPathInDomain(domain, "/tasks-fixture")
if err != nil {
t.Fatal(err)
}
item = newTaskRecord("task", "Linked")
body := map[string]any{}
raw, _ := json.Marshal(item)
json.Unmarshal(raw, &body)
body["page_path"] = "/tasks-fixture"
w := taskRequest(s, token, "POST", "items", body, "")
if w.Code != 201 {
t.Fatalf("link %d %s", w.Code, w.Body)
}
var result struct {
Item store.TaskRecord `json:"item"`
Path string `json:"page_path"`
}
json.Unmarshal(w.Body.Bytes(), &result)
if result.Path != "/tasks-fixture" || result.Item.PageUUID == "" {
t.Fatal(w.Body)
}
if _, err = s.store.DB.Exec(`UPDATE paths SET path='/renamed-fixture' WHERE domain_uuid=? AND object_uuid=?`, domain, result.Item.PageUUID); err != nil {
t.Fatal(err)
}
w = taskRequest(s, token, "GET", "items/"+item.UUID, nil, "")
json.Unmarshal(w.Body.Bytes(), &result)
if result.Path != "/renamed-fixture" {
t.Fatal("rename link did not follow", w.Body)
}
if _, err = s.store.DB.Exec(`DELETE FROM paths WHERE domain_uuid=? AND object_uuid=?`, domain, result.Item.PageUUID); err != nil {
t.Fatal(err)
}
w = taskRequest(s, token, "GET", "items/"+item.UUID, nil, "")
json.Unmarshal(w.Body.Bytes(), &result)
if result.Path != "" {
t.Fatal("removed Wiki page leaked a stale path", w.Body)
}
}
func TestTasksConcurrentUpdateAndCrossSiteWrite(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Concurrent"), 0)
if err != nil {
t.Fatal(err)
}
start := make(chan struct{})
out := make(chan error, 2)
var wg sync.WaitGroup
for _, title := range []string{"One", "Two"} {
wg.Add(1)
go func(title string) {
defer wg.Done()
<-start
changed := item
changed.Title = title
_, e := s.store.SaveTask(ctx, domain, actor, changed, 1)
out <- e
}(title)
}
close(start)
wg.Wait()
close(out)
success, conflict := 0, 0
for e := range out {
if e == nil {
success++
} else if errors.Is(e, store.ErrTaskConflict) {
conflict++
} else {
t.Fatal(e)
}
}
if success != 1 || conflict != 1 {
t.Fatalf("success=%d conflict=%d", success, conflict)
}
var revisions, changes int
s.store.DB.QueryRow(`SELECT count(*) FROM organizer_revisions WHERE item_uuid=?`, item.UUID).Scan(&revisions)
s.store.DB.QueryRow(`SELECT count(*) FROM organizer_changes WHERE item_uuid=?`, item.UUID).Scan(&changes)
if revisions != 2 || changes != 2 {
t.Fatalf("partial or duplicated revision: %d %d", revisions, changes)
}
r := httptest.NewRequest("POST", "http://localhost"+tasksAPI+"items", strings.NewReader(`{}`))
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Origin", "https://attacker.example")
r.Header.Set("Sec-Fetch-Site", "cross-site")
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
if w.Code != 403 {
t.Fatalf("cross-site status %d", w.Code)
}
}