parsimony/internal/store/m2_test.go
tgiachi 8d28e48360 feat: configurable cap on confirmation requests, with a warning
When the global cap of unconfirmed requests (300 an hour) was reached,
a subscribe request silently got no mail while the visitor saw "Check
your email"; a newsletter launch can pass 300 signups an hour.

- limits.pending_per_hour (default 300, must be a whole number >= 1)
  is validated at load and set on the store by the app.
- When the global cap refuses a request the store logs a warning naming
  the setting, at most once a minute. The visitor still gets the
  neutral page, so nothing about members is revealed. The per-address
  cap is unchanged and is not logged.
- parsimony.example.yaml documents the setting.
2026-11-10 15:14:04 +01:00

784 lines
26 KiB
Go

package store
import (
"database/sql"
"errors"
"fmt"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
)
func TestListPolicies(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
if l.PostPolicy != "members" || l.JoinPolicy != "open" {
t.Fatalf("defaults: %+v", l)
}
if err := s.SetPolicies(l.ID, "moderated", "closed", "private"); err != nil {
t.Fatal(err)
}
got, _ := s.GetList(l.ID)
if got.PostPolicy != "moderated" || got.JoinPolicy != "closed" {
t.Fatalf("policies: %+v", got)
}
if err := s.SetPolicies(l.ID, "bogus", "open", "private"); err == nil {
t.Fatal("invalid policy must be rejected")
}
if err := s.SetPolicies(999, "members", "open", "private"); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
}
func TestHeldQueue(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
id, err := s.HoldMessage(l.ID, "bob@x.com", []byte("Subject: hi\r\n\r\nx"), "list is moderated")
if err != nil {
t.Fatal(err)
}
hs, err := s.ListHeld(l.ID)
if err != nil || len(hs) != 1 || hs[0].ID != id || hs[0].Sender != "bob@x.com" || hs[0].Reason != "list is moderated" {
t.Fatalf("held: %+v %v", hs, err)
}
h, err := s.GetHeld(id)
if err != nil || string(h.Data) != "Subject: hi\r\n\r\nx" || h.ListID != l.ID || h.Reason != "list is moderated" {
t.Fatalf("get: %+v %v", h, err)
}
if err := s.DeleteHeld(id); err != nil {
t.Fatal(err)
}
if _, err := s.GetHeld(id); !errors.Is(err, ErrNotFound) {
t.Fatal("held message should be gone")
}
if err := s.DeleteHeld(id); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
}
func TestPendingTokens(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")
tok, created, err := s.CreatePending(l.ID, "A@x.com", "join")
if err != nil || !created || tok == "" {
t.Fatalf("create: %q %v %v", tok, created, err)
}
// Rate limit: same request within an hour is not recreated.
now = now.Add(30 * time.Minute)
if _, created, _ := s.CreatePending(l.ID, "a@x.com", "join"); created {
t.Fatal("must be rate limited")
}
// After the window the same request can be made again.
now = now.Add(31 * time.Minute)
if _, created, _ := s.CreatePending(l.ID, "a@x.com", "join"); !created {
t.Fatal("rate limit must lapse after an hour")
}
now = now.Add(-31 * time.Minute)
// A different action is independent.
if _, created, _ := s.CreatePending(l.ID, "a@x.com", "leave"); !created {
t.Fatal("leave is a separate request")
}
p, err := s.ConfirmPending(tok, l.ID, nil)
if err != nil || p.Address != "a@x.com" || p.Action != "join" || p.ListID != l.ID {
t.Fatalf("confirm: %+v %v", p, err)
}
if _, err := s.ConfirmPending(tok, l.ID, nil); !errors.Is(err, ErrNotFound) {
t.Fatal("token is single use")
}
if _, err := s.ConfirmPending("nope", l.ID, nil); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown token")
}
// Expiry.
tok2, _, _ := s.CreatePending(l.ID, "b@x.com", "join")
now = now.Add(73 * time.Hour)
if _, err := s.ConfirmPending(tok2, l.ID, nil); !errors.Is(err, ErrNotFound) {
t.Fatal("token must expire after 72h")
}
}
func TestSecretIsStable(t *testing.T) {
s := newTestStore(t)
a, err := s.Secret()
if err != nil || len(a) < 32 {
t.Fatalf("secret: %x %v", a, err)
}
b, _ := s.Secret()
if string(a) != string(b) {
t.Fatal("secret must not change")
}
}
func TestBounceDisablesAfterThreshold(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
s.AddMember(l.ID, "a@x.com", "A")
ms, _ := s.Members(l.ID)
id := ms[0].ID
for i := 1; i <= 2; i++ {
disabled, err := s.RecordHardBounce(id, 3)
if err != nil || disabled {
t.Fatalf("bounce %d: %v %v", i, disabled, err)
}
}
disabled, _ := s.RecordHardBounce(id, 3)
if !disabled {
t.Fatal("third hard bounce must disable")
}
ms, _ = s.Members(l.ID)
if !ms[0].Disabled || ms[0].BounceCount != 3 {
t.Fatalf("member: %+v", ms[0])
}
if act, _ := s.ActiveMembers(l.ID); len(act) != 0 {
t.Fatalf("active: %+v", act)
}
// Re-adding resets the state.
s.AddMember(l.ID, "a@x.com", "A")
act, _ := s.ActiveMembers(l.ID)
if len(act) != 1 || act[0].BounceCount != 0 || act[0].ID != id {
t.Fatalf("after re-add: %+v", act)
}
m, err := s.MemberByID(id)
if err != nil || m.Address != "a@x.com" || m.ListID != l.ID {
t.Fatalf("by id: %+v %v", m, err)
}
if _, err := s.MemberByID(999); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown id")
}
if _, err := s.RecordHardBounce(999, 3); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown id")
}
}
func TestMigrateFromM1(t *testing.T) {
path := filepath.Join(t.TempDir(), "old.db")
db, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
_, err = db.Exec(`
CREATE TABLE lists (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, domain TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', UNIQUE(name, domain));
CREATE TABLE members (list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE, address TEXT NOT NULL, display_name TEXT NOT NULL DEFAULT '', PRIMARY KEY(list_id, address));
INSERT INTO lists(name, domain, title) VALUES('dev','example.org','Dev');
INSERT INTO members(list_id, address, display_name) VALUES(1,'a@x.com','A'),(1,'b@x.com','B');`)
if err != nil {
t.Fatal(err)
}
db.Close()
s, err := Open(path)
if err != nil {
t.Fatalf("migrate: %v", err)
}
defer s.Close()
l, err := s.FindList("dev@example.org")
if err != nil || l.PostPolicy != "members" || l.JoinPolicy != "open" {
t.Fatalf("list: %+v %v", l, err)
}
ms, _ := s.Members(l.ID)
if len(ms) != 2 || ms[0].ID == 0 || ms[0].Address != "a@x.com" {
t.Fatalf("members: %+v", ms)
}
s.Close()
// Opening again is a no-op.
s2, err := Open(path)
if err != nil {
t.Fatal(err)
}
s2.Close()
}
func TestMigrationAddsTheHeldReasonColumn(t *testing.T) {
path := t.TempDir() + "/old.db"
s, _ := Open(path)
l, _ := s.CreateList("dev", "example.org", "Dev")
s.db.Exec(`INSERT INTO held(list_id, sender, data, created_at, reason) VALUES(?, 'a@x.com', x'41', 1, 'x')`, l.ID)
s.db.Exec(`ALTER TABLE held DROP COLUMN reason`)
s.Close()
s2, err := Open(path)
if err != nil {
t.Fatalf("migrate: %v", err)
}
defer s2.Close()
hs, err := s2.ListHeld(l.ID)
if err != nil || len(hs) != 1 || hs[0].Reason != "" {
t.Fatalf("an old held message has an empty reason: %+v %v", hs, err)
}
}
func TestHoldingAnEmptyMessage(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
id, err := s.HoldMessage(l.ID, "a@x.com", nil, "r")
if err != nil {
t.Fatalf("an empty message must be holdable: %v", err)
}
if h, err := s.GetHeld(id); err != nil || len(h.Data) != 0 {
t.Fatalf("%+v %v", h, err)
}
}
func TestConfirmationMailIsCappedPerAddressAcrossLists(t *testing.T) {
s := newTestStore(t)
now := time.Unix(1_000_000, 0)
s.Now = func() time.Time { return now }
var lists []List
for _, n := range []string{"a", "b", "c", "d", "e"} {
l, _ := s.CreateList(n, "example.org", n)
lists = append(lists, l)
}
// A third party can name a victim's address on every list: only a few mails may reach it per hour.
for i := 0; i < maxPendingPerAddress; i++ {
if _, created, _ := s.CreatePending(lists[i].ID, "victim@x.com", "join"); !created {
t.Fatalf("request %d must be allowed", i+1)
}
}
if _, created, _ := s.CreatePending(lists[maxPendingPerAddress].ID, "Victim@X.com", "join"); created {
t.Fatal("another list, same address, same hour: refused")
}
if _, created, _ := s.CreatePending(lists[0].ID, "victim@x.com", "leave"); created {
t.Fatal("a leave request counts as well")
}
if _, created, _ := s.CreatePending(lists[0].ID, "someone-else@x.com", "join"); !created {
t.Fatal("other addresses are not affected")
}
now = now.Add(time.Hour + time.Second)
if _, created, _ := s.CreatePending(lists[maxPendingPerAddress].ID, "victim@x.com", "join"); !created {
t.Fatal("the allowance returns after an hour")
}
}
func TestConfirmationMailHasAGlobalCap(t *testing.T) {
// 300 an hour, as documented: not derived from the constant.
s := newTestStore(t)
now := time.Unix(1_000_000, 0)
s.Now = func() time.Time { return now }
l, _ := s.CreateList("dev", "example.org", "Dev")
for i := 0; i < 300; i++ {
if _, created, err := s.CreatePending(l.ID, fmt.Sprintf("u%d@x.com", i), "join"); err != nil || !created {
t.Fatalf("request %d: %v %v", i+1, created, err)
}
}
if _, created, _ := s.CreatePending(l.ID, "one-more@x.com", "join"); created {
t.Fatal("the daemon must not become a confirmation-mail cannon")
}
now = now.Add(time.Hour + time.Second)
if _, created, _ := s.CreatePending(l.ID, "one-more@x.com", "join"); !created {
t.Fatal("the global allowance returns after an hour")
}
}
func TestHeldQueueHasACap(t *testing.T) {
s := newTestStore(t)
a, _ := s.CreateList("a", "example.org", "A")
b, _ := s.CreateList("b", "example.org", "B")
ids := make([]int64, 0, maxHeldPerList)
for i := 0; i < maxHeldPerList; i++ {
id, err := s.HoldMessage(a.ID, "x@y.com", []byte("Subject: s\r\n\r\nb"), "r")
if err != nil {
t.Fatalf("message %d: %v", i+1, err)
}
ids = append(ids, id)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", []byte("x"), "r"); !errors.Is(err, ErrHeldFull) {
t.Fatalf("want ErrHeldFull, got %v", err)
}
if _, err := s.HoldMessage(b.ID, "x@y.com", []byte("x"), "r"); err != nil {
t.Fatalf("another list has its own allowance: %v", err)
}
// Moderating frees room.
if err := s.DeleteHeld(ids[0]); err != nil {
t.Fatal(err)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", []byte("x"), "r"); err != nil {
t.Fatalf("after discarding one: %v", err)
}
}
func TestOldHeldMessagesExpire(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")
other, _ := s.CreateList("ops", "example.org", "Ops")
old, _ := s.HoldMessage(l.ID, "x@y.com", []byte("old"), "r")
oldOther, _ := s.HoldMessage(other.ID, "x@y.com", []byte("old elsewhere"), "r")
now = now.Add(heldTTL - time.Hour)
fresh, _ := s.HoldMessage(l.ID, "x@y.com", []byte("fresh"), "r")
if _, err := s.GetHeld(old); err != nil {
t.Fatal("not expired yet")
}
now = now.Add(2 * time.Hour) // the first message is now older than the limit
if _, err := s.HoldMessage(l.ID, "x@y.com", []byte("newest"), "r"); err != nil {
t.Fatal(err)
}
if _, err := s.GetHeld(old); !errors.Is(err, ErrNotFound) {
t.Fatal("a message nobody moderated for a month is dropped")
}
if _, err := s.GetHeld(fresh); err != nil {
t.Fatalf("a recent message stays: %v", err)
}
if _, err := s.GetHeld(oldOther); err != nil {
t.Fatalf("expiry is applied to the list being written to, not to others: %v", err)
}
}
func TestHeldListingsCarryASummaryAndNeverTheBody(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
body := strings.Repeat("0123456789abcdef\r\n", 1000)
data := []byte("From: =?UTF-8?Q?Jos=C3=A9?= <jose@example.com>\r\nSubject: =?UTF-8?Q?Caff=C3=A8_a_las_nueve?=\r\n\r\n" + body)
id, err := s.HoldMessage(l.ID, "Alice@Example.com", data, "r")
if err != nil {
t.Fatal(err)
}
list, err := s.ListHeld(l.ID)
if err != nil || len(list) != 1 {
t.Fatalf("%v %v", list, err)
}
h := list[0]
if h.Data != nil {
t.Fatalf("a listing must not read the %d-byte body into memory", len(data))
}
if h.Subject != "Caffè a las nueve" || h.FromHeader != "=?UTF-8?Q?Jos=C3=A9?= <jose@example.com>" || h.Size != len(data) || h.Sender != "alice@example.com" {
t.Fatalf("summary: %+v", h)
}
full, err := s.GetHeld(id)
if err != nil || len(full.Data) != len(data) || full.Subject != h.Subject {
t.Fatalf("a single message still comes with its body: %v %d", err, len(full.Data))
}
}
func TestHeldSummaryOfOddMessages(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
long := strings.Repeat("x", 500)
for name, tc := range map[string]struct {
data string
subject, from string
}{
"no headers": {"\r\njust a body\r\n", "", ""},
"empty": {"", "", ""},
"no subject": {"From: a@x.com\r\n\r\nb", "", "a@x.com"},
"long subject": {"Subject: " + long + "\r\n\r\nb", strings.Repeat("x", 200), ""},
"long from": {"From: " + long + "\r\n\r\nb", "", strings.Repeat("x", 200)},
"folded subject": {"Subject: one\r\n two\r\n\r\nb", "one two", ""},
"control characters": {"Subject: a\x01b\x1b[31mred\r\n\r\nb", "ab[31mred", ""},
} {
id, err := s.HoldMessage(l.ID, "a@x.com", []byte(tc.data), "")
if err != nil {
t.Fatalf("%s: %v", name, err)
}
h, _ := s.GetHeld(id)
if h.Subject != tc.subject || h.FromHeader != tc.from {
t.Errorf("%s: subject %q from %q, want %q %q", name, h.Subject, h.FromHeader, tc.subject, tc.from)
}
}
}
func TestHeldQueueHasAByteCapAndAMessageCap(t *testing.T) {
oldMsg, oldList := heldMessageLimit, heldBytesLimit
heldMessageLimit, heldBytesLimit = 1000, 3500
t.Cleanup(func() { heldMessageLimit, heldBytesLimit = oldMsg, oldList })
s := newTestStore(t)
a, _ := s.CreateList("a", "example.org", "A")
b, _ := s.CreateList("b", "example.org", "B")
msg := func(n int) []byte { return []byte("Subject: s\r\n\r\n" + strings.Repeat("x", n-14)) }
if _, err := s.HoldMessage(a.ID, "x@y.com", msg(1001), ""); !errors.Is(err, ErrHeldTooLarge) {
t.Fatalf("one message over the limit: want ErrHeldTooLarge, got %v", err)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", msg(1000), ""); err != nil {
t.Fatalf("exactly at the limit is fine: %v", err)
}
var ids []int64
for i := 0; i < 2; i++ { // 1000 + 1000 + 1000 = 3000 of 3500
id, err := s.HoldMessage(a.ID, "x@y.com", msg(1000), "")
if err != nil {
t.Fatal(err)
}
ids = append(ids, id)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", msg(600), ""); !errors.Is(err, ErrHeldFull) {
t.Fatalf("3000 + 600 > 3500: want ErrHeldFull, got %v", err)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", msg(500), ""); err != nil {
t.Fatalf("3000 + 500 = 3500 fits: %v", err)
}
if _, err := s.HoldMessage(b.ID, "x@y.com", msg(1000), ""); err != nil {
t.Fatalf("another list has its own allowance: %v", err)
}
if err := s.DeleteHeld(ids[0]); err != nil {
t.Fatal(err)
}
if _, err := s.HoldMessage(a.ID, "x@y.com", msg(900), ""); err != nil {
t.Fatalf("moderating frees room: %v", err)
}
}
func TestMigrationSummarisesExistingHeldMessages(t *testing.T) {
path := t.TempDir() + "/old.db"
s, _ := Open(path)
l, _ := s.CreateList("dev", "example.org", "Dev")
data := []byte("From: Bob <bob@x.com>\r\nSubject: Old held\r\n\r\nbody")
id, _ := s.HoldMessage(l.ID, "bob@x.com", data, "r")
s.db.Exec(`ALTER TABLE held DROP COLUMN subject`)
s.db.Exec(`ALTER TABLE held DROP COLUMN from_header`)
s.db.Exec(`ALTER TABLE held DROP COLUMN size`)
s.Close()
s2, err := Open(path)
if err != nil {
t.Fatalf("migrate: %v", err)
}
defer s2.Close()
list, _ := s2.ListHeld(l.ID)
if len(list) != 1 || list[0].ID != id || list[0].Subject != "Old held" || list[0].FromHeader != "Bob <bob@x.com>" || list[0].Size != len(data) || list[0].Data != nil {
t.Fatalf("an existing held message is summarised by the migration: %+v", list)
}
}
func TestThreadListingsDoNotLoadBodies(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
root, _, _ := s.ArchiveMessage(l.ID, msg("<r@x>", "Root", strings.Repeat("big body ", 1000)))
reply := msg("<c@x>", "Re: Root", "reply body")
reply.InReplyTo = "<r@x>"
s.ArchiveMessage(l.ID, reply)
th, err := s.ThreadMessages(l.ID, root)
if err != nil || len(th) != 2 {
t.Fatalf("%v %v", th, err)
}
for _, m := range th {
if m.Body != "" {
t.Fatalf("a thread listing needs subjects, not bodies: %q", m.Body[:20])
}
if m.Size == 0 || m.Subject == "" {
t.Fatalf("summary: %+v", m)
}
}
one, _ := s.GetMessage(root)
if !strings.HasPrefix(one.Body, "big body") {
t.Fatal("a single message still has its body")
}
}
// The members migration renames, creates, copies and drops. If any step fails, nothing may be left
// half done: the old table keeps its rows, and no members_v1 stays behind.
func TestFailedMembersMigrationLeavesTheOldTablesIntact(t *testing.T) {
path := filepath.Join(t.TempDir(), "old.db")
db, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
// The second member belongs to a list that does not exist: the copy fails on the foreign key.
_, err = db.Exec(`
CREATE TABLE lists (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, domain TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', UNIQUE(name, domain));
CREATE TABLE members (list_id INTEGER NOT NULL, address TEXT NOT NULL, display_name TEXT NOT NULL DEFAULT '', PRIMARY KEY(list_id, address));
INSERT INTO lists(name, domain, title) VALUES('dev','example.org','Dev');
INSERT INTO members(list_id, address, display_name) VALUES(1,'a@x.com','A'),(99,'ghost@x.com','G');`)
if err != nil {
t.Fatal(err)
}
db.Close()
if s, err := Open(path); err == nil {
s.Close()
t.Fatal("the migration must fail on the orphan row")
}
db, err = sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
defer db.Close()
var n int
db.QueryRow(`SELECT COUNT(*) FROM members`).Scan(&n)
if n != 2 {
t.Fatalf("the old members table lost rows: %d", n)
}
if has, _ := hasColumn(db, "members", "id"); has {
t.Fatal("members must still be the old table")
}
var tables int
db.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE name='members_v1'`).Scan(&tables)
if tables != 0 {
t.Fatal("members_v1 was left behind")
}
}
func pendingRows(t *testing.T, s *Store) int {
t.Helper()
var n int
if err := s.db.QueryRow(`SELECT COUNT(*) FROM pending`).Scan(&n); err != nil {
t.Fatal(err)
}
return n
}
func TestCreatePendingPurgesExpiredRows(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")
s.CreatePending(l.ID, "old@x.com", "join")
now = now.Add(70 * time.Hour)
s.CreatePending(l.ID, "recent@x.com", "join")
if n := pendingRows(t, s); n != 2 {
t.Fatalf("rows within the TTL must stay: %d", n)
}
// 72h after the first request (and a little more): it goes, the other stays.
now = now.Add(3 * time.Hour)
s.CreatePending(l.ID, "third@x.com", "join")
if n := pendingRows(t, s); n != 2 {
t.Fatalf("the expired row must be purged: %d rows", n)
}
var old int
s.db.QueryRow(`SELECT COUNT(*) FROM pending WHERE address='old@x.com'`).Scan(&old)
if old != 0 {
t.Fatal("the expired request is still there")
}
// Exactly at the TTL a token is still valid, so it is not purged either.
now = now.Add(pendingTTL)
s.CreatePending(l.ID, "fourth@x.com", "join")
var recent int
s.db.QueryRow(`SELECT COUNT(*) FROM pending WHERE address='third@x.com'`).Scan(&recent)
if recent != 1 {
t.Fatal("a row exactly at the TTL must not be purged yet")
}
}
func TestConfirmPendingAppliesTheActionAndConsumesTheToken(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
tok, _, _ := s.CreatePending(l.ID, "carol@x.com", ActionJoin)
p, err := s.ConfirmPending(tok, l.ID, nil)
if err != nil || p.Address != "carol@x.com" || p.Action != ActionJoin {
t.Fatalf("%+v %v", p, err)
}
if ok, _ := s.IsMember(l.ID, "carol@x.com"); !ok {
t.Fatal("join must subscribe")
}
if pendingRows(t, s) != 0 {
t.Fatal("the token must be consumed")
}
tok, _, _ = s.CreatePending(l.ID, "carol@x.com", ActionLeave)
if _, err := s.ConfirmPending(tok, l.ID, nil); err != nil {
t.Fatal(err)
}
if ok, _ := s.IsMember(l.ID, "carol@x.com"); ok {
t.Fatal("leave must unsubscribe")
}
// Leaving when already gone still succeeds and still uses the token.
tok, _, _ = s.CreatePending(l.ID, "ghost@x.com", ActionLeave)
if _, err := s.ConfirmPending(tok, l.ID, nil); err != nil {
t.Fatalf("leave of a non-member: %v", err)
}
if pendingRows(t, s) != 0 {
t.Fatal("the token must be consumed")
}
}
func TestConfirmPendingJoinReenablesADisabledMember(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
s.AddMember(l.ID, "bob@x.com", "Bob")
ms, _ := s.Members(l.ID)
for i := 0; i < BounceThreshold; i++ {
s.RecordHardBounce(ms[0].ID, BounceThreshold)
}
tok, _, _ := s.CreatePending(l.ID, "bob@x.com", ActionJoin)
if _, err := s.ConfirmPending(tok, l.ID, nil); err != nil {
t.Fatal(err)
}
m, _ := s.MemberByID(ms[0].ID)
if m.Disabled || m.BounceCount != 0 {
t.Fatalf("%+v", m)
}
}
// A refusal or a failure leaves the token usable: the confirmation is not lost.
func TestConfirmPendingKeepsTheTokenWhenTheActionDoesNotHappen(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
tok, _, _ := s.CreatePending(l.ID, "carol@x.com", ActionJoin)
refused := errors.New("closed")
if _, err := s.ConfirmPending(tok, l.ID, func(Pending) error { return refused }); !errors.Is(err, refused) {
t.Fatalf("want the check's error, got %v", err)
}
if pendingRows(t, s) != 1 {
t.Fatal("a refused confirmation must keep its token")
}
// A database error while subscribing: force one with a trigger.
if _, err := s.db.Exec(`CREATE TRIGGER boom BEFORE INSERT ON members BEGIN SELECT RAISE(ABORT, 'boom'); END`); err != nil {
t.Fatal(err)
}
if _, err := s.ConfirmPending(tok, l.ID, nil); err == nil || errors.Is(err, ErrNotFound) {
t.Fatalf("want the database error, got %v", err)
}
if pendingRows(t, s) != 1 {
t.Fatal("a failed AddMember must keep the token")
}
s.db.Exec(`DROP TRIGGER boom`)
if _, err := s.ConfirmPending(tok, l.ID, nil); err != nil {
t.Fatalf("the token must still work: %v", err)
}
if ok, _ := s.IsMember(l.ID, "carol@x.com"); !ok {
t.Fatal("carol must be subscribed")
}
}
func TestConfirmPendingForAnotherListIsNotFoundAndKeepsTheToken(t *testing.T) {
s := newTestStore(t)
dev, _ := s.CreateList("dev", "example.org", "Dev")
ops, _ := s.CreateList("ops", "example.org", "Ops")
tok, _, _ := s.CreatePending(dev.ID, "carol@x.com", ActionJoin)
if _, err := s.ConfirmPending(tok, ops.ID, nil); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
if ok, _ := s.IsMember(ops.ID, "carol@x.com"); ok {
t.Fatal("must not join the wrong list")
}
if _, err := s.ConfirmPending(tok, dev.ID, nil); err != nil {
t.Fatalf("the right list can still use it: %v", err)
}
}
func TestConfirmPendingExpiredIsNotFound(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")
tok, _, _ := s.CreatePending(l.ID, "carol@x.com", ActionJoin)
now = now.Add(pendingTTL) // exactly at the limit: still valid
if _, err := s.ConfirmPending(tok, l.ID, nil); err != nil {
t.Fatalf("at the TTL: %v", err)
}
tok, _, _ = s.CreatePending(l.ID, "dave@x.com", ActionJoin)
now = now.Add(pendingTTL + time.Second)
checked := false
if _, err := s.ConfirmPending(tok, l.ID, func(Pending) error { checked = true; return nil }); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
if checked {
t.Fatal("an expired token must not reach the check")
}
if ok, _ := s.IsMember(l.ID, "dave@x.com"); ok {
t.Fatal("an expired token must not subscribe")
}
if pendingRows(t, s) != 0 {
t.Fatal("an expired token is removed when it is presented")
}
}
// Two confirmations of one token at the same time: exactly one applies.
func TestConfirmPendingIsSingleUseUnderConcurrency(t *testing.T) {
s, err := Open(filepath.Join(t.TempDir(), "p.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { s.Close() })
l, _ := s.CreateList("dev", "example.org", "Dev")
for round := 0; round < 20; round++ {
addr := fmt.Sprintf("u%d@x.com", round)
tok, _, _ := s.CreatePending(l.ID, addr, ActionJoin)
var applied, notFound, other atomic.Int32
var wg sync.WaitGroup
start := make(chan struct{})
for i := 0; i < 8; i++ {
wg.Add(1)
go func() {
defer wg.Done()
<-start
_, err := s.ConfirmPending(tok, l.ID, func(Pending) error { applied.Add(1); return nil })
switch {
case err == nil:
case errors.Is(err, ErrNotFound):
notFound.Add(1)
default:
other.Add(1)
}
}()
}
close(start)
wg.Wait()
if applied.Load() != 1 || notFound.Load() != 7 || other.Load() != 0 {
t.Fatalf("round %d: applied %d, not found %d, other errors %d", round, applied.Load(), notFound.Load(), other.Load())
}
}
}
func TestConfirmationMailGlobalCapIsConfigurable(t *testing.T) {
s := newTestStore(t)
if s.PendingPerHour != 300 {
t.Fatalf("default PendingPerHour = %d, want 300", s.PendingPerHour)
}
s.PendingPerHour = 2
s.Logf = func(string, ...any) {}
now := time.Unix(1_000_000, 0)
s.Now = func() time.Time { return now }
l, _ := s.CreateList("dev", "example.org", "Dev")
for i := 0; i < 2; i++ {
if _, created, err := s.CreatePending(l.ID, fmt.Sprintf("u%d@x.com", i), "join"); err != nil || !created {
t.Fatalf("request %d: %v %v", i+1, created, err)
}
}
if _, created, err := s.CreatePending(l.ID, "u2@x.com", "join"); err != nil || created {
t.Fatalf("the third request in the hour: created %v err %v, want refused", created, err)
}
}
func TestGlobalCapRefusalsAreLoggedOncePerMinute(t *testing.T) {
s := newTestStore(t)
s.PendingPerHour = 1
var logged []string
s.Logf = func(format string, args ...any) { logged = append(logged, fmt.Sprintf(format, args...)) }
t0 := time.Unix(1_000_000, 0)
now := t0
s.Now = func() time.Time { return now }
l, _ := s.CreateList("dev", "example.org", "Dev")
s.CreatePending(l.ID, "first@x.com", "join")
s.CreatePending(l.ID, "first@x.com", "join") // a repeat is not the global cap
if len(logged) != 0 {
t.Fatalf("nothing refused by the global cap yet: %q", logged)
}
for i := 0; i < 5; i++ {
s.CreatePending(l.ID, fmt.Sprintf("u%d@x.com", i), "join")
}
if len(logged) != 1 || !strings.Contains(logged[0], "limits.pending_per_hour") || !strings.Contains(logged[0], "1") {
t.Fatalf("one warning naming the setting: %q", logged)
}
now = t0.Add(time.Minute - time.Second)
s.CreatePending(l.ID, "late@x.com", "join")
if len(logged) != 1 {
t.Fatalf("at most one line a minute: %q", logged)
}
now = t0.Add(time.Minute)
s.CreatePending(l.ID, "later@x.com", "join")
if len(logged) != 2 {
t.Fatalf("a minute later the next refusal is logged: %q", logged)
}
}
func TestPerAddressCapRefusalsAreNotLogged(t *testing.T) {
s := newTestStore(t)
var logged []string
s.Logf = func(format string, args ...any) { logged = append(logged, fmt.Sprintf(format, args...)) }
for i := 0; i <= maxPendingPerAddress; i++ {
l, _ := s.CreateList(fmt.Sprintf("l%d", i), "example.org", "L")
s.CreatePending(l.ID, "victim@x.com", "join")
}
if len(logged) != 0 {
t.Fatalf("the per-address cap is not the global one: %q", logged)
}
}