Files
pages/internal/store/tasks_backend_test.go
2026-11-15 05:47:14 +09:00

258 lines
8.4 KiB
Go

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