448 lines
16 KiB
Go
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)
|
|
}
|
|
}
|