Files
pages/internal/server/task_reminders_test.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

299 lines
9.3 KiB
Go

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