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?= \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?= " || 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 \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 " || 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("", "Root", strings.Repeat("big body ", 1000))) reply := msg("", "Re: Root", "reply body") reply.InReplyTo = "" 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()) } } } <<<<<<< HEAD func TestMigrationAddsTheOutboxPriorityAloneAfterAHalfDoneUpgrade(t *testing.T) { // A crash between adding post_id and priority leaves outbox with the first and not the second. path := t.TempDir() + "/old.db" s, _ := Open(path) if _, err := s.db.Exec(`DROP INDEX outbox_due_prio`); err != nil { t.Fatal(err) } if _, err := s.db.Exec(`ALTER TABLE outbox DROP COLUMN priority`); err != nil { t.Fatal(err) } s.Close() s2, err := Open(path) if err != nil { t.Fatalf("migrate: %v", err) } defer s2.Close() if ok, err := hasColumn(s2.db, "outbox", "priority"); err != nil || !ok { t.Fatalf("priority is added back: %v %v", ok, err) ======= 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) >>>>>>> fix/sr-web-limits } }