Files
pages/internal/server/task_digest_history_test.go
Anya Tokugawa e65ca56f92
Build and publish container images / images (push) Successful in 12m27s
feat: add audited work records and controlled digest retries
2026-11-08 02:35:29 +09:00

448 lines
16 KiB
Go

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)
}
}