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