package store import ( "context" "database/sql" "errors" "fmt" "testing" "github.com/google/uuid" ) func taskBackendFixture(t *testing.T, b storeSQLBackend) (*Store, string, string) { t.Helper() f := newPublicationBackend(t, b) s := f.s s.DocumentRoot = t.TempDir() var err error err = s.EnsureTasksSchema() if err == nil && b == storeSQLite { _, err = s.DB.Exec(`CREATE TABLE IF NOT EXISTS organizer_contact_credentials(credential_id TEXT PRIMARY KEY)`) } if err != nil { t.Fatal(err) } return s, f.domain, f.actor } func TestTaskBackendCoreAndDAV(t *testing.T) { for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} { t.Run(fmt.Sprint(b), func(t *testing.T) { s, d, a := taskBackendFixture(t, b) ctx := context.Background() makeItem := func(kind, title string) TaskRecord { return TaskRecord{UUID: uuid.NewString(), Kind: kind, Title: title, Status: "todo", Bucket: "inbox"} } project, err := s.SaveTask(ctx, d, a, makeItem("project", "Project"), 0) if err != nil { t.Fatal(err) } task := makeItem("task", "日本語 Task") task.ProjectUUID = project.UUID task.DueOn = "2026-11-15" task.PlannedOn = "2026-11-15" task.StartOn = "2026-11-15" task.EndOn = "2026-11-16" task.References = []string{"https://example.invalid/reference"} task.NotifyDue = true task.Priority = 2 task, err = s.SaveTaskDAV(ctx, d, a, task, 0, &TaskDAVData{Name: "same.ics", UID: "same", Data: "synthetic VTODO"}, "", project.UUID) if err != nil { t.Fatal(err) } got, err := s.TaskDAVByName(ctx, d, a, "same.ics", project.UUID) if err != nil || got.UUID != task.UUID { t.Fatal(got, err) } defaultTask, err := s.SaveTaskDAV(ctx, d, a, makeItem("task", "Default"), 0, &TaskDAVData{Name: "same.ics", UID: "same", Data: "default VTODO"}, "", "") if err != nil { t.Fatal("same identity in separate collection", err) } got, err = s.TaskDAVByName(ctx, d, a, "same.ics") if err != nil || got.UUID != defaultTask.UUID { t.Fatal(got, err) } dup := makeItem("task", "Collision") dup.ProjectUUID = project.UUID if _, err = s.SaveTaskDAV(ctx, d, a, dup, 0, task.CalDAV, "", project.UUID); !errors.Is(err, ErrTaskDAVIdentity) { t.Fatal(err) } if list, err := s.TaskDAVList(ctx, d, a, project.UUID); err != nil || len(list) != 1 { t.Fatal(list, err) } if list, err := s.TaskDAVList(ctx, d, a); err != nil || len(list) != 1 { t.Fatal(list, err) } if list, err := s.TaskDAVCollections(ctx, d, a); err != nil || len(list) != 1 { t.Fatal(list, err) } child := makeItem("task", "Child") child.ParentUUID = task.UUID child.ProjectUUID = project.UUID child, err = s.SaveTask(ctx, d, a, child, 0) if err != nil { t.Fatal(err) } if parents, err := s.TaskContextParents(ctx, d, a, []TaskRecord{child}); err != nil || len(parents) != 1 { t.Fatal(parents, err) } if list, _, err := s.TaskSchedule(ctx, d, a, "2026-11", project.UUID); err != nil || len(list) != 1 { t.Fatal(list, err) } for _, query := range []TaskQuery{ {Kind: "task", View: "today", Project: project.UUID, Search: "日本語"}, {Kind: "task", View: "index", Filter: "~s 日本語 ~priority 2 ~attachment ~due today", Sort: "priority", Project: project.UUID}, {Kind: "task", View: "day"}, {Kind: "task", View: "carryover"}, {Kind: "task", View: "review"}, {Kind: "task", View: "all", Hierarchy: true}, } { query.Today = "2026-11-15" query.Limit = 1 items, next, err := s.ListTasks(ctx, d, a, query) if err != nil { t.Fatal(query, err) } if query.Search != "" || query.Filter != "" { if len(items) != 1 || items[0].UUID != task.UUID { t.Fatal(query, items) } } seen := map[string]bool{} for _, v := range items { seen[v.UUID] = true } for next != "" { query.Before = next items, next, err = s.ListTasks(ctx, d, a, query) if err != nil { t.Fatal(query, err) } for _, v := range items { if seen[v.UUID] { t.Fatal("pagination repeats") } seen[v.UUID] = true } } } if err = s.DeleteTask(ctx, d, a, task.UUID, task.Version); !errors.Is(err, ErrTaskHasChildren) { t.Fatal(err) } if err = s.DeleteTask(ctx, d, a, child.UUID, child.Version); err != nil { t.Fatal(err) } task.Status = "done" task.References = nil updated, err := s.SaveTask(ctx, d, a, task, task.Version) if err != nil || len(updated.References) != 1 || updated.CalDAV == nil { t.Fatal(updated, err) } if _, err = s.SaveTask(ctx, d, a, task, task.Version); !errors.Is(err, ErrTaskConflict) { t.Fatal(err) } if history, err := s.TaskHistory(ctx, d, a, task.UUID); err != nil || len(history) != 2 { t.Fatal(history, err) } var reminders int if err = s.DB.QueryRow(`SELECT count(*) FROM organizer_reminders`).Scan(&reminders); err != nil || reminders != 0 { t.Fatal(reminders, err) } if err = s.DeleteTask(ctx, d, a, updated.UUID, updated.Version); err != nil { t.Fatal(err) } if err = s.DeleteTask(ctx, d, a, updated.UUID, updated.Version); err != nil { t.Fatal("delete retry", err) } if _, err = s.SaveTask(ctx, d, a, updated, 0); !errors.Is(err, ErrTaskDeleted) { t.Fatal(err) } if _, err = s.TaskDAVByName(ctx, d, a, "same.ics", project.UUID); !errors.Is(err, sql.ErrNoRows) { t.Fatal(err) } cred, secret, err := s.CreateDAVCredential(ctx, d, a, "synthetic", true, 1, "all", true) if err != nil { t.Fatal(err) } if owner, write, _, err := s.AuthenticateDAV(ctx, d, cred.ID, secret, "tasks"); err != nil || owner != a || !write { t.Fatal(owner, write, err) } if err = s.SetTaskDAVDefaultTitle(ctx, d, a, "New default", cred.ID); err != nil { t.Fatal(err) } if title, err := s.TaskDAVDefaultTitle(ctx, d, a); err != nil || title != "New default" { t.Fatal(title, err) } if err = s.RevokeTaskDAVCredential(ctx, d, a, cred.ID); err != nil { t.Fatal(err) } if _, _, _, err = s.AuthenticateDAV(ctx, d, cred.ID, secret, "tasks"); !errors.Is(err, ErrAccessDenied) { t.Fatal(err) } s.ReadOnly = true if _, err = s.SaveTask(ctx, d, a, defaultTask, defaultTask.Version); !errors.Is(err, ErrReadOnly) { t.Fatal(err) } }) } } func TestPostgreSQLTaskConcurrentCASAndRollback(t *testing.T) { s, d, a := taskBackendFixture(t, storePostgreSQL) ctx := context.Background() v, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "before", Status: "todo", Bucket: "inbox"}, 0) if err != nil { t.Fatal(err) } peer := &Store{DB: s.DB, DocumentRoot: s.DocumentRoot, sqlBackend: storePostgreSQL} results := make(chan error, 2) for _, writer := range []*Store{s, peer} { go func(w *Store) { item := v item.Title = "updated" _, e := w.SaveTask(ctx, d, a, item, v.Version) results <- e }(writer) } wins := 0 for i := 0; i < 2; i++ { e := <-results if e == nil { wins++ } else if !errors.Is(e, ErrTaskConflict) { t.Fatal(e) } } if wins != 1 { t.Fatal("CAS winners", wins) } v, err = s.GetTask(ctx, d, a, v.UUID) if err != nil { t.Fatal(err) } if _, err = s.DB.Exec(`ALTER TABLE activity_outbox RENAME COLUMN payload TO unavailable_payload`); err != nil { t.Fatal(err) } changed := v changed.Title = "must roll back" if _, err = s.SaveTask(ctx, d, a, changed, v.Version); err == nil { t.Fatal("ignored outbox failure") } current, err := s.GetTask(ctx, d, a, v.UUID) if err != nil || current.Version != v.Version || current.Title != v.Title { t.Fatal(current, err) } if err = s.DeleteTask(ctx, d, a, v.UUID, v.Version); err == nil { t.Fatal("delete ignored outbox failure") } if _, err = s.GetTask(ctx, d, a, v.UUID); err != nil { t.Fatal("partial delete", err) } if _, err = s.DB.Exec(`ALTER TABLE activity_outbox RENAME COLUMN unavailable_payload TO payload`); err != nil { t.Fatal(err) } if _, err = s.DB.Exec(`UPDATE principals SET state='readonly' WHERE uuid=$1`, a); err != nil { t.Fatal(err) } if _, err = s.SaveTask(ctx, d, a, v, v.Version); !errors.Is(err, ErrAccessDenied) { t.Fatal(err) } if _, err = s.GetTask(ctx, d, a, v.UUID); err != nil { t.Fatal(err) } if _, err = s.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=$1 AND principal_uuid=$2`, d, a); err != nil { t.Fatal(err) } if _, err = s.GetTask(ctx, d, a, v.UUID); !errors.Is(err, ErrAccessDenied) { t.Fatal(err) } }