feat: add audited work records and controlled digest retries
Build and publish container images / images (push) Successful in 12m27s
Build and publish container images / images (push) Successful in 12m27s
This commit is contained in:
1 parent
6e0aecdfb3
commit
e65ca56f92
33 files changed
+2262
-114
No files matched your search
@@ -108,6 +108,8 @@ func organizerSection(path string) string {
|
||||
}
|
||||
|
||||
func init() {
|
||||
translations["en"]["task.work_history"] = "Work history"
|
||||
translations["ja"]["task.work_history"] = "作業記録"
|
||||
for lang, entries := range map[string]map[string]string{
|
||||
"en": {"organizer.title": "Organizer", "organizer.dashboard": "Dashboard", "organizer.settings": "Personal settings", "organizer.contacts": "Contacts", "organizer.private": "Preferences apply only to you in this Domain. System administration is separate.", "organizer.calendar_defaults": "Default calendars", "organizer.open": "Open"},
|
||||
"ja": {"organizer.title": "オーガナイザー", "organizer.dashboard": "ダッシュボード", "organizer.settings": "個人設定", "organizer.contacts": "連絡先", "organizer.private": "このドメイン内の自分だけに適用する設定です。システムの管理設定とは別です。", "organizer.calendar_defaults": "既定のカレンダー", "organizer.open": "開く"},
|
||||
|
||||
@@ -38,67 +38,110 @@ func sendTaskDigestSMTP(ctx context.Context, config store.AuthProviderConfig, re
|
||||
func (s *Server) deliverTaskDigests(ctx context.Context, job *store.EventJob) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
if _, err := s.store.MaintainTaskDigests(ctx, time.Now()); err != nil {
|
||||
return err
|
||||
}
|
||||
queued, err := s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
due, err := s.store.DueTaskDigests(ctx, time.Now())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sent, uncertain := 0, 0
|
||||
for _, candidate := range due {
|
||||
sent, uncertain, checked := 0, 0, 0
|
||||
deliver := func(claim store.TaskDigestClaim) error {
|
||||
state, reason := s.deliverTaskDigest(ctx, claim)
|
||||
if state == "sent" {
|
||||
sent++
|
||||
}
|
||||
if state == "uncertain" {
|
||||
uncertain++
|
||||
}
|
||||
checked++
|
||||
finish, stop := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
defer stop()
|
||||
err := s.store.FinishTaskDigestReason(finish, claim, state, reason, time.Now())
|
||||
// A reclaimed generation cannot complete a newer attempt.
|
||||
if errors.Is(err, store.ErrTaskConflict) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
// Alternate automatic delivery and manual retries within the shared time
|
||||
// budget, so a retry backlog cannot monopolize scheduled deliveries.
|
||||
for i := 0; i < max(len(due), len(queued)); i++ {
|
||||
for _, manual := range []bool{false, true} {
|
||||
if ctx.Err() != nil {
|
||||
break
|
||||
}
|
||||
var claim store.TaskDigestClaim
|
||||
var e error
|
||||
if manual {
|
||||
if i >= len(queued) {
|
||||
continue
|
||||
}
|
||||
claim, e = s.store.ClaimQueuedTaskDigest(ctx, queued[i], time.Now())
|
||||
} else {
|
||||
if i >= len(due) {
|
||||
continue
|
||||
}
|
||||
claim, e = s.store.ClaimTaskDigest(ctx, due[i], time.Now())
|
||||
}
|
||||
if errors.Is(e, sql.ErrNoRows) {
|
||||
continue
|
||||
}
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if e = deliver(claim); e != nil {
|
||||
return e
|
||||
}
|
||||
}
|
||||
if ctx.Err() != nil {
|
||||
break
|
||||
}
|
||||
claim, e := s.store.ClaimTaskDigest(ctx, candidate, time.Now())
|
||||
if errors.Is(e, sql.ErrNoRows) {
|
||||
continue
|
||||
}
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
state := "cancelled"
|
||||
if s.systemExtensionEnabled(claim.Domain, "organizer.tasks") {
|
||||
config, e := s.store.AuthProviderConfig(claim.Domain, "smtp")
|
||||
if e == nil && config.Enabled {
|
||||
items, next, e := s.store.ListTasks(ctx, claim.Domain, claim.Owner, store.TaskQuery{Kind: "task", View: "today", Today: claim.Day, Limit: 100})
|
||||
if e == nil {
|
||||
var body strings.Builder
|
||||
host, _ := s.store.GetDomainEffectiveHost(claim.Domain)
|
||||
base := ""
|
||||
if host != "" && !strings.ContainsAny(host, "/\\\r\n\t @") {
|
||||
base = "https://" + host
|
||||
}
|
||||
fmt.Fprintf(&body, "Tasks / やることリスト — %s (%s)\n\n", claim.Day, claim.Timezone)
|
||||
if len(items) == 0 {
|
||||
body.WriteString("No tasks due or planned today. / 今日の対象タスクはありません。\n")
|
||||
}
|
||||
for _, item := range items {
|
||||
fmt.Fprintf(&body, "- %s\n due/期限: %s | planned/予定: %s | estimate/見積: %d min\n %s/v/plan/task/%s\n", item.Title, item.DueOn, item.PlannedOn, item.Estimate, base, item.UUID)
|
||||
}
|
||||
if next != "" {
|
||||
body.WriteString("\nFirst 100 items only. / 最初の100件です。続きはタスク画面で確認してください。\n")
|
||||
}
|
||||
// Check consent and current account email immediately before send.
|
||||
if recipient, e := s.store.TaskDigestRecipient(ctx, claim); e == nil {
|
||||
state = "uncertain"
|
||||
if e = sendTaskDigestSMTP(ctx, config, recipient, claim.Day, body.String()); e == nil {
|
||||
state = "sent"
|
||||
sent++
|
||||
} else {
|
||||
uncertain++
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Persist delivery outcome even if the scheduler context was cancelled.
|
||||
finish, stop := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
e = s.store.FinishTaskDigest(finish, claim, state)
|
||||
stop()
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
}
|
||||
if len(due) > 0 {
|
||||
s.addEventProgressLog(ctx, job, fmt.Sprintf("task digest checked=%d sent=%d uncertain=%d", len(due), sent, uncertain))
|
||||
if checked > 0 {
|
||||
s.addEventProgressLog(ctx, job, fmt.Sprintf("task digest checked=%d sent=%d uncertain=%d", checked, sent, uncertain))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Server) deliverTaskDigest(ctx context.Context, claim store.TaskDigestClaim) (string, string) {
|
||||
if !s.systemExtensionEnabled(claim.Domain, "organizer.tasks") {
|
||||
return "cancelled", "extension_disabled"
|
||||
}
|
||||
config, err := s.store.AuthProviderConfig(claim.Domain, "smtp")
|
||||
if err != nil || !config.Enabled {
|
||||
return "cancelled", "smtp_unavailable"
|
||||
}
|
||||
items, next, err := s.store.ListTasks(ctx, claim.Domain, claim.Owner, store.TaskQuery{Kind: "task", View: "today", Today: claim.Day, Limit: 100})
|
||||
if err != nil {
|
||||
return "cancelled", "tasks_unavailable"
|
||||
}
|
||||
var body strings.Builder
|
||||
host, _ := s.store.GetDomainEffectiveHost(claim.Domain)
|
||||
base := ""
|
||||
if host != "" && !strings.ContainsAny(host, "/\\\r\n\t @") {
|
||||
base = "https://" + host
|
||||
}
|
||||
fmt.Fprintf(&body, "Tasks / やることリスト — %s (%s)\n\n", claim.Day, claim.Timezone)
|
||||
if len(items) == 0 {
|
||||
body.WriteString("No tasks due or planned today. / 今日の対象タスクはありません。\n")
|
||||
}
|
||||
for _, item := range items {
|
||||
fmt.Fprintf(&body, "- %s\n due/期限: %s | planned/予定: %s | estimate/見積: %d min\n %s/v/plan/task/%s\n", item.Title, item.DueOn, item.PlannedOn, item.Estimate, base, item.UUID)
|
||||
}
|
||||
if next != "" {
|
||||
body.WriteString("\nFirst 100 items only. / 最初の100件です。続きはタスク画面で確認してください。\n")
|
||||
}
|
||||
recipient, err := s.store.TaskDigestRecipient(ctx, claim)
|
||||
if err != nil {
|
||||
return "cancelled", "consent_changed"
|
||||
}
|
||||
if err = sendTaskDigestSMTP(ctx, config, recipient, claim.Day, body.String()); err != nil {
|
||||
return "uncertain", "transport_uncertain"
|
||||
}
|
||||
return "sent", ""
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
func (s *Server) handleTaskDigestHistory(w http.ResponseWriter, r *http.Request, actor string, active bool, parts []string) {
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
if len(parts) == 1 && r.Method == "GET" {
|
||||
limit := 50
|
||||
if raw := r.URL.Query().Get("limit"); raw != "" {
|
||||
v, e := strconv.Atoi(raw)
|
||||
if e != nil {
|
||||
taskError(w, store.ErrTaskInvalid)
|
||||
return
|
||||
}
|
||||
limit = v
|
||||
}
|
||||
result, err := s.store.TaskDigestHistory(r.Context(), domain, actor, r.URL.Query().Get("after"), limit, time.Now())
|
||||
if err != nil {
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
writeEventJSON(w, 200, result)
|
||||
return
|
||||
}
|
||||
if len(parts) == 2 && parts[1] == "retry" && r.Method == "POST" {
|
||||
if !active {
|
||||
taskError(w, store.ErrAccessDenied)
|
||||
return
|
||||
}
|
||||
var input store.TaskDigestRetry
|
||||
if !taskJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
if id, err := s.store.TaskDigestRetryReceipt(r.Context(), domain, actor, input); err == nil {
|
||||
writeEventJSON(w, 202, map[string]string{"request_id": id})
|
||||
return
|
||||
} else if !errors.Is(err, sql.ErrNoRows) {
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
principal, err := s.store.PrincipalForSession(domain, s.authTokenFromRequest(r))
|
||||
if err != nil {
|
||||
taskError(w, store.ErrAccessDenied)
|
||||
return
|
||||
}
|
||||
if _, err = smtpMailbox(principal.Email); err != nil {
|
||||
writeEventJSON(w, 422, map[string]string{"error": "email_required"})
|
||||
return
|
||||
}
|
||||
config, err := s.store.AuthProviderConfig(domain, "smtp")
|
||||
if err != nil || !config.Enabled {
|
||||
writeEventJSON(w, 422, map[string]string{"error": "smtp_unavailable"})
|
||||
return
|
||||
}
|
||||
id, err := s.store.QueueTaskDigestRetry(r.Context(), domain, actor, input, time.Now())
|
||||
if err != nil {
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
writeEventJSON(w, 202, map[string]string{"request_id": id})
|
||||
return
|
||||
}
|
||||
if len(parts) == 1 {
|
||||
w.Header().Set("Allow", "GET")
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
if len(parts) == 2 && parts[1] == "retry" {
|
||||
w.Header().Set("Allow", "POST")
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
http.NotFound(w, r)
|
||||
}
|
||||
@@ -0,0 +1,447 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"pageswiki/internal/store"
|
||||
)
|
||||
|
||||
func digestHistoryFixture(t *testing.T) (*Server, string, string, string, time.Time, store.TaskDigestClaim) {
|
||||
t.Helper()
|
||||
s, token, domain, actor := taskFixture(t)
|
||||
ctx := context.Background()
|
||||
now := time.Now().UTC()
|
||||
p := store.TaskPreferences{Complexity: 1, DigestEnabled: true, DigestTime: "00:00", Timezone: "UTC"}
|
||||
if _, err := s.store.SaveTaskPreferences(ctx, domain, actor, p, now.Add(-24*time.Hour)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.store.DB.Exec(`UPDATE principals SET email='reader@example.test' WHERE uuid=?`, actor); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c, err := s.store.ClaimTaskDigest(ctx, store.TaskDigestDue{Domain: domain, Owner: actor}, now)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return s, token, domain, actor, now, c
|
||||
}
|
||||
|
||||
func TestTaskDigestHistoryRetryGenerationAndConsent(t *testing.T) {
|
||||
s, token, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
if recipient, err := s.store.TaskDigestRecipient(ctx, c); err != nil || recipient != "reader@example.test" {
|
||||
t.Fatal(recipient, err)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
|
||||
post := func(v store.TaskDigestRetry) int {
|
||||
return taskRequest(s, token, "POST", "digest-history/retry", v, "").Code
|
||||
}
|
||||
if got := post(input); got != 412 {
|
||||
t.Fatal("retried active delivery", got)
|
||||
}
|
||||
if err := s.store.FinishTaskDigest(ctx, c, "sent"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := post(input); got != 422 {
|
||||
t.Fatal("missing duplicate acknowledgment", got)
|
||||
}
|
||||
input.DuplicateAcknowledged = true
|
||||
var wg sync.WaitGroup
|
||||
results := make(chan int, 2)
|
||||
for range 2 {
|
||||
wg.Add(1)
|
||||
go func() { defer wg.Done(); results <- post(input) }()
|
||||
}
|
||||
wg.Wait()
|
||||
close(results)
|
||||
for code := range results {
|
||||
if code != 202 {
|
||||
t.Fatal("idempotent retry", code)
|
||||
}
|
||||
}
|
||||
q, err := s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil || len(q) != 1 || q[0].AttemptUUID != input.RequestID {
|
||||
t.Fatal(q, err)
|
||||
}
|
||||
if err = s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: false, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := post(input); got != 202 {
|
||||
t.Fatal("accepted receipt lost after SMTP disabled", got)
|
||||
}
|
||||
if err = s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
changed := input
|
||||
changed.DuplicateAcknowledged = false
|
||||
if got := post(changed); got != 412 {
|
||||
t.Fatal("changed replay", got)
|
||||
}
|
||||
changed = input
|
||||
changed.RequestID = uuid.NewString()
|
||||
if got := post(changed); got != 412 {
|
||||
t.Fatal("second queued request", got)
|
||||
}
|
||||
newClaim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.store.ClaimQueuedTaskDigest(ctx, q[0], now); !errors.Is(err, sql.ErrNoRows) {
|
||||
t.Fatal("double claim", err)
|
||||
}
|
||||
if err = s.store.FinishTaskDigest(ctx, c, "cancelled"); !errors.Is(err, store.ErrTaskConflict) {
|
||||
t.Fatal("old generation finished new attempt", err)
|
||||
}
|
||||
if _, err = s.store.TaskDigestRecipient(ctx, c); err == nil {
|
||||
t.Fatal("old generation can send")
|
||||
}
|
||||
if _, err = s.store.TaskDigestRecipient(ctx, newClaim); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p, err := s.store.TaskPreferences(ctx, domain, actor)
|
||||
if 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, newClaim); err == nil {
|
||||
t.Fatal("opt out ignored")
|
||||
}
|
||||
if err = s.store.FinishTaskDigestReason(ctx, newClaim, "cancelled", "consent_changed", now); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
w := taskRequest(s, token, "GET", "digest-history?limit=1", nil, "")
|
||||
if w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
var page store.TaskDigestHistory
|
||||
if err = json.Unmarshal(w.Body.Bytes(), &page); err != nil || len(page.Items) != 1 || page.Next == "" || page.Retries != 1 || page.Current.UUID != input.RequestID {
|
||||
t.Fatal(page, err)
|
||||
}
|
||||
w = taskRequest(s, token, "GET", "digest-history?limit=1&after="+page.Next, nil, "")
|
||||
if w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
for _, suffix := range []string{"?limit=101", "?after=bad", "?limit=NaN"} {
|
||||
if w = taskRequest(s, token, "GET", "digest-history"+suffix, nil, ""); w.Code != 422 {
|
||||
t.Fatal(suffix, w.Code)
|
||||
}
|
||||
}
|
||||
if strings.Contains(w.Body.String(), "reader@example.test") {
|
||||
t.Fatal("email in history")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskDigestHistoryQueueExpiryAndPermissions(t *testing.T) {
|
||||
for _, change := range []string{"preference", "extension", "suspended", "tomorrow"} {
|
||||
t.Run(change, func(t *testing.T) {
|
||||
s, _, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
q, err := s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
switch change {
|
||||
case "preference":
|
||||
p, e := s.store.TaskPreferences(ctx, domain, actor)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
p.Estimate++
|
||||
_, err = s.store.SaveTaskPreferences(ctx, domain, actor, p, now)
|
||||
case "extension":
|
||||
err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`)
|
||||
case "suspended":
|
||||
_, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor)
|
||||
case "tomorrow":
|
||||
now = now.Add(24 * time.Hour)
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.store.ClaimQueuedTaskDigest(ctx, q[0], now); !errors.Is(err, sql.ErrNoRows) {
|
||||
t.Fatal("cancelled queue returned live claim", err)
|
||||
}
|
||||
var state string
|
||||
if err = s.store.DB.QueryRow(`SELECT state FROM organizer_digest_attempts WHERE uuid=?`, input.RequestID).Scan(&state); err != nil || state != "cancelled" {
|
||||
t.Fatal(state, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
s, token, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
other, err := s.store.CreatePasswordAccount(domain, "digest-other", "a long test password", "Other", "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
otherToken, err := s.store.CreateAuthSession(domain, other.UUID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
w := taskRequest(s, otherToken, "GET", "digest-history", nil, "")
|
||||
if w.Code != 200 || !strings.Contains(w.Body.String(), `"items":[]`) {
|
||||
t.Fatal("history privacy", w.Code, w.Body)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
|
||||
if _, err = s.store.QueueTaskDigestRetry(ctx, domain, other.UUID, input, now); err == nil {
|
||||
t.Fatal("retried other's mail")
|
||||
}
|
||||
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", "digest-history/retry", input, ""); w.Code != 403 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
if w = taskRequest(s, token, "GET", "digest-history", nil, ""); w.Code != 200 {
|
||||
t.Fatal(w.Code, w.Body)
|
||||
}
|
||||
if w = taskRequest(s, "", "GET", "digest-history", nil, ""); w.Code == 200 {
|
||||
t.Fatal("anonymous history")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskDigestHistoryRetentionAndStaleWorker(t *testing.T) {
|
||||
s, _, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
// Keep synthetic stale-worker time within the same date even near midnight.
|
||||
now = time.Date(now.Year(), now.Month(), now.Day(), 12, 0, 0, 0, time.UTC)
|
||||
if _, err := s.store.DB.Exec(`UPDATE organizer_digest_attempts SET updated_ms=? WHERE uuid=?`, now.UnixMilli(), c.AttemptUUID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.store.MaintainTaskDigests(ctx, now.Add(11*time.Minute)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
page, err := s.store.TaskDigestHistory(ctx, domain, actor, "", 50, now)
|
||||
if err != nil || page.Current.State != "uncertain" {
|
||||
t.Fatal(page, err)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID, DuplicateAcknowledged: true}
|
||||
if _, err = s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now.Add(12*time.Minute)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
q, err := s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
claim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now.Add(12*time.Minute))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = s.store.FinishTaskDigest(ctx, c, "sent"); !errors.Is(err, store.ErrTaskConflict) {
|
||||
t.Fatal("stale completion", err)
|
||||
}
|
||||
if err = s.store.FinishTaskDigestReason(ctx, claim, "sent", "", now.Add(12*time.Minute)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
deleted, err := s.store.MaintainTaskDigests(ctx, now.Add(91*24*time.Hour))
|
||||
if err != nil || deleted != 2 {
|
||||
t.Fatal("retention", deleted, err)
|
||||
}
|
||||
var reservations, receipts int
|
||||
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_deliveries WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&reservations); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_requests WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&receipts); err != nil || reservations != 1 || receipts != 1 {
|
||||
t.Fatal("deduplication lost", reservations, receipts, err)
|
||||
}
|
||||
// Even an old request replay after retention returns its receipt without requeueing.
|
||||
if id, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now.Add(91*24*time.Hour)); err != nil || id != input.RequestID {
|
||||
t.Fatal(id, err)
|
||||
}
|
||||
q, err = s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil || len(q) != 0 {
|
||||
t.Fatal("retention resurrected mail", q, err)
|
||||
}
|
||||
if _, err = s.store.DB.Exec(`UPDATE organizer_task_preferences SET next_digest_ms=? WHERE domain_uuid=? AND owner_uuid=?`, now.Add(-time.Minute).UnixMilli(), domain, actor); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.store.ClaimTaskDigest(ctx, store.TaskDigestDue{Domain: domain, Owner: actor}, now); !errors.Is(err, sql.ErrNoRows) {
|
||||
t.Fatal("reservation lost", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskDigestHistorySMTPWorker(t *testing.T) {
|
||||
s, _, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
address, _, done := fakeSMTP(t, "", false)
|
||||
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: address, SMTPFrom: "wiki@example.test"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.deliverTaskDigests(ctx, &store.EventJob{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
delivery := <-done
|
||||
if !strings.Contains(delivery.message, "Subject: PagesWiki tasks "+c.Day) {
|
||||
t.Fatal("message missing")
|
||||
}
|
||||
page, err := s.store.TaskDigestHistory(ctx, domain, actor, "", 50, now)
|
||||
if err != nil || page.Current.State != "sent" || len(page.Items) != 2 {
|
||||
t.Fatal(page, err)
|
||||
}
|
||||
if err := s.deliverTaskDigests(ctx, &store.EventJob{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskDigestHistoryLimitsAndAtomicQueue(t *testing.T) {
|
||||
s, _, domain, actor, now, c := digestHistoryFixture(t)
|
||||
ctx := context.Background()
|
||||
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
|
||||
if _, err := s.store.DB.Exec(`CREATE TRIGGER fail_digest_queue BEFORE INSERT ON organizer_digest_attempts WHEN NEW.kind='manual' BEGIN SELECT RAISE(ABORT,'test queue failure'); END`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err == nil {
|
||||
t.Fatal("injected failure ignored")
|
||||
}
|
||||
var count int
|
||||
if err := s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_requests`).Scan(&count); err != nil || count != 0 {
|
||||
t.Fatal("partial receipt", count, err)
|
||||
}
|
||||
if _, err := s.store.DB.Exec(`DROP TRIGGER fail_digest_queue`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for i := 0; i < 5; i++ {
|
||||
input.RequestID = uuid.NewString()
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
|
||||
t.Fatal(i, err)
|
||||
}
|
||||
q, err := s.store.QueuedTaskDigests(ctx)
|
||||
if err != nil || len(q) != 1 {
|
||||
t.Fatal(q, err)
|
||||
}
|
||||
claim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = s.store.FinishTaskDigest(ctx, claim, "cancelled"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
input.ExpectedAttempt = claim.AttemptUUID
|
||||
}
|
||||
input.RequestID = uuid.NewString()
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); !errors.Is(err, store.ErrTaskConflict) {
|
||||
t.Fatal("retry cap", err)
|
||||
}
|
||||
input.Day = now.AddDate(0, 0, -1).Format("2006-01-02")
|
||||
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); !errors.Is(err, store.ErrTaskInvalid) {
|
||||
t.Fatal("past day accepted", err)
|
||||
}
|
||||
// A bounded retention pass leaves queued rows and durable guards untouched.
|
||||
_, err := s.store.DB.Exec(`WITH RECURSIVE n(i) AS (VALUES(1) UNION ALL SELECT i+1 FROM n WHERE i<501) INSERT INTO organizer_digest_attempts SELECT 'old-'||i,'d','u','2000-01-01','scheduled','sent',1,'UTC','',1,1 FROM n`)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
deleted, err := s.store.MaintainTaskDigests(ctx, now)
|
||||
if err != nil || deleted != 500 {
|
||||
t.Fatal("unbounded retention", deleted, err)
|
||||
}
|
||||
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_attempts WHERE uuid LIKE 'old-%'`).Scan(&count); err != nil || count != 1 {
|
||||
t.Fatal(count, err)
|
||||
}
|
||||
var integrity string
|
||||
if err = s.store.DB.QueryRow(`PRAGMA integrity_check`).Scan(&integrity); err != nil || integrity != "ok" {
|
||||
t.Fatal(integrity, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskDigestHistoryChromium(t *testing.T) {
|
||||
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
|
||||
t.Skip("opt-in Chromium")
|
||||
}
|
||||
s, token, domain, actor, now, c := digestHistoryFixture(t)
|
||||
s.store.BackgroundJobsDisabled = true
|
||||
s = New(s.store)
|
||||
if err := s.store.FinishTaskDigest(context.Background(), c, "uncertain"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
address, _, done := fakeSMTP(t, "", false)
|
||||
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: address, SMTPFrom: "wiki@example.test"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
script, err := os.ReadFile("internal/server/testdata/task-digest-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
|
||||
}
|
||||
if r.URL.Path == "/fixture/tick" && r.Method == "POST" {
|
||||
if e := s.deliverTaskDigests(r.Context(), &store.EventJob{}); e != nil {
|
||||
http.Error(w, "worker failed", 500)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(204)
|
||||
return
|
||||
}
|
||||
handler.ServeHTTP(w, r)
|
||||
}))
|
||||
defer server.Close()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second)
|
||||
defer cancel()
|
||||
width := os.Getenv("DIGEST_HISTORY_WIDTH")
|
||||
if width == "" {
|
||||
width = "1440"
|
||||
}
|
||||
args := []string{"internal/server/testdata/vim-browser-smoke.mjs", server.URL + "/fixture", t.TempDir(), os.Getenv("DIGEST_HISTORY_SCREENSHOT"), width, "850"}
|
||||
if out, err := exec.CommandContext(ctx, "node", args...).CombinedOutput(); err != nil {
|
||||
t.Fatalf("browser: %v\n%s", err, out)
|
||||
}
|
||||
select {
|
||||
case delivery := <-done:
|
||||
if !strings.Contains(delivery.message, "Subject: PagesWiki tasks "+c.Day) {
|
||||
t.Fatal("mail missing")
|
||||
}
|
||||
case <-ctx.Done():
|
||||
t.Fatal("SMTP not observed")
|
||||
}
|
||||
page, err := s.store.TaskDigestHistory(context.Background(), domain, actor, "", 50, now)
|
||||
if err != nil || page.Retries != 1 || len(page.Items) != 2 || page.Current.State != "sent" {
|
||||
t.Fatal(page, err)
|
||||
}
|
||||
}
|
||||
@@ -301,11 +301,24 @@ func (s *Server) handleTaskProductivity(w http.ResponseWriter, r *http.Request,
|
||||
var input struct {
|
||||
store.TaskWork
|
||||
Action string `json:"action"`
|
||||
Reason string `json:"reason"`
|
||||
Start string `json:"start"`
|
||||
End string `json:"end"`
|
||||
}
|
||||
if !taskJSON(w, r, &input) {
|
||||
return
|
||||
}
|
||||
v, err := s.store.ChangeTaskWork(r.Context(), domain, actor, input.Action, input.TaskWork, time.Now())
|
||||
if input.Action == "correct" && (input.Start != "" || input.End != "") {
|
||||
a, e1 := parseWorkInstant(input.Start, s.getLocation(domain))
|
||||
b, e2 := parseWorkInstant(input.End, s.getLocation(domain))
|
||||
if e1 != nil || e2 != nil {
|
||||
taskError(w, store.ErrTaskInvalid)
|
||||
return
|
||||
}
|
||||
input.StartMS = a.UnixMilli()
|
||||
input.EndMS = b.UnixMilli()
|
||||
}
|
||||
v, err := s.store.ChangeTaskWork(r.Context(), domain, actor, input.Action, input.TaskWork, time.Now(), input.Reason)
|
||||
if err != nil {
|
||||
taskError(w, err)
|
||||
return
|
||||
|
||||
@@ -222,6 +222,9 @@ func TestTaskWorkReportSplitsMidnightAndCompletion(t *testing.T) {
|
||||
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)
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"pageswiki/internal/store"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
func parseWorkInstant(raw string, loc *time.Location) (time.Time, error) {
|
||||
if v, err := time.Parse(time.RFC3339Nano, raw); err == nil {
|
||||
return v, nil
|
||||
}
|
||||
for _, format := range []string{"2006-01-02T15:04:05", "2006-01-02T15:04"} {
|
||||
v, err := time.ParseInLocation(format, raw, loc)
|
||||
if err != nil || v.Format(format) != raw {
|
||||
continue
|
||||
}
|
||||
// A repeated wall time needs an explicit offset. Do not silently choose
|
||||
// the earlier/later occurrence when a browser datetime-local cannot express it.
|
||||
for _, delta := range []time.Duration{-24 * time.Hour, -2 * time.Hour, -time.Hour, -30 * time.Minute, 30 * time.Minute, time.Hour, 2 * time.Hour, 24 * time.Hour} {
|
||||
if v.Add(delta).In(loc).Format(format) == raw {
|
||||
return time.Time{}, store.ErrTaskInvalid
|
||||
}
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
return time.Time{}, store.ErrTaskInvalid
|
||||
}
|
||||
|
||||
func (s *Server) handleTaskWorkHistory(w http.ResponseWriter, r *http.Request, actor string, parts []string) {
|
||||
if r.Method != "GET" {
|
||||
w.Header().Set("Allow", "GET")
|
||||
w.WriteHeader(405)
|
||||
return
|
||||
}
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
if len(parts) == 2 && parts[1] != "" {
|
||||
var before int64
|
||||
if raw := r.URL.Query().Get("before"); raw != "" {
|
||||
var err error
|
||||
before, err = strconv.ParseInt(raw, 10, 64)
|
||||
if err != nil || before < 0 {
|
||||
taskError(w, store.ErrTaskInvalid)
|
||||
return
|
||||
}
|
||||
}
|
||||
items, err := s.store.TaskWorkRevisions(r.Context(), domain, actor, parts[1], before)
|
||||
if err != nil {
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
var next int64
|
||||
if len(items) == 100 {
|
||||
next = items[len(items)-1].Item.Version
|
||||
}
|
||||
writeEventJSON(w, 200, map[string]any{"items": items, "next": next})
|
||||
return
|
||||
}
|
||||
if len(parts) != 1 {
|
||||
http.NotFound(w, r)
|
||||
return
|
||||
}
|
||||
now := time.Now().In(s.getLocation(domain))
|
||||
end := time.Date(now.Year(), now.Month(), now.Day()+1, 0, 0, 0, 0, now.Location())
|
||||
start := end.AddDate(0, 0, -30)
|
||||
for _, v := range []struct {
|
||||
key string
|
||||
target *time.Time
|
||||
}{{"from", &start}, {"to", &end}} {
|
||||
if raw := r.URL.Query().Get(v.key); raw != "" {
|
||||
date, err := time.ParseInLocation("2006-01-02", raw, now.Location())
|
||||
if err != nil || date.Format("2006-01-02") != raw {
|
||||
taskError(w, store.ErrTaskInvalid)
|
||||
return
|
||||
}
|
||||
*v.target = date
|
||||
}
|
||||
}
|
||||
limit := 50
|
||||
if raw := r.URL.Query().Get("limit"); raw != "" {
|
||||
var err error
|
||||
limit, err = strconv.Atoi(raw)
|
||||
if err != nil {
|
||||
taskError(w, store.ErrTaskInvalid)
|
||||
return
|
||||
}
|
||||
}
|
||||
result, err := s.store.TaskWorkHistory(r.Context(), domain, actor, start, end, r.URL.Query().Get("after"), limit)
|
||||
if err != nil {
|
||||
taskError(w, err)
|
||||
return
|
||||
}
|
||||
writeEventJSON(w, 200, map[string]any{"items": result.Items, "next": result.Next, "from": start.Format("2006-01-02"), "to": end.Format("2006-01-02"), "timezone": now.Location().String()})
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -98,6 +98,10 @@ func (s *Server) handleTaskPage(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
if r.URL.Path == "/v/plan/tasks/work" {
|
||||
s.renderWithContext(w, r, "task_work_history.gohtml", map[string]any{"TaskWritable": active, "Timezone": s.getTimezoneName(domain)})
|
||||
return
|
||||
}
|
||||
if r.URL.Path == "/v/plan/tasks/report" || r.URL.Path == "/v/plan/tasks/settings" {
|
||||
s.handleTaskProductivityPage(w, r, active)
|
||||
return
|
||||
@@ -212,6 +216,14 @@ func (s *Server) handleTasksAPI(w http.ResponseWriter, r *http.Request) {
|
||||
r = r.WithContext(ctx)
|
||||
domain := s.domainUUIDForRequest(r)
|
||||
parts := strings.Split(strings.TrimPrefix(r.URL.Path, tasksAPI), "/")
|
||||
if parts[0] == "digest-history" {
|
||||
s.handleTaskDigestHistory(w, r, actor, active, parts)
|
||||
return
|
||||
}
|
||||
if parts[0] == "work-history" {
|
||||
s.handleTaskWorkHistory(w, r, actor, parts)
|
||||
return
|
||||
}
|
||||
if len(parts) == 1 && (parts[0] == "dashboard" || parts[0] == "progress" || parts[0] == "calendar-capture" || parts[0] == "capture" || parts[0] == "preferences" || parts[0] == "work" || parts[0] == "report") {
|
||||
s.handleTaskProductivity(w, r, actor, active, parts[0])
|
||||
return
|
||||
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
(async()=>{
|
||||
const assert=(ok,msg)=>{if(!ok)throw Error(msg);},delay=ms=>new Promise(r=>setTimeout(r,ms));
|
||||
const wait=async check=>{for(let n=0;n<240;n++){if(check())return;await delay(25);}throw Error('Timed out: '+check);};
|
||||
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
|
||||
try{
|
||||
await new Promise(resolve=>{frame.onload=resolve;frame.src='/-/sys/config?panel=organizer';});
|
||||
const w=frame.contentWindow,d=frame.contentDocument;await wait(()=>d.querySelector('#task-digest-history details'));
|
||||
const root=d.getElementById('task-digest-history'),details=root.querySelector('details');
|
||||
assert(!details.open,'History not lazy');assert(!w.performance.getEntriesByType('resource').some(x=>x.name.includes('/digest-history')),'History eagerly fetched');
|
||||
details.open=true;await wait(()=>root.querySelector('.digest-retry form'));
|
||||
const form=root.querySelector('.digest-retry form'),ack=form.querySelector('input');
|
||||
assert(ack.required&&!ack.checked,'Uncertain delivery must require confirmation');assert(!form.checkValidity(),'Unchecked acknowledgment valid');ack.checked=true;
|
||||
const original=w.fetch,requests=[];let lose=true;
|
||||
w.fetch=async(url,options)=>{if(String(url).endsWith('/digest-history/retry')){requests.push(JSON.parse(options.body));const response=await original(url,options);if(lose){lose=false;await response.text();throw new TypeError('Simulated lost response');}return response;}return original(url,options);};
|
||||
form.requestSubmit();await wait(()=>root.querySelector('[role=status]').textContent&&!form.querySelector('button').disabled);
|
||||
assert(root.contains(form),'Lost response removed retry controls');form.requestSubmit();
|
||||
await wait(()=>!root.querySelector('.digest-retry form')&&!root.querySelector('.productivity-controls button').disabled);
|
||||
assert(requests.length===2&&requests[0].request_id===requests[1].request_id,'Retry generated a second request ID');
|
||||
assert(root.querySelectorAll('tbody tr').length===2,'Duplicate attempt created');
|
||||
const tick=await fetch('/fixture/tick',{method:'POST'});assert(tick.ok,'Worker failed');
|
||||
root.querySelector('.productivity-controls button').click();await wait(()=>root.querySelector('.digest-retry form'));
|
||||
assert(root.querySelector('.digest-retry input').required,'Sent retry must require confirmation');
|
||||
assert(root.textContent.includes('メールサーバー受付済み')||root.textContent.includes('Accepted by mail server'),'Sent status missing');
|
||||
assert(!root.textContent.includes('reader@example.test'),'Recipient leaked in history');
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'Settings overflow viewport');
|
||||
details.scrollIntoView({block:'start'});document.body.dataset.vimReady='1';
|
||||
}catch(error){const out=document.createElement('pre');out.id='error';out.textContent=error.stack;document.body.append(out);}
|
||||
})();
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
(async()=>{
|
||||
const assert=(ok,msg)=>{if(!ok)throw Error(msg);},delay=ms=>new Promise(r=>setTimeout(r,ms));
|
||||
const wait=async check=>{for(let n=0;n<200;n++){if(check())return;await delay(25);}throw Error('Timed out: '+check);};
|
||||
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
|
||||
try{
|
||||
await new Promise(resolve=>{frame.onload=resolve;frame.src='/v/plan/dashboard';});
|
||||
await wait(()=>frame.contentDocument.querySelector('.productivity-table tbody tr'));
|
||||
const reportTable=frame.contentDocument.querySelector('.productivity-table');
|
||||
assert(reportTable.querySelectorAll('thead th').length===4,'Project aggregate table missing');
|
||||
assert(reportTable.querySelector('tbody tr').lastElementChild.textContent==='1.00','Project duration incorrect');
|
||||
const historyLink=frame.contentDocument.querySelector('a[href="/v/plan/tasks/work"]');assert(historyLink,'Dashboard history link missing');
|
||||
await new Promise(resolve=>{frame.onload=resolve;historyLink.click();});
|
||||
const w=frame.contentWindow,d=frame.contentDocument;
|
||||
await wait(()=>d.querySelector('.work-history-table tbody button'));
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'History overflows viewport');
|
||||
d.querySelector('.work-history-table tbody button').click();
|
||||
let form=d.querySelector('.work-history-edit');assert(form,'Inline correction missing');
|
||||
const inputs=form.querySelectorAll('input');inputs[2].value='Browser correction';
|
||||
form.requestSubmit();await wait(()=>!d.querySelector('.work-history-edit')&&!d.getElementById('work-history-list').inert);
|
||||
d.querySelector('#work-history-list details').open=true;await wait(()=>d.querySelector('#work-history-list details strong'));
|
||||
assert(d.querySelector('#work-history-list details').textContent.includes('Browser correction'),'Audit missing');
|
||||
const originalFetch=w.fetch;w.fetch=async(url,options)=>options?.method==='POST'?new w.Response(JSON.stringify({error:'conflict'}),{status:412}):originalFetch(url,options);
|
||||
d.querySelector('.work-history-table tbody button').click();form=d.querySelector('.work-history-edit');form.querySelector('input[type=text]').value='Retain my input';form.requestSubmit();
|
||||
await wait(()=>form.querySelector('[role=status]').textContent);assert(form.querySelector('input[type=text]').value==='Retain my input','Conflict discarded input');
|
||||
w.fetch=originalFetch;w.confirm=()=>true;form.querySelector('button[type=button]').click();
|
||||
d.querySelectorAll('.work-history-table tbody tr:first-child button')[1].click();form=d.querySelector('.work-history-edit');form.querySelector('input').value='Browser cancellation';form.requestSubmit();await wait(()=>!d.querySelector('.work-history-edit')&&!d.getElementById('work-history-list').inert);
|
||||
assert(!d.querySelector('.work-history-table tbody tr:first-child button'),'Cancelled work remains editable');
|
||||
d.querySelector('#work-history-list details').open=true;await wait(()=>d.querySelector('#work-history-list details strong'));
|
||||
assert(d.querySelector('#work-history-list details').textContent.includes('Browser cancellation'),'Cancellation audit missing');
|
||||
const report=await (await fetch('/_/api/v1/extension/organizer.tasks/report')).json();assert(report.days.every(day=>day.work_ms===0),'Cancelled time remains in report');
|
||||
assert(d.documentElement.scrollWidth<=w.innerWidth,'Expanded history overflows viewport');
|
||||
document.body.dataset.vimReady='1';
|
||||
}catch(error){const out=document.createElement('pre');out.id='error';out.textContent=error.stack;document.body.append(out);}
|
||||
})();
|
||||
Reference in new issue
Block a user