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.
784 lines
26 KiB
Go
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)
|
|
}
|
|
}
|