Files
pages/internal/server/task_productivity_test.go
T
Anya Tokugawa e65ca56f92
Build and publish container images / images (push) Successful in 12m27s
feat: add audited work records and controlled digest retries
2026-11-08 02:35:29 +09:00

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