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