273 lines
10 KiB
Go
273 lines
10 KiB
Go
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 := `<c:calendar-query xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:d="DAV:"><d:prop><d:getetag/><c:calendar-data/></d:prop><c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="VTODO"/></c:comp-filter></c:filter></c:calendar-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 := `<c:calendar-multiget xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:d="DAV:"><d:prop><d:getetag/><c:calendar-data/></d:prop><d:href>` + url + `</d:href></c:calendar-multiget>`
|
|
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)
|
|
}
|
|
}
|