Loading…
} + {posts.isError &&{posts.error.message}
} + {posts.data && items.length === 0 && ( +Nothing has been sent to this list yet.
+ )} + {items.length > 0 && ( +", []byte("Message-ID:
\r\nSubject: hi\r\n\r\nbody\r\n"), items); err != nil { + t.Fatal(err) + } + return l +} + +func (e *env) onlyPost(t *testing.T, l store.List) store.Post { + t.Helper() + posts, err := e.s.ListPosts(l.ID, 0) + if err != nil || len(posts) != 1 { + t.Fatalf("posts: %+v %v", posts, err) + } + return posts[0] +} + +func TestTheWorkerCountsEachOutcomeOfAPost(t *testing.T) { + e := setup(t) + l := e.post(t, 4) + e.snd.fn = func(_ context.Context, _ string, to []string) error { + switch to[0] { + case "b@x.com": + return errors.New("connection refused") + case "c@x.com": + return &smtp.SMTPError{Code: 554, EnhancedCode: smtp.EnhancedCode{5, 7, 1}, Message: "policy"} + case "d@x.com": + return outbound.AtRcpt(&smtp.SMTPError{Code: 550, EnhancedCode: smtp.EnhancedCode{5, 1, 1}, Message: "no such user"}) + } + return nil + } + st, err := e.w.RunOnce(context.Background()) + if err != nil || st.Sent != 1 || st.Retried != 1 || st.Failed != 1 || st.Dropped != 1 { + t.Fatalf("run: %+v %v", st, err) + } + p := e.onlyPost(t, l) + if p.Recipients != 4 || p.Sent != 1 || p.Failed != 1 || p.Dropped != 1 || p.Pending != 1 { + t.Fatalf("post: %+v", p) + } + // The retried delivery goes out later. + e.snd.fn = nil + e.clk.set(t0.Add(Backoff(1))) + e.w.RunOnce(context.Background()) + if p := e.onlyPost(t, l); p.Sent != 2 || p.Pending != 0 { + t.Fatalf("post: %+v", p) + } +} + +func TestGivingUpAfterMaxAgeCountsAsFailed(t *testing.T) { + e := setup(t) + l := e.post(t, 1) + e.snd.fn = func(context.Context, string, []string) error { return errors.New("down") } + e.clk.set(t0.Add(MaxAge + 1)) + if st, _ := e.w.RunOnce(context.Background()); st.Failed != 1 { + t.Fatalf("stats: %+v", st) + } + if p := e.onlyPost(t, l); p.Failed != 1 || p.Pending != 0 { + t.Fatalf("post: %+v", p) + } +} + +func TestAMissingBodyCountsAsDropped(t *testing.T) { + e := setup(t) + e.w.readBody = func(int64) ([]byte, error) { return nil, store.ErrNotFound } + l := e.post(t, 2) + e.w.RunOnce(context.Background()) + if p := e.onlyPost(t, l); p.Dropped != 2 || p.Sent != 0 || p.Pending != 0 { + t.Fatalf("post: %+v", p) + } +} + +func TestDiscussionMailIsSentBeforeABigNewsletterQueuedEarlier(t *testing.T) { + e := setup(t) + e.w.Concurrency = 1 + var news []store.NewOutbound + for i := 0; i < 120; i++ { + news = append(news, store.NewOutbound{From: "b@x.org", Rcpt: "reader@x.com", Priority: 1}) + } + if err := e.s.Enqueue([]byte("Subject: newsletter\r\n\r\nx"), news); err != nil { + t.Fatal(err) + } + e.clk.set(t0.Add(1)) + e.s.Enqueue([]byte("Subject: talk\r\n\r\nx"), []store.NewOutbound{ + {From: "b@x.org", Rcpt: "first@x.com"}, {From: "b@x.org", Rcpt: "second@x.com"}, + }) + if _, err := e.w.RunOnce(context.Background()); err != nil { + t.Fatal(err) + } + if e.snd.sent[0].To[0] != "first@x.com" || e.snd.sent[1].To[0] != "second@x.com" || e.snd.sent[2].To[0] != "reader@x.com" { + t.Fatalf("order: %v %v %v", e.snd.sent[0].To, e.snd.sent[1].To, e.snd.sent[2].To) + } +} diff --git a/internal/queue/queue.go b/internal/queue/queue.go index 9976a9c..77f8141 100644 --- a/internal/queue/queue.go +++ b/internal/queue/queue.go @@ -219,7 +219,7 @@ func (w *Worker) RunOnce(ctx context.Context) (Stats, error) { func (w *Worker) deliver(ctx context.Context, cache *bodies, it store.OutboxItem) Stats { data, err := cache.get(it.MsgID) if errors.Is(err, store.ErrNotFound) { - w.complete(it) + w.drop(it) return Stats{Dropped: 1} } if err != nil { @@ -259,7 +259,7 @@ func (w *Worker) deliver(ctx context.Context, cache *bodies, it store.OutboxItem } } log.Printf("queue: drop %s: %v", it.Rcpt, err) - w.complete(it) + w.drop(it) return out case outbound.IsPermanent(err): // The relay refused the message itself (policy, size, line length...): nobody gets it, so @@ -292,3 +292,10 @@ func (w *Worker) complete(it store.OutboxItem) { log.Printf("queue: remove %d: %v", it.ID, err) } } + +// drop removes a delivery that will never be made; a delivery of a post counts as dropped. +func (w *Worker) drop(it store.OutboxItem) { + if err := w.Store.DropOutbox(it.ID); err != nil && !errors.Is(err, store.ErrNotFound) { + log.Printf("queue: drop %d: %v", it.ID, err) + } +} diff --git a/internal/router/priority_test.go b/internal/router/priority_test.go new file mode 100644 index 0000000..fd9ef41 --- /dev/null +++ b/internal/router/priority_test.go @@ -0,0 +1,127 @@ +package router + +import ( + "database/sql" + "testing" + + "codeberg.org/squidd/parsimony/internal/store" +) + +// newsletterEnv is newEnv on a database file whose list has the publishers post policy, set +// directly in the database. +func newsletterEnv(t *testing.T) *env { + t.Helper() + path := t.TempDir() + "/p.db" + s, err := store.Open(path) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { s.Close() }) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "alice@example.com", "Alice") + s.AddMember(l.ID, "bob@example.com", "Bob") + db, err := sql.Open("sqlite", path) + if err != nil { + t.Fatal(err) + } + defer db.Close() + if _, err := db.Exec(`UPDATE lists SET post_policy=? WHERE id=?`, store.PostPublishers, l.ID); err != nil { + t.Fatal(err) + } + l, _ = s.GetList(l.ID) + return &env{r: New(s), s: s, list: l} +} + +func duePriorities(t *testing.T, s *store.Store) []int { + t.Helper() + due, err := s.DueOutbox(100) + if err != nil { + t.Fatal(err) + } + var out []int + for _, d := range due { + out = append(out, d.Priority) + } + return out +} + +func allEqual(ps []int, want int, n int) bool { + if len(ps) != n { + return false + } + for _, p := range ps { + if p != want { + return false + } + } + return true +} + +const samplePost = "From: alice@example.com\r\nSubject: hi\r\nMessage-ID:
\r\n\r\nbody\r\n" + +func TestANewsletterIsDeliveredWithPriorityOne(t *testing.T) { + e := newsletterEnv(t) + res, err := e.r.prepare(e.list, []byte(samplePost)) + if err != nil { + t.Fatal(err) + } + if err := e.r.Deliver(res); err != nil { + t.Fatal(err) + } + if ps := duePriorities(t, e.s); !allEqual(ps, 1, 2) { + t.Fatalf("priorities: %v", ps) + } +} + +func TestADiscussionPostIsDeliveredWithPriorityZero(t *testing.T) { + e := newEnv(t) + if err := e.post(t, samplePost); err != nil { + t.Fatal(err) + } + if ps := duePriorities(t, e.s); !allEqual(ps, 0, 2) { + t.Fatalf("priorities: %v", ps) + } +} + +func TestAReleasedNewsletterHasPriorityOne(t *testing.T) { + e := newsletterEnv(t) + id, _ := e.s.HoldMessage(e.list.ID, "alice@example.com", []byte(samplePost), "r") + if err := e.r.Release(id); err != nil { + t.Fatal(err) + } + if ps := duePriorities(t, e.s); !allEqual(ps, 1, 2) { + t.Fatalf("priorities: %v", ps) + } +} + +func TestAReleasedDiscussionPostHasPriorityZero(t *testing.T) { + e := newEnv(t) + id, _ := e.s.HoldMessage(e.list.ID, "alice@example.com", []byte(samplePost), "r") + if err := e.r.Release(id); err != nil { + t.Fatal(err) + } + if ps := duePriorities(t, e.s); !allEqual(ps, 0, 2) { + t.Fatalf("priorities: %v", ps) + } +} + +func TestConfirmationMailOfANewsletterHasPriorityZero(t *testing.T) { + e := newsletterEnv(t) + if handled, err := e.r.Command("carol@x.com", "dev+join@example.org", nil); !handled || err != nil { + t.Fatalf("join: %v %v", handled, err) + } + if ps := duePriorities(t, e.s); !allEqual(ps, 0, 1) { + t.Fatalf("priorities: %v", ps) + } +} + +func TestAPostIsRecordedWithItsRecipients(t *testing.T) { + e := newEnv(t) + if err := e.post(t, samplePost); err != nil { + t.Fatal(err) + } + posts, err := e.s.ListPosts(e.list.ID, 0) + if err != nil || len(posts) != 1 || posts[0].Recipients != 2 || posts[0].MessageID != "
" || posts[0].Subject == "" {
+ t.Fatalf("posts: %+v %v", posts, err)
+ }
+}
diff --git a/internal/router/router.go b/internal/router/router.go
index 7721ece..71230ac 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -176,8 +176,13 @@ func postID(data []byte) string {
return "sha256:" + hex.EncodeToString(sum[:])
}
-// outbound builds one queue entry per recipient.
+// outbound builds one queue entry per recipient. A newsletter (post policy publishers) is sent
+// with priority 1, so that its many deliveries never delay discussion mail.
func (r *Router) outbound(res Result) ([]store.NewOutbound, error) {
+ priority := 0
+ if res.List.PostPolicy == store.PostPublishers {
+ priority = 1
+ }
items := make([]store.NewOutbound, 0, len(res.Recipients))
for _, rc := range res.Recipients {
from := r.bounceAddress(res.List, rc.ID)
@@ -185,7 +190,7 @@ func (r *Router) outbound(res Result) ([]store.NewOutbound, error) {
return nil, errors.New("cannot create bounce address")
}
items = append(items, store.NewOutbound{
- From: from, Rcpt: rc.Address, MemberID: rc.ID, Prefix: r.unsubscribeHeaders(res.List, rc.ID),
+ From: from, Rcpt: rc.Address, MemberID: rc.ID, Prefix: r.unsubscribeHeaders(res.List, rc.ID), Priority: priority,
})
}
return items, nil
diff --git a/internal/store/outbox.go b/internal/store/outbox.go
index c72abea..a0aea3b 100644
--- a/internal/store/outbox.go
+++ b/internal/store/outbox.go
@@ -12,6 +12,7 @@ type NewOutbound struct {
Rcpt string
MemberID int64 // 0 for system mail
Prefix []byte // per-recipient headers, sent before the shared message
+ Priority int // lower goes first among due deliveries: 0 for discussion and system mail, 1 for a newsletter
}
// OutboxItem is a queued delivery to one recipient.
@@ -28,7 +29,8 @@ type OutboxItem struct {
CreatedAt time.Time
// Failed deliveries are never retried (the relay refused them for good, or they are too old).
// They stay listed for a week so the admin can see what was lost and why.
- Failed bool
+ Failed bool
+ Priority int
}
// OutboxStats summarises the queue.
@@ -52,7 +54,7 @@ func (s *Store) Enqueue(msg []byte, items []NewOutbound) error {
return err
}
defer tx.Rollback()
- if err := enqueueTx(tx, s.Now().Unix(), msg, items); err != nil {
+ if err := enqueueTx(tx, s.Now().Unix(), 0, msg, items); err != nil {
return err
}
return tx.Commit()
@@ -65,6 +67,8 @@ const postMemory = time.Hour
// in the same transaction, so a crash never leaves one without the other. If the list already
// queued the same postID within postMemory it queues nothing and returns ErrDuplicate: the MTA
// delivers the post again when our reply to the first delivery was lost.
+// It also records the post (a Post, with its counters) and stamps every delivery with its id;
+// a refused duplicate records nothing.
func (s *Store) EnqueuePost(listID int64, postID string, msg []byte, items []NewOutbound) error {
now := s.Now()
tx, err := s.db.Begin()
@@ -81,8 +85,12 @@ func (s *Store) EnqueuePost(listID int64, postID string, msg []byte, items []New
}
return err
}
+ post, err := recordPostTx(tx, now, listID, msg, len(items))
+ if err != nil {
+ return err
+ }
if len(items) > 0 {
- if err := enqueueTx(tx, now.Unix(), msg, items); err != nil {
+ if err := enqueueTx(tx, now.Unix(), post, msg, items); err != nil {
return err
}
}
@@ -93,7 +101,7 @@ func (s *Store) EnqueuePost(listID int64, postID string, msg []byte, items []New
// its deliveries in one transaction. Of several simultaneous approvals only one succeeds, the
// others get ErrNotFound, so a message is never delivered twice. With no recipients the message
// is still released. An approval always delivers, even a post already seen, and records postID
-// as EnqueuePost does, so a later copy of the same post is refused.
+// as EnqueuePost does, so a later copy of the same post is refused. It records the post as EnqueuePost does.
func (s *Store) EnqueueFromHeld(heldID int64, postID string, msg []byte, items []NewOutbound) error {
tx, err := s.db.Begin()
if err != nil {
@@ -113,15 +121,20 @@ func (s *Store) EnqueueFromHeld(heldID int64, postID string, msg []byte, items [
ON CONFLICT(list_id, post_id) DO UPDATE SET created_at=excluded.created_at`, listID, postID, s.Now().Unix()); err != nil {
return err
}
+ post, err := recordPostTx(tx, s.Now(), listID, msg, len(items))
+ if err != nil {
+ return err
+ }
if len(items) > 0 {
- if err := enqueueTx(tx, s.Now().Unix(), msg, items); err != nil {
+ if err := enqueueTx(tx, s.Now().Unix(), post, msg, items); err != nil {
return err
}
}
return tx.Commit()
}
-func enqueueTx(tx *sql.Tx, now int64, msg []byte, items []NewOutbound) error {
+// enqueueTx stores msg and its deliveries; postID is the posts row they count for, 0 for other mail.
+func enqueueTx(tx *sql.Tx, now, postID int64, msg []byte, items []NewOutbound) error {
res, err := tx.Exec(`INSERT INTO outbox_msgs(data) VALUES(?)`, msg)
if err != nil {
return err
@@ -132,20 +145,20 @@ func enqueueTx(tx *sql.Tx, now int64, msg []byte, items []NewOutbound) error {
if prefix == nil {
prefix = []byte{}
}
- if _, err := tx.Exec(`INSERT INTO outbox(msg_id, envelope_from, rcpt, member_id, prefix, next_at, created_at)
- VALUES(?,?,?,?,?,?,?)`, msgID, it.From, it.Rcpt, it.MemberID, prefix, now, now); err != nil {
+ if _, err := tx.Exec(`INSERT INTO outbox(msg_id, envelope_from, rcpt, member_id, prefix, next_at, created_at, post_id, priority)
+ VALUES(?,?,?,?,?,?,?,?,?)`, msgID, it.From, it.Rcpt, it.MemberID, prefix, now, now, postID, it.Priority); err != nil {
return err
}
}
return nil
}
-const outboxCols = `id, msg_id, envelope_from, rcpt, member_id, prefix, attempts, next_at, last_error, created_at, failed`
+const outboxCols = `id, msg_id, envelope_from, rcpt, member_id, prefix, attempts, next_at, last_error, created_at, failed, priority`
func scanOutbox(row interface{ Scan(...any) error }) (OutboxItem, error) {
var it OutboxItem
var next, created, failed int64
- err := row.Scan(&it.ID, &it.MsgID, &it.From, &it.Rcpt, &it.MemberID, &it.Prefix, &it.Attempts, &next, &it.LastError, &created, &failed)
+ err := row.Scan(&it.ID, &it.MsgID, &it.From, &it.Rcpt, &it.MemberID, &it.Prefix, &it.Attempts, &next, &it.LastError, &created, &failed, &it.Priority)
it.NextAt, it.CreatedAt, it.Failed = time.Unix(next, 0), time.Unix(created, 0), failed != 0
return it, err
}
@@ -167,9 +180,10 @@ func (s *Store) queryOutbox(q string, args ...any) ([]OutboxItem, error) {
return out, rows.Err()
}
-// DueOutbox returns up to limit deliveries whose time has come, longest waiting first.
+// DueOutbox returns up to limit deliveries whose time has come: lowest priority number first (so a
+// big newsletter never delays discussion mail), then longest waiting first.
func (s *Store) DueOutbox(limit int) ([]OutboxItem, error) {
- return s.queryOutbox(`SELECT `+outboxCols+` FROM outbox WHERE failed=0 AND next_at<=? ORDER BY next_at, id LIMIT ?`,
+ return s.queryOutbox(`SELECT `+outboxCols+` FROM outbox WHERE failed=0 AND next_at<=? ORDER BY priority, next_at, id LIMIT ?`,
s.Now().Unix(), limit)
}
@@ -188,16 +202,26 @@ func (s *Store) OutboxData(msgID int64) ([]byte, error) {
return b, err
}
-// CompleteOutbox removes a delivery (sent, dropped or discarded) and the shared
-// message once no recipient needs it.
-func (s *Store) CompleteOutbox(id int64) error {
+// CompleteOutbox removes a delivery the relay accepted, and the shared message once no recipient
+// needs it. A delivery of a post counts as sent, in the same transaction.
+func (s *Store) CompleteOutbox(id int64) error { return s.removeOutbox(id, "sent") }
+
+// DropOutbox removes a delivery that will never be made (the mailbox does not exist, or the admin
+// discarded it), like CompleteOutbox. A delivery of a post counts as dropped, unless it had
+// already failed: it is counted as failed already.
+func (s *Store) DropOutbox(id int64) error { return s.removeOutbox(id, "dropped") }
+
+// removeOutbox deletes a delivery and adds one to counter (a column of posts, never user input)
+// of its post, when it has one and it had not failed.
+func (s *Store) removeOutbox(id int64, counter string) error {
tx, err := s.db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
- var msgID int64
- err = tx.QueryRow(`SELECT msg_id FROM outbox WHERE id=?`, id).Scan(&msgID)
+ var msgID, postID int64
+ var failed bool
+ err = tx.QueryRow(`SELECT msg_id, post_id, failed FROM outbox WHERE id=?`, id).Scan(&msgID, &postID, &failed)
if errors.Is(err, sql.ErrNoRows) {
return ErrNotFound
}
@@ -210,6 +234,11 @@ func (s *Store) CompleteOutbox(id int64) error {
if _, err := tx.Exec(`DELETE FROM outbox_msgs WHERE id=? AND NOT EXISTS (SELECT 1 FROM outbox WHERE msg_id=?)`, msgID, msgID); err != nil {
return err
}
+ if postID != 0 && !failed {
+ if _, err := tx.Exec(`UPDATE posts SET `+counter+`=`+counter+`+1 WHERE id=?`, postID); err != nil {
+ return err
+ }
+ }
return tx.Commit()
}
@@ -232,10 +261,33 @@ func (s *Store) OutboxStats() (OutboxStats, error) {
}
// FailOutbox gives up on a delivery for good, keeping it listed with the reason. Its time is the
-// moment of the failure, from which PurgeFailedOutbox counts.
+// moment of the failure, from which PurgeFailedOutbox counts. A delivery of a post counts as failed,
+// in the same transaction.
func (s *Store) FailOutbox(id int64, reason string) error {
- return affected(s.db.Exec(`UPDATE outbox SET failed=1, attempts=attempts+1, last_error=?, next_at=? WHERE id=?`,
- reason, s.Now().Unix(), id))
+ tx, err := s.db.Begin()
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+ var postID int64
+ var failed bool
+ err = tx.QueryRow(`SELECT post_id, failed FROM outbox WHERE id=?`, id).Scan(&postID, &failed)
+ if errors.Is(err, sql.ErrNoRows) {
+ return ErrNotFound
+ }
+ if err != nil {
+ return err
+ }
+ if _, err := tx.Exec(`UPDATE outbox SET failed=1, attempts=attempts+1, last_error=?, next_at=? WHERE id=?`,
+ reason, s.Now().Unix(), id); err != nil {
+ return err
+ }
+ if postID != 0 && !failed {
+ if _, err := tx.Exec(`UPDATE posts SET failed=failed+1 WHERE id=?`, postID); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
}
// PurgeFailedOutbox forgets failed deliveries older than a week, and the stored messages nobody
diff --git a/internal/store/posts.go b/internal/store/posts.go
new file mode 100644
index 0000000..e9f3323
--- /dev/null
+++ b/internal/store/posts.go
@@ -0,0 +1,78 @@
+package store
+
+import (
+ "bytes"
+ "database/sql"
+ "net/mail"
+ "time"
+)
+
+// Post is a post queued to a list, with the outcome of its deliveries so far.
+type Post struct {
+ ID int64
+ ListID int64
+ MessageID string // the Message-ID header, at most 200 characters
+ Subject string // decoded, at most 200 characters
+ CreatedAt time.Time
+ Recipients int // deliveries queued
+ Sent int // accepted by the relay
+ Failed int // given up for good
+ Dropped int // the mailbox does not exist, or discarded by the admin
+ Pending int // still in the queue: Recipients - Sent - Failed - Dropped
+}
+
+// postTTL is how long a post and its counters are kept.
+const postTTL = 400 * 24 * time.Hour
+
+// Limits of ListPosts.
+const (
+ defaultPostsLimit = 50
+ maxPostsLimit = 200
+)
+
+// recordPostTx stores the posts row of a post queued to a list and returns its id. It forgets
+// posts older than postTTL on the way, so the table never grows without bound.
+func recordPostTx(tx *sql.Tx, now time.Time, listID int64, msg []byte, recipients int) (int64, error) {
+ if _, err := tx.Exec(`DELETE FROM posts WHERE created_at`, now.Add(-postTTL).Unix()); err != nil {
+ return 0, err
+ }
+ subject, _ := summarize(msg)
+ var messageID string
+ if m, err := mail.ReadMessage(bytes.NewReader(msg)); err == nil {
+ messageID = cleanSummary(m.Header.Get("Message-ID"))
+ }
+ res, err := tx.Exec(`INSERT INTO posts(list_id, message_id, subject, created_at, recipients) VALUES(?,?,?,?,?)`,
+ listID, messageID, subject, now.Unix(), recipients)
+ if err != nil {
+ return 0, err
+ }
+ return res.LastInsertId()
+}
+
+// ListPosts returns the posts of a list, newest first: up to limit (50 when limit <= 0, at most 200).
+func (s *Store) ListPosts(listID int64, limit int) ([]Post, error) {
+ if limit <= 0 {
+ limit = defaultPostsLimit
+ }
+ if limit > maxPostsLimit {
+ limit = maxPostsLimit
+ }
+ rows, err := s.db.Query(`SELECT id, list_id, message_id, subject, created_at, recipients, sent, failed, dropped
+ FROM posts WHERE list_id=? ORDER BY created_at DESC, id DESC LIMIT ?`, listID, limit)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var out []Post
+ for rows.Next() {
+ var p Post
+ var created int64
+ if err := rows.Scan(&p.ID, &p.ListID, &p.MessageID, &p.Subject, &created, &p.Recipients, &p.Sent, &p.Failed, &p.Dropped); err != nil {
+ return nil, err
+ }
+ p.CreatedAt = time.Unix(created, 0)
+ p.Pending = p.Recipients - p.Sent - p.Failed - p.Dropped
+ out = append(out, p)
+ }
+ return out, rows.Err()
+}
diff --git a/internal/store/posts_test.go b/internal/store/posts_test.go
new file mode 100644
index 0000000..24a4960
--- /dev/null
+++ b/internal/store/posts_test.go
@@ -0,0 +1,424 @@
+package store
+
+import (
+ "errors"
+ "strings"
+ "testing"
+ "time"
+)
+
+const postMsg = "Message-ID: \r\nSubject: =?utf-8?q?Caff=C3=A8?= news\x07\r\n\r\nbody"
+
+func onlyPost(t *testing.T, s *Store, listID int64) Post {
+ t.Helper()
+ posts, err := s.ListPosts(listID, 0)
+ if err != nil || len(posts) != 1 {
+ t.Fatalf("posts: %+v %v", posts, err)
+ }
+ return posts[0]
+}
+
+func outboxPostIDs(t *testing.T, s *Store) []int64 {
+ t.Helper()
+ rows, err := s.db.Query(`SELECT post_id FROM outbox ORDER BY id`)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer rows.Close()
+ var ids []int64
+ for rows.Next() {
+ var id int64
+ rows.Scan(&id)
+ ids = append(ids, id)
+ }
+ return ids
+}
+
+func TestEnqueuePostRecordsThePost(t *testing.T) {
+ s := newTestStore(t)
+ now := time.Unix(1_000_000, 0)
+ s.Now = func() time.Time { return now }
+ l, _ := s.CreateList("dev", "example.org", "Dev")
+ if err := s.EnqueuePost(l.ID, "mid:", []byte(postMsg), items(3)); err != nil {
+ t.Fatal(err)
+ }
+ p := onlyPost(t, s, l.ID)
+ if p.ID == 0 || p.ListID != l.ID || p.MessageID != "" || p.Subject != "Caffè news" || !p.CreatedAt.Equal(now) ||
+ p.Recipients != 3 || p.Sent != 0 || p.Failed != 0 || p.Dropped != 0 || p.Pending != 3 {
+ t.Fatalf("post: %+v", p)
+ }
+ for _, id := range outboxPostIDs(t, s) {
+ if id != p.ID {
+ t.Fatalf("every delivery carries the post id: %d != %d", id, p.ID)
+ }
+ }
+}
+
+func TestEnqueuePostRecordsAPostRowWithNoRecipients(t *testing.T) {
+ s := newTestStore(t)
+ l, _ := s.CreateList("dev", "example.org", "Dev")
+ if err := s.EnqueuePost(l.ID, "mid:", []byte(postMsg), nil); err != nil {
+ t.Fatal(err)
+ }
+ if p := onlyPost(t, s, l.ID); p.Recipients != 0 || p.Pending != 0 {
+ t.Fatalf("post: %+v", p)
+ }
+}
+
+func TestARefusedDuplicateRecordsNoPost(t *testing.T) {
+ s := newTestStore(t)
+ l, _ := s.CreateList("dev", "example.org", "Dev")
+ s.EnqueuePost(l.ID, "mid:", []byte(postMsg), items(1))
+ if err := s.EnqueuePost(l.ID, "mid:", []byte(postMsg), items(1)); !errors.Is(err, ErrDuplicate) {
+ t.Fatalf("want ErrDuplicate, got %v", err)
+ }
+ onlyPost(t, s, l.ID)
+}
+
+func TestAFailedQueueWriteRecordsNoPost(t *testing.T) {
+ s := newTestStore(t)
+ l, _ := s.CreateList("dev", "example.org", "Dev")
+ if _, err := s.db.Exec(`CREATE TRIGGER boom BEFORE INSERT ON outbox BEGIN SELECT RAISE(ABORT, 'boom'); END`); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.EnqueuePost(l.ID, "mid:", []byte(postMsg), items(2)); err == nil {
+ t.Fatal("want the queue error")
+ }
+ hid, _ := s.HoldMessage(l.ID, "a@x.com", []byte("x"), "r")
+ if err := s.EnqueueFromHeld(hid, "mid: