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.
330 lines
11 KiB
Go
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)
|
|
}
|
|
}
|