package server import ( "context" "encoding/json" "errors" "strings" "sync" "testing" "time" "pageswiki/internal/store" ) func reminderTime(t *testing.T, v string) time.Time { t.Helper() at, e := time.Parse(time.RFC3339, v) if e != nil { t.Fatal(e) } return at } func reminderTask() store.TaskRecord { i := newTaskRecord("task", "Private reminder title") i.DueOn = "2030-05-01" i.PlannedOn = i.DueOn i.NotifyDue = true i.ReminderTime = "09:00" return i } func TestTaskReminderDeliveryTimezoneDedupAndInboxProjection(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() if err := s.store.SetConfigInDomain(domain, "timezone", "Asia/Tokyo"); err != nil { t.Fatal(err) } i := reminderTask() i.NotifyPlanned = true i.ReminderTimezone = "America/New_York" i, err := s.store.SaveTask(ctx, domain, actor, i, 0) if err != nil { t.Fatal(err) } if i.ReminderTimezone != "Asia/Tokyo" { t.Fatal("trusted supplied timezone", i.ReminderTimezone) } before := reminderTime(t, "2030-04-30T23:59:59Z") fire := before.Add(time.Second) if n, sent, e := s.store.DeliverTaskReminders(ctx, before, 100); e != nil || n != 0 || sent != 0 { t.Fatal(n, sent, e) } if n, sent, e := s.store.DeliverTaskReminders(ctx, fire, 1); e != nil || n != 1 || sent != 1 { t.Fatal(n, sent, e) } if n, sent, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || n != 1 || sent != 1 { t.Fatal(n, sent, e) } if n, sent, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || n != 0 || sent != 0 { t.Fatal(n, sent, e) } notices, _, err := s.store.ListNotifications(ctx, domain, actor, false, "", 100) if err != nil || len(notices) != 2 { t.Fatal(notices, err) } for _, n := range notices { if strings.Contains(n.Message, "Private") { t.Fatal("title copied to inbox") } } s.mux.HandleFunc("/_/api/v1/notifications", s.handleNotificationsAPI) w := configRequest(s, token, "GET", "/_/api/v1/notifications", nil) if w.Code != 200 || !strings.Contains(w.Body.String(), "Private reminder title") || !strings.Contains(w.Body.String(), "タスクの期限通知") { t.Fatalf("projection %d %s", w.Code, w.Body) } i.Title = "New current title" i, err = s.store.SaveTask(ctx, domain, actor, i, i.Version) if err != nil { t.Fatal(err) } if _, sent, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || sent != 0 { t.Fatal("edit redelivered", sent, e) } w = configRequest(s, token, "GET", "/_/api/v1/notifications", nil) if !strings.Contains(w.Body.String(), "New current title") || strings.Contains(w.Body.String(), "Private reminder title") { t.Fatal(w.Body) } i.Status = "done" i, err = s.store.SaveTask(ctx, domain, actor, i, i.Version) if err != nil { t.Fatal(err) } w = configRequest(s, token, "GET", "/_/api/v1/notifications", nil) if strings.Contains(w.Body.String(), "New current title") || strings.Contains(w.Body.String(), "/v/plan/task/") { t.Fatal("stale notification disclosed task", w.Body) } i.Status = "todo" if _, err = s.store.SaveTask(ctx, domain, actor, i, i.Version); err != nil { t.Fatal(err) } if _, sent, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || sent != 0 { t.Fatal("reopen redelivered same occurrence", sent, e) } } func TestTaskRemindersRescheduleCancelSkipAndRevoke(t *testing.T) { for _, scenario := range []string{"reschedule", "off", "done", "cancelled", "archive", "disabled", "revoked", "expired", "stale-version"} { t.Run(scenario, func(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() i, err := s.store.SaveTask(ctx, domain, actor, reminderTask(), 0) if err != nil { t.Fatal(err) } fire := reminderTime(t, "2030-05-01T09:00:00Z") save := true switch scenario { case "reschedule": i.DueOn = "2030-05-02" case "off": i.NotifyDue = false case "done", "cancelled": i.Status = scenario case "archive": i.Archived = true case "disabled": save = false err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`) case "revoked": save = false _, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor) case "expired": save = false fire = fire.Add(24 * time.Hour) case "stale-version": save = false _, err = s.store.DB.Exec(`UPDATE organizer_reminders SET source_version=0`) } if err != nil { t.Fatal(err) } if save { if _, err = s.store.SaveTask(ctx, domain, actor, i, i.Version); err != nil { t.Fatal(err) } } if _, sent, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || sent != 0 { t.Fatal(scenario, sent, e) } if scenario == "reschedule" { if _, sent, e := s.store.DeliverTaskReminders(ctx, fire.Add(24*time.Hour), 100); e != nil || sent != 1 { t.Fatal("new date", sent, e) } } }) } } func TestTaskRemindersAtomicFailureParallelDeliveryAndOptIn(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() i := reminderTask() i.NotifyDue = false i, err := s.store.SaveTask(ctx, domain, actor, i, 0) if err != nil { t.Fatal(err) } fire := reminderTime(t, "2030-05-01T09:00:00Z") if n, _, e := s.store.DeliverTaskReminders(ctx, fire, 100); e != nil || n != 0 { t.Fatal("implicit opt in", n, e) } i.NotifyDue = true if _, err = s.store.DB.Exec(`CREATE TRIGGER reject_reservation BEFORE INSERT ON organizer_reminders BEGIN SELECT RAISE(ABORT,'test reservation failure'); END`); err != nil { t.Fatal(err) } if _, err = s.store.SaveTask(ctx, domain, actor, i, i.Version); err == nil { t.Fatal("partial save") } got, err := s.store.GetTask(ctx, domain, actor, i.UUID) if err != nil || got.Version != 1 || got.NotifyDue { t.Fatal(got, err) } if _, err = s.store.DB.Exec(`DROP TRIGGER reject_reservation`); err != nil { t.Fatal(err) } i, err = s.store.SaveTask(ctx, domain, actor, i, i.Version) if err != nil { t.Fatal(err) } if _, err = s.store.DB.Exec(`CREATE TRIGGER reject_reminder_inbox BEFORE INSERT ON notification_inbox BEGIN SELECT RAISE(ABORT,'test delivery failure'); END`); err != nil { t.Fatal(err) } if _, _, err = s.store.DeliverTaskReminders(ctx, fire, 100); err == nil { t.Fatal("delivery failure ignored") } var state string if err = s.store.DB.QueryRow(`SELECT state FROM organizer_reminders`).Scan(&state); err != nil || state != "pending" { t.Fatal(state, err) } if _, err = s.store.DB.Exec(`DROP TRIGGER reject_reminder_inbox`); err != nil { t.Fatal(err) } start := make(chan struct{}) results := make(chan error, 2) var wg sync.WaitGroup for j := 0; j < 2; j++ { wg.Add(1) go func() { defer wg.Done() <-start _, _, e := s.store.DeliverTaskReminders(ctx, fire, 100) results <- e }() } close(start) wg.Wait() close(results) for e := range results { if e != nil { t.Fatal(e) } } notices, _, err := s.store.ListNotifications(ctx, domain, actor, false, "", 100) if err != nil || len(notices) != 1 { t.Fatal(notices, err) } other, err := s.store.CreatePasswordAccount(domain, "reminder-other", "long other password", "Other", "") if err != nil { t.Fatal(err) } if _, err = s.store.TaskReminderTitle(ctx, domain, other.UUID, notices[0].EventUUID); err == nil { t.Fatal("cross-owner metadata leak") } } func TestTaskReminderDSTAndValidation(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() if err := s.store.SetConfigInDomain(domain, "timezone", "America/New_York"); err != nil { t.Fatal(err) } i := reminderTask() i.DueOn = "2030-03-10" i.ReminderTime = "02:30" if _, err := s.store.SaveTask(ctx, domain, actor, i, 0); !errors.Is(err, store.ErrTaskInvalid) { t.Fatal("nonexistent local time accepted", err) } i.ReminderTime = "09:00" i, err := s.store.SaveTask(ctx, domain, actor, i, 0) if err != nil { t.Fatal(err) } var fire int64 if err = s.store.DB.QueryRow(`SELECT fire_at_ms FROM organizer_reminders`).Scan(&fire); err != nil { t.Fatal(err) } if fire != reminderTime(t, "2030-03-10T13:00:00Z").UnixMilli() { t.Fatal("DST offset", fire) } for _, clock := range []string{"9:00", "25:00", "09:00:30"} { i.ReminderTime = clock if _, err = s.store.SaveTask(ctx, domain, actor, i, i.Version); !errors.Is(err, store.ErrTaskInvalid) { t.Fatal(clock, err) } } i.ReminderTime = "09:00" i.DueOn = "" if _, err = s.store.SaveTask(ctx, domain, actor, i, i.Version); !errors.Is(err, store.ErrTaskInvalid) { t.Fatal("missing date", err) } // Added optional fields preserve legacy JSON create-retry comparisons. legacy := newTaskRecord("task", "Legacy") if _, err = s.store.SaveTask(ctx, domain, actor, legacy, 0); err != nil { t.Fatal(err) } if _, err = s.store.SaveTask(ctx, domain, actor, legacy, 0); err != nil { t.Fatal("legacy retry", err) } if err = s.store.EnsureTaskReminderEvent(); err != nil { t.Fatal(err) } if _, err = s.store.DB.Exec(`UPDATE event_definitions SET enabled=0,interval_seconds=300 WHERE uuid='builtin.task.reminders'`); err != nil { t.Fatal(err) } if err = s.store.EnsureTaskReminderEvent(); err != nil { t.Fatal(err) } defs, err := s.store.ListEventDefinitions() if err != nil { t.Fatal(err) } for _, d := range defs { if d.UUID == "builtin.task.reminders" && (d.Enabled || d.IntervalSeconds != 300) { b, _ := json.Marshal(d) t.Fatal(string(b)) } } }