feat: add audited work records and controlled digest retries
Build and publish container images / images (push) Successful in 12m27s

This commit is contained in:
Anya Tokugawa committed 2026-11-08 02:35:29 +09:00
1 parent 6e0aecdfb3
commit e65ca56f92
33 files changed
+2262 -114

No files matched your search

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