package server import ( "context" "encoding/base64" "encoding/json" "strings" "testing" "time" "github.com/google/uuid" "pageswiki/internal/store" ) func TestTaskDigestSMTPContent(t *testing.T) { address, _, done := fakeSMTP(t, "", false) body := "やること\n- 私用タスク\n" if e := sendTaskDigestSMTP(context.Background(), store.AuthProviderConfig{SMTPAddress: address, SMTPFrom: "wiki@example.test"}, "reader@example.test", "2026-11-01", body); e != nil { t.Fatal(e) } result := <-done parts := strings.SplitN(strings.ReplaceAll(result.message, "\r\n", "\n"), "\n\n", 2) if len(parts) != 2 { t.Fatal("missing MIME body") } decoded, e := base64.StdEncoding.DecodeString(strings.Join(strings.Fields(parts[1]), "")) if e != nil || string(decoded) != body { t.Fatal("body encoding", e) } if !strings.Contains(parts[0], "Subject: PagesWiki tasks 2026-11-01") || strings.Contains(parts[0], "私用") { t.Fatal("wrong headers") } } func TestTaskReminderPreferencesAndCapture(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() existing, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Existing without reminders"), 0) if err != nil { t.Fatal(err) } w := taskRequest(s, token, "GET", "preferences", nil, "") var result struct { Preferences store.TaskPreferences `json:"preferences"` Defaults store.TaskRecord `json:"defaults"` } if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil { t.Fatal(err) } if result.Preferences.NotifyDue || result.Preferences.NotifyPlanned || result.Preferences.ReminderTime != "09:00" { t.Fatal("unexpected initial reminder preferences", result.Preferences) } p := result.Preferences p.NotifyDue, p.NotifyPlanned, p.ReminderTime = true, true, "10:35" w = taskRequest(s, token, "PUT", "preferences", p, "") if w.Code != 200 { t.Fatal(w.Code, w.Body) } if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil { t.Fatal(err) } p = result.Preferences for _, clock := range []string{"9:00", "24:00", "10:35:00", "garbage"} { bad := p bad.ReminderTime = clock if w = taskRequest(s, token, "PUT", "preferences", bad, ""); w.Code != 422 { t.Fatal("invalid clock accepted", clock, w.Code) } } for _, tc := range []struct { name string dates map[string]any due, planned bool }{ {"undated", map[string]any{}, false, false}, {"dated", map[string]any{"due_on": "2030-01-02", "planned_on": "2030-01-01"}, true, true}, {"cleared", map[string]any{"due_on": "", "planned_on": ""}, false, false}, } { input := tc.dates input["request_id"] = uuid.NewString() input["title"] = tc.name w = taskRequest(s, token, "POST", "capture", input, "") if w.Code != 201 { t.Fatal(tc.name, w.Code, w.Body) } var response struct { Item store.TaskRecord `json:"item"` } if err = json.Unmarshal(w.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Item.NotifyDue != tc.due || response.Item.NotifyPlanned != tc.planned || response.Item.ReminderTime != "10:35" { t.Fatal("wrong reminder defaults", response.Item) } if tc.due && response.Item.ReminderTimezone == "" { t.Fatal("missing server timezone") } } zero := 0 p.PlannedDays = &zero if w = taskRequest(s, token, "PUT", "preferences", p, ""); w.Code != 200 { t.Fatal(w.Code, w.Body) } w = taskRequest(s, token, "GET", "preferences", nil, "") if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil { t.Fatal(err) } if !result.Defaults.NotifyPlanned || result.Defaults.NotifyDue || result.Defaults.PlannedOn == "" { t.Fatal("dated defaults missing", result.Defaults) } loaded, err := s.store.GetTask(ctx, domain, actor, existing.UUID) if err != nil || loaded.Version != existing.Version || loaded.NotifyDue || loaded.NotifyPlanned { t.Fatal("existing task changed", loaded, err) } } func TestTaskCaptureDefaultsReplayAndPermissions(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() days := 2 p := store.TaskPreferences{AssigneeUUID: actor, DueDays: &days, Complexity: 3, Estimate: 60, Timezone: "Asia/Tokyo", DigestTime: "09:00"} p, err := s.store.SaveTaskPreferences(ctx, domain, actor, p, time.Now()) if err != nil { t.Fatal(err) } id := uuid.NewString() input := map[string]any{"request_id": id, "title": "Mail task", "notes": "Subject only"} w := taskRequest(s, token, "POST", "capture", input, "") if w.Code != 201 { t.Fatalf("capture %d %s", w.Code, w.Body) } var response struct { Item store.TaskRecord `json:"item"` } if err = json.Unmarshal(w.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Item.Complexity != 3 || response.Item.Estimate != 60 || response.Item.AssigneeUUID != actor || response.Item.DueOn == "" { t.Fatalf("defaults missing %+v", response.Item) } p.Estimate = 120 if _, err = s.store.SaveTaskPreferences(ctx, domain, actor, p, time.Now()); err != nil { t.Fatal(err) } if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 201 { t.Fatalf("retry %d %s", w.Code, w.Body) } loaded, err := s.store.GetTask(ctx, domain, actor, id) if err != nil || loaded.Estimate != 60 || loaded.Version != 1 { t.Fatal(loaded, err) } input["title"] = "Different" if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 412 { t.Fatalf("conflicting replay %d", w.Code) } input["request_id"] = uuid.NewString() input["due_on"] = "" if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 201 { t.Fatal(w.Code, w.Body) } if err = json.Unmarshal(w.Body.Bytes(), &response); err != nil || response.Item.DueOn != "" { t.Fatal("explicit clear lost", err) } if w = taskRequest(s, "", "POST", "capture", input, ""); w.Code == 201 { t.Fatal("anonymous capture") } if err = s.store.SetPrincipalState(domain, actor, "readonly"); err != nil { t.Fatal(err) } token, err = s.store.CreateAuthSession(domain, actor) if err != nil { t.Fatal(err) } if w = taskRequest(s, token, "POST", "capture", input, ""); w.Code != 403 { t.Fatal("readonly capture", w.Code) } } func TestTaskWorkReportSplitsMidnightAndCompletion(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() item := newTaskRecord("task", "Tracked task") item.Estimate = 60 item.Complexity = 3 item, err := s.store.SaveTask(ctx, domain, actor, item, 0) if err != nil { t.Fatal(err) } loc, _ := time.LoadLocation("Asia/Tokyo") start := time.Date(2026, 11, 1, 23, 30, 0, 0, loc) end := start.Add(90 * time.Minute) v, err := s.store.ChangeTaskWork(ctx, domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: item.UUID}, start) if err != nil { t.Fatal(err) } if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: item.UUID}, start); err != store.ErrTaskConflict { t.Fatal("second active timer", err) } v, err = s.store.ChangeTaskWork(ctx, domain, actor, "stop", v, end) if err != nil { t.Fatal(err) } if again, e := s.store.ChangeTaskWork(ctx, domain, actor, "stop", v, end.Add(time.Hour)); e != nil || again.EndMS != v.EndMS { t.Fatal("stop replay changed duration", e) } a := time.Date(2026, 11, 1, 0, 0, 0, 0, loc) report, err := s.store.TaskReport(ctx, domain, actor, a, a.AddDate(0, 0, 2), end) if err != nil { t.Fatal(err) } if len(report.Tasks) != 1 || report.Tasks[0].WorkMS != 90*60000 || report.Days[0].WorkMS != 30*60000 || report.Days[1].WorkMS != 60*60000 { t.Fatalf("wrong split %+v", report) } item.Status = "done" item, err = s.store.SaveTask(ctx, domain, actor, item, item.Version) if err != nil { t.Fatal(err) } now := time.Now().In(loc) day := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, loc) report, err = s.store.TaskReport(ctx, domain, actor, day, day.AddDate(0, 0, 1), now) if err != nil || report.Days[0].Points != 7 || report.Days[0].Completed != 1 { t.Fatal("points", report, err) } item.Status = "todo" if _, err = s.store.SaveTask(ctx, domain, actor, item, item.Version); err != nil { t.Fatal(err) } report, err = s.store.TaskReport(ctx, domain, actor, day, day.AddDate(0, 0, 1), now) if err != nil || report.Days[0].Points != 0 { t.Fatal("reopen did not retract", err) } } func TestTaskDigestClaimOnceAndOptOut(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() now := time.Date(2026, 11, 1, 8, 0, 0, 0, time.UTC) p := store.TaskPreferences{Complexity: 1, DigestEnabled: true, DigestTime: "09:00", Timezone: "UTC"} p, err := s.store.SaveTaskPreferences(ctx, domain, actor, p, now) if err != nil { t.Fatal(err) } if rows, e := s.store.DueTaskDigests(ctx, now); e != nil || len(rows) != 0 { t.Fatal(rows, e) } now = now.Add(2 * time.Hour) due, err := s.store.DueTaskDigests(ctx, now) if err != nil || len(due) != 1 { t.Fatal(due, err) } claim, err := s.store.ClaimTaskDigest(ctx, due[0], now) if err != nil { t.Fatal(err) } if _, e := s.store.ClaimTaskDigest(ctx, due[0], now); e == nil { t.Fatal("double claim") } if err = s.store.FinishTaskDigest(ctx, claim, "sent"); err != nil { t.Fatal(err) } p.DigestEnabled = false if _, err = s.store.SaveTaskPreferences(ctx, domain, actor, p, now); err != nil { t.Fatal(err) } if _, err = s.store.TaskDigestRecipient(ctx, claim); err == nil { t.Fatal("opt-out not enforced") } }