344 lines
13 KiB
Go
344 lines
13 KiB
Go
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("<!doctype html><body style='margin:0'><script>" + string(script) + "</script></body>"))
|
|
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)
|
|
}
|
|
}
|