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

458 lines
15 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"github.com/google/uuid"
"testing"
"time"
)
func productivityBackendFixture(t *testing.T, b storeSQLBackend) (*Store, string, string) {
t.Helper()
s, d, a := taskBackendFixture(t, b)
if b == storePostgreSQL {
for i := 0; i < 2; i++ {
if err := s.ensurePostgreSQLTaskProductivity(context.Background()); err != nil {
t.Fatal(err)
}
}
if err := s.ensurePostgreSQLNotificationInbox(context.Background()); err != nil {
t.Fatal(err)
}
} else if err := s.EnsureNotificationSchema(); err != nil {
t.Fatal(err)
}
return s, d, a
}
func TestTaskProductivityBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, b)
ctx := context.Background()
today := time.Now().UTC().Truncate(24 * time.Hour)
start := today.Add(9 * time.Hour)
task, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Planning", Status: "todo", Bucket: "inbox", Estimate: 30, PlannedOn: today.Format("2006-01-02")}, 0)
if err != nil {
t.Fatal(err)
}
p, err := s.TaskPreferences(ctx, d, a)
if err != nil {
t.Fatal(err)
}
p.DigestEnabled = true
p.Timezone = "Asia/Tokyo"
p.WikiPrefix = "/tasks/{YYYY}/{MM}"
p.Estimate = 30
p, err = s.SaveTaskPreferences(ctx, d, a, p, start)
if err != nil || p.Version != 1 {
t.Fatal(p, err)
}
stale := p
stale.Version = 0
if _, err = s.SaveTaskPreferences(ctx, d, a, stale, start); !errors.Is(err, ErrTaskConflict) {
t.Fatal(err)
}
read, err := s.TaskPreferences(ctx, d, a)
if err != nil || read.WikiPrefix != p.WikiPrefix {
t.Fatal(read, err)
}
layout, err := s.SaveDashboard(ctx, d, a, 0, []DashboardWidget{{ID: "today", Width: 1, Height: 1}})
if err != nil || layout.Widgets[0].Width != 3 {
t.Fatal(layout, err)
}
if _, err = s.SaveDashboard(ctx, d, a, 0, DefaultDashboard()); !errors.Is(err, ErrTaskConflict) {
t.Fatal(err)
}
if got, err := s.Dashboard(ctx, d, a); err != nil || got.Version != 1 {
t.Fatal(got, err)
}
if got, err := s.TaskPreferences(ctx, d, a); err != nil || got.Version != p.Version {
t.Fatal("layout invalidated preferences", got, err)
}
work, err := s.ChangeTaskWork(ctx, d, a, "start", TaskWork{UUID: uuid.NewString(), TaskUUID: task.UUID}, start)
if err != nil {
t.Fatal(err)
}
if _, err = s.ChangeTaskWork(ctx, d, a, "start", TaskWork{UUID: uuid.NewString(), TaskUUID: task.UUID}, start); !errors.Is(err, ErrTaskConflict) {
t.Fatal(err)
}
if got, err := s.ActiveTaskWork(ctx, d, a); err != nil || got == nil || got.UUID != work.UUID {
t.Fatal(got, err)
}
work, err = s.ChangeTaskWork(ctx, d, a, "stop", work, start.Add(30*time.Minute))
if err != nil {
t.Fatal(err)
}
other, err := s.ChangeTaskWork(ctx, d, a, "start", TaskWork{UUID: uuid.NewString(), TaskUUID: task.UUID}, start.Add(time.Hour))
if err != nil {
t.Fatal(err)
}
other, err = s.ChangeTaskWork(ctx, d, a, "stop", other, start.Add(70*time.Minute))
if err != nil {
t.Fatal(err)
}
other.EndMS = start.Add(75 * time.Minute).UnixMilli()
other, err = s.ChangeTaskWork(ctx, d, a, "correct", other, start.Add(2*time.Hour), "corrected end")
if err != nil {
t.Fatal(err)
}
other, err = s.ChangeTaskWork(ctx, d, a, "cancel", other, start.Add(2*time.Hour), "duplicate work")
if err != nil {
t.Fatal(err)
}
if revisions, err := s.TaskWorkRevisions(ctx, d, a, other.UUID, 0); err != nil || len(revisions) != 4 {
t.Fatal(revisions, err)
}
page, err := s.TaskWorkHistory(ctx, d, a, today, today.AddDate(0, 0, 1), "", 1)
if err != nil || len(page.Items) != 1 || page.Next == "" {
t.Fatal(page, err)
}
page, err = s.TaskWorkHistory(ctx, d, a, today, today.AddDate(0, 0, 1), page.Next, 1)
if err != nil || len(page.Items) != 1 || page.Items[0].UUID != work.UUID {
t.Fatal(page, err)
}
f, err := s.ChangeTaskFocus(ctx, d, a, "start", TaskFocus{UUID: uuid.NewString(), TaskUUID: task.UUID, Phase: "focus", DurationMS: 25 * 60000}, 0, start)
if err != nil {
t.Fatal(err)
}
f, err = s.ChangeTaskFocus(ctx, d, a, "pause", f, f.Version, start.Add(10*time.Minute))
if err != nil {
t.Fatal(err)
}
f, err = s.ChangeTaskFocus(ctx, d, a, "resume", f, f.Version, start.Add(20*time.Minute))
if err != nil {
t.Fatal(err)
}
if n, err := s.CompleteTaskFocus(ctx, start.Add(40*time.Minute), 100); err != nil || n != 1 {
t.Fatal(n, err)
}
if n, err := s.CompleteTaskFocus(ctx, start.Add(41*time.Minute), 100); err != nil || n != 0 {
t.Fatal(n, err)
}
if got, err := s.LatestTaskFocus(ctx, d, a); err != nil || got.State != "completed" {
t.Fatal(got, err)
}
notices, _, err := s.ListNotifications(ctx, d, a, true, "", 10)
if err != nil || len(notices) != 1 {
t.Fatal(notices, err)
}
if err = s.MarkNotificationRead(d, a, notices[0].UUID); err != nil {
t.Fatal(err)
}
if got, err := s.GetNotification(ctx, d, a, notices[0].UUID); err != nil || got.Status != "read" {
t.Fatal(got, err)
}
summary, err := s.TaskDaySummary(ctx, d, a, today, today.AddDate(0, 0, 1), start.Add(2*time.Hour))
if err != nil || summary.FocusMS != 25*60000 || summary.TaskCount != 1 {
t.Fatal(summary, err)
}
report, err := s.TaskReport(ctx, d, a, today, today.AddDate(0, 0, 1), start.Add(2*time.Hour))
if err != nil || report.Days[0].WorkMS != 30*60000 || report.Days[0].FocusMS != 25*60000 {
t.Fatal(report, err)
}
block, err := s.ReserveTaskBlock(ctx, d, a, TaskBlock{UUID: uuid.NewString(), TaskUUID: task.UUID, CalendarUUID: uuid.NewString(), Start: start, End: start.Add(time.Hour)}, task.Version)
if err != nil || block.Title != "Planning" {
t.Fatal(block, err)
}
if err = s.SetTaskBlockState(ctx, d, a, block.UUID, "active"); err != nil {
t.Fatal(err)
}
if got, err := s.GetTaskBlock(ctx, d, a, block.UUID); err != nil || got.State != "active" {
t.Fatal(got, err)
}
if got, err := s.TaskBlocks(ctx, d, a, task.UUID); err != nil || len(got) != 1 {
t.Fatal(got, err)
}
if got, more, err := s.TaskBlockCalendars(ctx, d, a); err != nil || more || len(got) != 1 {
t.Fatal(got, err)
}
if err = s.SetTaskBlockState(ctx, d, a, block.UUID, "unlinked"); err != nil {
t.Fatal(err)
}
task.Status = "done"
if _, err = s.SaveTask(ctx, d, a, task, task.Version); err != nil {
t.Fatal(err)
}
if progress, err := s.DashboardProgress(ctx, d, a, today.Format("2006-01-02")); err != nil || progress.Total != 1 || progress.Done != 1 {
t.Fatal(progress, err)
}
s.ReadOnly = true
if _, err = s.ChangeTaskFocus(ctx, d, a, "start", TaskFocus{UUID: uuid.NewString(), Phase: "break", DurationMS: 60000}, 0, start); !errors.Is(err, ErrReadOnly) {
t.Fatal(err)
}
if err = s.SetTaskBlockState(ctx, d, a, block.UUID, "unlinked"); !errors.Is(err, ErrReadOnly) {
t.Fatal(err)
}
})
}
}
func TestPostgreSQLProductivityConcurrentAndRollback(t *testing.T) {
s, d, a := productivityBackendFixture(t, storePostgreSQL)
ctx := context.Background()
now := time.Now().UTC()
task, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Concurrent", Status: "todo", Bucket: "inbox"}, 0)
if err != nil {
t.Fatal(err)
}
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL, DocumentRoot: s.DocumentRoot}
writers := []*Store{s, peer}
prefs, err := s.TaskPreferences(ctx, d, a)
if err != nil {
t.Fatal(err)
}
checkRace := func(fn func(*Store) error) {
t.Helper()
results := make(chan error, 2)
for _, w := range writers {
go func(w *Store) { results <- fn(w) }(w)
}
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("expected one winner", wins)
}
}
checkRace(func(w *Store) error { _, e := w.SaveTaskPreferences(ctx, d, a, prefs, now); return e })
checkRace(func(w *Store) error { _, e := w.SaveDashboard(ctx, d, a, 0, DefaultDashboard()); return e })
checkRace(func(w *Store) error {
_, e := w.ChangeTaskWork(ctx, d, a, "start", TaskWork{UUID: uuid.NewString(), TaskUUID: task.UUID}, now)
return e
})
work, err := s.ActiveTaskWork(ctx, d, a)
if err != nil || work == nil {
t.Fatal(work, err)
}
if _, err = s.DB.Exec(`ALTER TABLE organizer_work_revisions RENAME COLUMN reason TO unavailable_reason`); err != nil {
t.Fatal(err)
}
if _, err = s.ChangeTaskWork(ctx, d, a, "stop", *work, now.Add(time.Minute)); err == nil {
t.Fatal("ignored work audit failure")
}
if current, err := s.ActiveTaskWork(ctx, d, a); err != nil || current == nil || current.Version != work.Version {
t.Fatal("partial work update", current, err)
}
if _, err = s.DB.Exec(`ALTER TABLE organizer_work_revisions RENAME COLUMN unavailable_reason TO reason`); err != nil {
t.Fatal(err)
}
if _, err = s.ChangeTaskWork(ctx, d, a, "stop", *work, now.Add(time.Minute)); err != nil {
t.Fatal(err)
}
checkRace(func(w *Store) error {
_, e := w.ChangeTaskFocus(ctx, d, a, "start", TaskFocus{UUID: uuid.NewString(), TaskUUID: task.UUID, Phase: "focus", DurationMS: 60000}, 0, now)
return e
})
focus, err := s.LatestTaskFocus(ctx, d, a)
if err != nil || focus == nil {
t.Fatal(focus, err)
}
if _, err = s.DB.Exec(`ALTER TABLE organizer_focus_changes RENAME COLUMN action TO unavailable_action`); err != nil {
t.Fatal(err)
}
if _, err = s.ChangeTaskFocus(ctx, d, a, "pause", *focus, focus.Version, now.Add(30*time.Second)); err == nil {
t.Fatal("ignored focus audit failure")
}
if current, err := s.LatestTaskFocus(ctx, d, a); err != nil || current.State != "running" || current.Version != focus.Version {
t.Fatal("partial focus update", current, err)
}
if _, err = s.DB.Exec(`ALTER TABLE organizer_focus_changes RENAME COLUMN unavailable_action TO action`); err != nil {
t.Fatal(err)
}
// Notification failure must leave a timer runnable for a later retry.
if _, err = s.DB.Exec(`ALTER TABLE notification_inbox RENAME COLUMN message TO unavailable_message`); err != nil {
t.Fatal(err)
}
if _, err = s.CompleteTaskFocus(ctx, now.Add(2*time.Minute), 100); err == nil {
t.Fatal("ignored Inbox failure")
}
if current, err := s.LatestTaskFocus(ctx, d, a); err != nil || current.State != "running" {
t.Fatal(current, err)
}
if _, err = s.DB.Exec(`ALTER TABLE notification_inbox RENAME COLUMN unavailable_message TO message`); err != nil {
t.Fatal(err)
}
type sweep struct {
n int
err error
}
results := make(chan sweep, 2)
for _, w := range writers {
go func(w *Store) { n, e := w.CompleteTaskFocus(ctx, now.Add(2*time.Minute), 100); results <- sweep{n, e} }(w)
}
total := 0
for i := 0; i < 2; i++ {
r := <-results
if r.err != nil {
t.Fatal(r.err)
}
total += r.n
}
if total != 1 {
t.Fatal(total)
}
notices, _, err := s.ListNotifications(ctx, d, a, true, "", 100)
if err != nil || len(notices) != 1 {
t.Fatal(notices, 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.TaskPreferences(ctx, d, a); !errors.Is(err, ErrAccessDenied) {
t.Fatal(err)
}
if _, err = s.TaskReport(ctx, d, a, now.Add(-time.Hour), now.Add(time.Hour), now); !errors.Is(err, ErrAccessDenied) {
t.Fatal(err)
}
}
func TestPostgreSQLInboxIdempotency(t *testing.T) {
s, d, a := productivityBackendFixture(t, storePostgreSQL)
type result struct {
id string
created bool
err error
}
results := make(chan result, 2)
for i := 0; i < 2; i++ {
go func() {
tx, err := s.DB.Begin()
if err != nil {
results <- result{err: err}
return
}
defer tx.Rollback()
n, new, err := s.CreateNotificationTx(tx, Notification{DomainUUID: d, RecipientUUID: a, EventUUID: "same-event", Kind: "synthetic", Message: "one"})
if err == nil {
err = tx.Commit()
}
results <- result{n.UUID, new, err}
}()
}
id := ""
created := 0
for i := 0; i < 2; i++ {
r := <-results
if r.err != nil {
t.Fatal(r.err)
}
if id != "" && id != r.id {
t.Fatal("duplicate identities")
}
id = r.id
if r.created {
created++
}
}
if created != 1 {
t.Fatal(created)
}
// Multiple rows exercise cursor parameter numbering and recipient scope.
for i := 0; i < 3; i++ {
tx, e := s.DB.Begin()
if e != nil {
t.Fatal(e)
}
_, _, e = s.CreateNotificationTx(tx, Notification{DomainUUID: d, RecipientUUID: a, EventUUID: fmt.Sprint(i), Kind: "synthetic", CreatedAtMS: int64(i + 1)})
if e == nil {
e = tx.Commit()
} else {
tx.Rollback()
}
if e != nil {
t.Fatal(e)
}
}
seen := map[string]bool{}
cursor := ""
for {
items, next, e := s.ListNotifications(context.Background(), d, a, false, cursor, 1)
if e != nil {
t.Fatal(e)
}
for _, n := range items {
if seen[n.UUID] {
t.Fatal("duplicate cursor row")
}
seen[n.UUID] = true
}
if next == "" {
break
}
cursor = next
}
if len(seen) != 4 {
t.Fatal(len(seen))
}
if _, err := s.GetNotification(context.Background(), d, "other", id); err == nil {
t.Fatal("cross-recipient read")
}
}
func TestTaskReminderDeliveryBackend(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, backend)
ctx := context.Background()
now := time.Now().UTC().Truncate(24 * time.Hour).Add(12 * time.Hour)
item := TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Private reminder", Status: "todo", Bucket: "inbox", DueOn: now.Format("2006-01-02"), NotifyDue: true, ReminderTime: "09:00"}
saved, err := s.SaveTask(ctx, d, a, item, 0)
if err != nil {
t.Fatal(err)
}
if _, err = s.DB.Exec(`ALTER TABLE notification_inbox RENAME COLUMN message TO unavailable_message`); err != nil {
t.Fatal(err)
}
if _, _, err = s.DeliverTaskReminders(ctx, now, 100); err == nil {
t.Fatal("ignored Inbox failure")
}
var state string
if err = s.DB.QueryRow(`SELECT state FROM organizer_reminders`).Scan(&state); err != nil || state != "pending" {
t.Fatal(state, err)
}
if _, err = s.DB.Exec(`ALTER TABLE notification_inbox RENAME COLUMN unavailable_message TO message`); err != nil {
t.Fatal(err)
}
n, sent, err := s.DeliverTaskReminders(ctx, now, 100)
if err != nil || n != 1 || sent != 1 {
t.Fatal(n, sent, err)
}
notices, _, err := s.ListNotifications(ctx, d, a, true, "", 100)
if err != nil || len(notices) != 1 || notices[0].Message == item.Title {
t.Fatal(notices, err)
}
if title, err := s.TaskReminderTitle(ctx, d, a, notices[0].EventUUID); err != nil || title != item.Title {
t.Fatal(title, err)
}
saved.Title = "Changed"
saved, err = s.SaveTask(ctx, d, a, saved, saved.Version)
if err != nil {
t.Fatal(err)
}
if n, sent, err = s.DeliverTaskReminders(ctx, now, 100); err != nil || n != 0 || sent != 0 {
t.Fatal("reminder resurrected", n, sent, err)
}
// The compact journal repair path must not duplicate direct outbox writes.
if n, published, err := s.PublishTaskActivity(ctx, 100); err != nil || n != 2 || published != 0 {
t.Fatal(n, published, err)
}
if n, _, err := s.PublishTaskActivity(ctx, 100); err != nil || n != 0 {
t.Fatal(n, err)
}
s.ReadOnly = true
if _, _, err = s.DeliverTaskReminders(ctx, now, 100); !errors.Is(err, ErrReadOnly) {
t.Fatal(err)
}
})
}
}