458 lines
15 KiB
Go
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)
|
|
}
|
|
})
|
|
}
|
|
}
|