Files
pages/internal/server/tasks_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

330 lines
11 KiB
Go

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