Add task capture, work reports, daily digests and private contacts
Build and publish container images / images (push) Successful in 16m37s

This commit is contained in:
Anya Tokugawa committed 2026-11-01 22:28:16 +09:00
1 parent 50b8b0323f
commit b4792bb175
50 files changed
+2678 -17

No files matched your search

+187
View File
@@ -0,0 +1,187 @@
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 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")
}
}