273 lines
9.4 KiB
Go
273 lines
9.4 KiB
Go
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)
|
|
}
|
|
if len(report.Projects) != 1 || report.Projects[0].UUID != "" || report.Projects[0].Points != 7 || report.Projects[0].Completed != 1 {
|
|
t.Fatal("unassigned project totals", report.Projects)
|
|
}
|
|
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")
|
|
}
|
|
}
|