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
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user