package server import ( "context" "database/sql" "errors" "strconv" "strings" "testing" "time" "github.com/google/uuid" "pageswiki/internal/store" ) func TestTaskDeleteAPIAndDAVTombstone(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() page, err := s.store.CreatePageAtPathInDomain(domain, "/delete-fixture-note") if err != nil { t.Fatal(err) } task := newTaskRecord("task", "Delete fixture") task.PageUUID = page task.NotifyDue, task.DueOn = true, "2099-01-01" task, err = s.store.SaveTask(ctx, domain, actor, task, 0) if err != nil { t.Fatal(err) } url := "items/" + task.UUID for _, test := range []struct { tag string status int }{{"", 428}, {`W/"1"`, 422}, {`"2"`, 412}} { w := taskRequest(s, token, "DELETE", url, nil, test.tag) if w.Code != test.status { t.Fatalf("precondition %s: %d %s", test.tag, w.Code, w.Body) } } for i := 0; i < 2; i++ { w := taskRequest(s, token, "DELETE", url, nil, `"1"`) if w.Code != 204 { t.Fatalf("delete/retry: %d %s", w.Code, w.Body) } } for _, suffix := range []string{url, url + "/history"} { if w := taskRequest(s, token, "GET", suffix, nil, ""); w.Code != 404 { t.Fatalf("deleted read: %d %s", w.Code, w.Body) } } for _, view := range []string{"all", "archived", "done", "today"} { w := taskRequest(s, token, "GET", "items?view="+view, nil, "") if w.Code != 200 || strings.Contains(w.Body.String(), task.UUID) { t.Fatalf("deleted list %s: %d %s", view, w.Code, w.Body) } } for _, table := range []string{"organizer_items", "organizer_revisions", "organizer_reminders", "organizer_task_metrics"} { var count int if err := s.store.DB.QueryRow(`SELECT count(*) FROM ` + table).Scan(&count); err != nil || count != 0 { t.Fatalf("cleanup %s: %d %v", table, count, err) } } if id, err := s.store.ResolvePathInDomain(domain, "/delete-fixture-note"); err != nil || id != page { t.Fatal("Wiki note removed", id, err) } if _, err := s.store.SaveTask(ctx, domain, actor, task, 0); !errors.Is(err, store.ErrTaskDeleted) { t.Fatal("UUID recreated", err) } if _, _, err := s.store.PublishTaskActivity(ctx, 100); err != nil { t.Fatal("deleted head stalled outbox bridge", err) } for _, project := range []string{"", uuid.NewString()} { if project != "" { p := newTaskRecord("project", "Delete project fixture") p.UUID = project if _, err := s.store.SaveTask(ctx, domain, actor, p, 0); err != nil { t.Fatal(err) } } davTask := newTaskRecord("task", "DAV fixture") davTask.ProjectUUID = project data := &store.TaskDAVData{Name: "client-fixture.ics", UID: "client-fixture-uid", Data: "fixture"} davTask, err = s.store.SaveTaskDAV(ctx, domain, actor, davTask, 0, data, "", project) if err != nil { t.Fatal(err) } if err = s.store.DeleteTask(ctx, domain, actor, davTask.UUID, davTask.Version); err != nil { t.Fatal(err) } // Simulate reopening/rebuilding the derived DAV indexes. if err = s.store.EnsureTasksSchema(); err != nil { t.Fatal(err) } if _, err = s.store.TaskDAVByName(ctx, domain, actor, data.Name, project); !errors.Is(err, sql.ErrNoRows) { t.Fatal("DAV deleted resource exposed", err) } items, err := s.store.TaskDAVList(ctx, domain, actor, project) if err != nil || len(items) != 0 { t.Fatal("DAV deleted resource listed", items, err) } for _, altered := range []string{"neither", "name", "uid"} { candidate := newTaskRecord("task", "Stale client PUT") candidate.ProjectUUID = project d := *data if altered == "name" { d.Name = "other.ics" } if altered == "uid" { d.UID = "other-uid" } if _, err := s.store.SaveTaskDAV(ctx, domain, actor, candidate, 0, &d, "", project); !errors.Is(err, store.ErrTaskDAVIdentity) { t.Fatalf("resurrection %s: %v", altered, err) } } } } func TestTaskDeleteGuardsAndAtomicity(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() task, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Guarded fixture"), 0) if err != nil { t.Fatal(err) } other, err := s.store.CreatePasswordAccount(domain, "deleteother", "long fixture password", "Other", "") if err != nil { t.Fatal(err) } if err := s.store.DeleteTask(ctx, domain, other.UUID, task.UUID, 1); !errors.Is(err, sql.ErrNoRows) { t.Fatal("ownership", err) } if err := s.store.DeleteTask(ctx, "other-domain", actor, task.UUID, 1); !errors.Is(err, store.ErrAccessDenied) { t.Fatal("domain", err) } if err := s.store.SetPrincipalState(domain, actor, "readonly"); err != nil { t.Fatal(err) } if w := taskRequest(s, token, "DELETE", "items/"+task.UUID, nil, `"1"`); w.Code != 401 { t.Fatal("readonly", w.Code, w.Body) } if err := s.store.DeleteTask(ctx, domain, actor, task.UUID, 1); !errors.Is(err, store.ErrAccessDenied) { t.Fatal("readonly store", err) } if err := s.store.SetPrincipalState(domain, actor, "active"); err != nil { t.Fatal(err) } token, err = s.store.CreateAuthSession(domain, actor) if err != nil { t.Fatal(err) } if err := s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil { t.Fatal(err) } if err := s.store.DeleteTask(ctx, domain, actor, task.UUID, 1); !errors.Is(err, store.ErrAccessDenied) { t.Fatal("disabled", err) } if _, err := s.store.DB.Exec(`DELETE FROM config WHERE domain_uuid=? AND key='system_extension_states'`, domain); err != nil { t.Fatal(err) } child := newTaskRecord("task", "Archived child") child.ParentUUID = task.UUID child.Archived = true child, err = s.store.SaveTask(ctx, domain, actor, child, 0) if err != nil { t.Fatal(err) } if w := taskRequest(s, token, "DELETE", "items/"+task.UUID, nil, `"1"`); w.Code != 409 || !strings.Contains(w.Body.String(), "has_children") { t.Fatal("children", w.Code, w.Body) } if err = s.store.DeleteTask(ctx, domain, actor, child.UUID, child.Version); err != nil { t.Fatal(err) } focus, err := s.store.ChangeTaskFocus(ctx, domain, actor, "start", store.TaskFocus{UUID: uuid.NewString(), TaskUUID: task.UUID, Phase: "focus", DurationMS: 25 * 60 * 1000}, 0, time.Now()) if err != nil { t.Fatal(err) } if err = s.store.DeleteTask(ctx, domain, actor, task.UUID, 1); !errors.Is(err, store.ErrTaskWorking) { t.Fatal("focus", err) } if _, err = s.store.ChangeTaskFocus(ctx, domain, actor, "cancel", focus, focus.Version, time.Now()); err != nil { t.Fatal(err) } work, err := s.store.ChangeTaskWork(ctx, domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: task.UUID}, time.Now()) if err != nil { t.Fatal(err) } if err = s.store.DeleteTask(ctx, domain, actor, task.UUID, 1); !errors.Is(err, store.ErrTaskWorking) { t.Fatal("running work", err) } if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "stop", work, time.Now()); err != nil { t.Fatal(err) } // Abort at the last delete step: neither a tombstone nor partial cleanup may remain. if _, err = s.store.DB.Exec(`CREATE TRIGGER fail_fixture_delete BEFORE DELETE ON organizer_items BEGIN SELECT RAISE(ABORT,'fixture failure'); END`); err != nil { t.Fatal(err) } if err = s.store.DeleteTask(ctx, domain, actor, task.UUID, 1); err == nil { t.Fatal("injected failure ignored") } if _, err = s.store.GetTask(ctx, domain, actor, task.UUID); err != nil { t.Fatal("head not rolled back", err) } var n int if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_task_deletions WHERE item_uuid=?`, task.UUID).Scan(&n); err != nil || n != 0 { t.Fatal("partial tombstone", n, err) } if _, err = s.store.DB.Exec(`DROP TRIGGER fail_fixture_delete`); err != nil { t.Fatal(err) } task.Archived = true task, err = s.store.SaveTask(ctx, domain, actor, task, 1) if err != nil { t.Fatal(err) } if w := taskRequest(s, token, "DELETE", "items/"+task.UUID, nil, `"`+strconv.FormatInt(task.Version, 10)+`"`); w.Code != 204 { t.Fatal("archived deletion", w.Code, w.Body) } if err := s.store.DeleteTask(ctx, domain, other.UUID, task.UUID, task.Version); !errors.Is(err, sql.ErrNoRows) { t.Fatal("tombstone ownership", err) } if _, err := s.store.SaveTask(ctx, domain, other.UUID, task, 0); !errors.Is(err, sql.ErrNoRows) { t.Fatal("tombstone creation privacy", err) } if err := s.store.DB.QueryRow(`SELECT count(*) FROM organizer_work_sessions WHERE uuid=? AND end_ms>0`, work.UUID).Scan(&n); err != nil || n != 1 { t.Fatal("work history removed", n, err) } project, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("project", "Keep project"), 0) if err != nil { t.Fatal(err) } if err = s.store.DeleteTask(ctx, domain, actor, project.UUID, 1); !errors.Is(err, store.ErrTaskInvalid) { t.Fatal("project unexpectedly deleted", err) } } func TestTaskDeleteDAVHTTP(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() auth, name := "Bearer "+token, "delete-client.ics" url := taskDAVCollection + name if w := davTaskRequest(s, auth, "PUT", url, taskICALFixture, nil); w.Code != 201 { t.Fatal(w.Code, w.Body) } item, err := s.store.TaskDAVByName(ctx, domain, actor, name) if err != nil { t.Fatal(err) } before := davTaskRequest(s, auth, "GET", url, "", nil) if before.Code != 200 { t.Fatal(before.Code, before.Body) } if err = s.store.DeleteTask(ctx, domain, actor, item.UUID, item.Version); err != nil { t.Fatal(err) } if w := davTaskRequest(s, auth, "GET", url, "", nil); w.Code != 404 { t.Fatal(w.Code, w.Body) } query := `` if w := davTaskRequest(s, auth, "REPORT", taskDAVCollection, query, nil); w.Code != 207 || strings.Contains(w.Body.String(), name) { t.Fatal("query", w.Code, w.Body) } multi := `` + url + `` if w := davTaskRequest(s, auth, "REPORT", taskDAVCollection, multi, nil); w.Code != 207 || !strings.Contains(w.Body.String(), "404 Not Found") { t.Fatal("multiget", w.Code, w.Body) } if w := davTaskRequest(s, auth, "PUT", url, taskICALFixture, map[string]string{"If-Match": before.Header().Get("ETag")}); w.Code != 412 { t.Fatal("stale conditional PUT", w.Code, w.Body) } if w := davTaskRequest(s, auth, "PUT", url, taskICALFixture, nil); w.Code != 403 || !strings.Contains(w.Body.String(), "no-uid-conflict") { t.Fatal("stale unconditional PUT", w.Code, w.Body) } }