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