package server import ( "context" "encoding/json" "errors" "net/http" "net/http/httptest" "net/url" "os" "os/exec" "strings" "sync" "testing" "time" "github.com/google/uuid" "pageswiki/internal/store" ) func recordedWork(t *testing.T, s *Server, domain, actor, task string, start time.Time) store.TaskWork { t.Helper() v, err := s.store.ChangeTaskWork(context.Background(), domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: task, CancelledMS: 99}, start) if err != nil || v.CancelledMS != 0 { t.Fatal(v, err) } v, err = s.store.ChangeTaskWork(context.Background(), domain, actor, "stop", v, start.Add(time.Hour)) if err != nil { t.Fatal(err) } return v } func TestWorkHistoryCorrectionCancellationAndReports(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() project, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("project", "Project A"), 0) if err != nil { t.Fatal(err) } item := newTaskRecord("task", "Audited work") item.ProjectUUID = project.UUID item, err = s.store.SaveTask(ctx, domain, actor, item, 0) if err != nil { t.Fatal(err) } start := time.Date(2026, 1, 2, 12, 0, 0, 0, time.UTC) first := recordedWork(t, s, domain, actor, item.UUID, start) second := recordedWork(t, s, domain, actor, item.UUID, start.Add(2*time.Hour)) post := func(v store.TaskWork, action, reason string) int { return taskRequest(s, token, "POST", "work", map[string]any{"uuid": v.UUID, "task_uuid": v.TaskUUID, "version": v.Version, "action": action, "reason": reason, "start_ms": v.StartMS, "end_ms": v.EndMS}, "").Code } if got := post(first, "correct", ""); got != 422 { t.Fatal("missing reason", got) } bad := first bad.EndMS = second.EndMS if got := post(bad, "correct", "overlap"); got != 412 { t.Fatal("overlap", got) } bad = first bad.EndMS = bad.StartMS if got := post(bad, "correct", "empty"); got != 422 { t.Fatal("empty interval", got) } first.EndMS = start.Add(2 * time.Hour).UnixMilli() // adjacency is valid if got := post(first, "correct", "Finished later"); got != 200 { t.Fatal("correct", got) } if got := post(first, "correct", "stale mutation"); got != 412 { t.Fatal("stale version", got) } first.Version++ report, err := s.store.TaskReport(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), time.Now()) if err != nil || len(report.Projects) != 1 || report.Projects[0].Title != "Project A" || report.Projects[0].WorkMS != 3*3600000 { t.Fatal(report, err) } if got := post(first, "cancel", "Duplicate recording"); got != 200 { t.Fatal("cancel", got) } report, err = s.store.TaskReport(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), time.Now()) if err != nil || report.Projects[0].WorkMS != 3600000 { t.Fatal("cancelled counted", report, err) } audit, err := s.store.TaskWorkRevisions(ctx, domain, actor, first.UUID, 0) if err != nil || len(audit) != 4 || audit[0].Action != "cancel" || audit[1].Action != "correct" || audit[2].Action != "stop" || audit[3].Action != "start" || audit[2].Item.EndMS != start.Add(time.Hour).UnixMilli() { t.Fatal(audit, err) } page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), "", 1) if err != nil || len(page.Items) != 1 || page.Items[0].UUID != second.UUID || page.Next == "" { t.Fatal(page, err) } page, err = s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), page.Next, 1) if err != nil || len(page.Items) != 1 || page.Items[0].UUID != first.UUID || page.Items[0].CancelledMS == 0 || page.Next != "" { t.Fatal(page, err) } for _, query := range []string{"limit=101", "after=bad", "from=2026-01-02&to=2026-01-01", "from=2020-01-01&to=2026-01-01"} { if w := taskRequest(s, token, "GET", "work-history?"+query, nil, ""); w.Code != 422 { t.Fatal(query, w.Code, w.Body) } } if w := taskRequest(s, token, "GET", "work-history/"+first.UUID+"?before=3", nil, ""); w.Code != 200 { t.Fatal(w.Code, w.Body) } if w := taskRequest(s, token, "POST", "work-history", nil, ""); w.Code != 405 { t.Fatal(w.Code, w.Body) } stranger, err := s.store.CreatePasswordAccount(domain, "history-stranger", "a long test password", "Stranger", "") if err != nil { t.Fatal(err) } strangerToken, err := s.store.CreateAuthSession(domain, stranger.UUID) if err != nil { t.Fatal(err) } if w := taskRequest(s, strangerToken, "GET", "work-history/"+first.UUID, nil, ""); w.Code != 404 { t.Fatal("history leaked", w.Code, w.Body) } if w := taskRequest(s, strangerToken, "GET", "work-history?from=2026-01-01&to=2026-01-04", nil, ""); w.Code != 200 || !strings.Contains(w.Body.String(), `"items":[]`) { t.Fatal("list leaked", w.Code, w.Body) } 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 got := post(second, "cancel", "No permission"); got != 403 { t.Fatal("readonly mutation", got) } if err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil { t.Fatal(err) } if w := taskRequest(s, token, "GET", "work-history", nil, ""); w.Code != 404 { t.Fatal("disabled extension", w.Code) } } func TestWorkInstantTimezone(t *testing.T) { for _, tc := range []struct { zone, input string valid bool }{{"Asia/Tokyo", "2026-01-02T12:30", true}, {"America/New_York", "2026-03-08T02:30", false}, {"America/New_York", "2026-11-01T01:30", false}, {"America/New_York", "2026-11-01T01:30:00-04:00", true}, {"Australia/Lord_Howe", "2026-04-05T01:45", false}, {"UTC", "bad", false}} { loc, err := time.LoadLocation(tc.zone) if err != nil { t.Fatal(err) } _, err = parseWorkInstant(tc.input, loc) if (err == nil) != tc.valid { t.Fatal(tc, err) } } } func TestWorkHistoryFencingAndAtomicAudit(t *testing.T) { s, _, domain, actor := taskFixture(t) ctx := context.Background() item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Fenced work"), 0) if err != nil { t.Fatal(err) } start := time.Now().Add(-10 * time.Hour) v := recordedWork(t, s, domain, actor, item.UUID, start) // Simulate a pre-upgrade session: capture its old value, never invent older versions. if _, err = s.store.DB.Exec(`DELETE FROM organizer_work_revisions WHERE work_uuid=?`, v.UUID); err != nil { t.Fatal(err) } if _, err = s.store.DB.Exec(`CREATE TRIGGER fail_work_audit BEFORE INSERT ON organizer_work_revisions WHEN NEW.action='correct' BEGIN SELECT RAISE(ABORT,'test audit unavailable'); END`); err != nil { t.Fatal(err) } edit := v edit.EndMS += 60000 if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "must rollback"); err == nil { t.Fatal("audit failure accepted") } var version int64 if err = s.store.DB.QueryRow(`SELECT version FROM organizer_work_sessions WHERE uuid=?`, v.UUID).Scan(&version); err != nil || version != 2 { t.Fatal("partial mutation", version, err) } if _, err = s.store.DB.Exec(`DROP TRIGGER fail_work_audit`); err != nil { t.Fatal(err) } // Two concurrent corrections must not overwrite one another. var wg sync.WaitGroup results := make(chan error, 2) for range 2 { wg.Add(1) go func() { defer wg.Done() _, e := s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "racing correction") results <- e }() } wg.Wait() close(results) wins, conflicts := 0, 0 for err := range results { if err == nil { wins++ } else if errors.Is(err, store.ErrTaskConflict) { conflicts++ } else { t.Fatal(err) } } if wins != 1 || conflicts != 1 { t.Fatal(wins, conflicts) } history, err := s.store.TaskWorkRevisions(ctx, domain, actor, v.UUID, 0) if err != nil || len(history) != 2 || history[1].Action != "baseline" || history[1].Item.EndMS != v.EndMS { t.Fatal(history, err) } // Cross-Domain intervals belong to the same person, but never appear in this list. d, err := s.store.GetDomainByUUID(domain) if err != nil { t.Fatal(err) } if err = s.store.CreateDomain(d.CampusUUID, "work-other", "Other", "work-other", "local", "", "", true); err != nil { t.Fatal(err) } domains, err := s.store.ListDomains() if err != nil { t.Fatal(err) } other := "" for _, d := range domains { if d.Name == "work-other" { other = d.UUID } } if other == "" { t.Fatal("missing domain") } if _, err = s.store.DB.Exec(`INSERT OR IGNORE INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,'active',0)`, uuid.NewString(), other, actor); err != nil { t.Fatal(err) } otherTask, err := s.store.SaveTask(ctx, other, actor, newTaskRecord("task", "Private other work"), 0) if err != nil { t.Fatal(err) } foreign := recordedWork(t, s, other, actor, otherTask.UUID, start.Add(2*time.Hour)) edit = history[0].Item edit.EndMS = foreign.EndMS if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "overlaps other domain"); !errors.Is(err, store.ErrTaskConflict) { t.Fatal(err) } if _, err = s.store.TaskWorkRevisions(ctx, domain, actor, foreign.UUID, 0); err == nil { t.Fatal("cross-domain audit leaked") } page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), time.Now(), "", 50) if err != nil || len(page.Items) != 1 { t.Fatal(page, err) } active, err := s.store.ChangeTaskWork(ctx, domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: item.UUID}, start.Add(5*time.Hour)) if err != nil { t.Fatal(err) } for _, action := range []string{"correct", "cancel"} { if _, err = s.store.ChangeTaskWork(ctx, domain, actor, action, active, time.Now(), "active recording"); !errors.Is(err, store.ErrTaskConflict) { t.Fatal(action, err) } } if _, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil { t.Fatal(err) } if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "cancel", history[0].Item, time.Now(), "revoked"); !errors.Is(err, store.ErrAccessDenied) { t.Fatal("revocation not fenced", err) } } func TestWorkHistoryChromium(t *testing.T) { if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" { t.Skip("opt-in Chromium") } s, token, domain, actor := taskFixture(t) s.store.BackgroundJobsDisabled = true s = New(s.store) item, err := s.store.SaveTask(context.Background(), domain, actor, newTaskRecord("task", "Browser work record"), 0) if err != nil { t.Fatal(err) } v := recordedWork(t, s, domain, actor, item.UUID, time.Now().Add(-3*time.Hour)) script, err := os.ReadFile("internal/server/testdata/task-work-history.js") if err != nil { t.Fatal(err) } handler := s.handler() server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { r.Host = "localhost" r.Header.Set("Authorization", "Bearer "+token) if r.URL.Path == "/fixture" { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte("
")) return } handler.ServeHTTP(w, r) })) defer server.Close() ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second) defer cancel() width := os.Getenv("WORK_HISTORY_WIDTH") if width == "" { width = "1440" } args := []string{"internal/server/testdata/vim-browser-smoke.mjs", server.URL + "/fixture", t.TempDir(), os.Getenv("WORK_HISTORY_SCREENSHOT"), width, "850"} if out, err := exec.CommandContext(ctx, "node", args...).CombinedOutput(); err != nil { t.Fatalf("browser: %v\n%s", err, out) } history, err := s.store.TaskWorkRevisions(context.Background(), domain, actor, v.UUID, 0) if err != nil || len(history) != 4 || history[0].Action != "cancel" || history[1].Action != "correct" { t.Fatal(history, err) } } func TestWorkHistoryLocalTimestampAPI(t *testing.T) { s, token, domain, actor := taskFixture(t) ctx := context.Background() item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Timestamp"), 0) if err != nil { t.Fatal(err) } start := time.Date(2026, 1, 2, 12, 0, 0, 123000000, time.UTC) v := recordedWork(t, s, domain, actor, item.UUID, start) input := map[string]any{"uuid": v.UUID, "version": v.Version, "action": "correct", "reason": "API timestamp", "start": start.Format(time.RFC3339Nano), "end": start.Add(90 * time.Minute).Format(time.RFC3339Nano)} w := taskRequest(s, token, "POST", "work", input, "") if w.Code != 200 { t.Fatal(w.Code, w.Body) } var result struct { Item store.TaskWork `json:"item"` } if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil { t.Fatal(err) } page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(3*time.Hour), "", 50) if err != nil || page.Items[0].StartMS != start.UnixMilli() { t.Fatal(page, err) } if w = taskRequest(s, token, "GET", "work-history?"+url.Values{"from": {"2026-01-02"}, "to": {"2026-01-03"}}.Encode(), nil, ""); w.Code != 200 { t.Fatal(w.Code, w.Body) } }