parsimony/internal/store/dup_test.go
tgiachi dd0096093b test: pin the duplicate guard and the graceful shutdown
- router: an approved post is remembered, so the MTA's copy is refused
- store: a post with no recipients stores no message body
- app: an API request in flight during Close gets its answer
- app: finished LMTP sessions leave the connection tracker
- router: drop a TrimSpace on the Message-ID that net/mail already does
2026-11-10 11:58:07 +01:00

149 lines
5.2 KiB
Go

package store
import (
"errors"
"testing"
"time"
)
func TestEnqueuePostRefusesTheSamePostTwiceWithinAnHour(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:<a@x>", []byte("m"), items(2)); err != nil {
t.Fatal(err)
}
now = now.Add(59 * time.Minute)
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), items(2)); !errors.Is(err, ErrDuplicate) {
t.Fatalf("want ErrDuplicate, got %v", err)
}
if st, _ := s.OutboxStats(); st.Pending != 2 {
t.Fatalf("a duplicate must queue nothing, pending = %d", st.Pending)
}
}
func TestEnqueuePostTellsPostsAndListsApart(t *testing.T) {
s := newTestStore(t)
dev, _ := s.CreateList("dev", "example.org", "Dev")
ops, _ := s.CreateList("ops", "example.org", "Ops")
if err := s.EnqueuePost(dev.ID, "mid:<a@x>", []byte("m"), items(1)); err != nil {
t.Fatal(err)
}
if err := s.EnqueuePost(dev.ID, "mid:<b@x>", []byte("m"), items(1)); err != nil {
t.Fatalf("another Message-ID: %v", err)
}
if err := s.EnqueuePost(ops.ID, "mid:<a@x>", []byte("m"), items(1)); err != nil {
t.Fatalf("the same post to another list: %v", err)
}
if st, _ := s.OutboxStats(); st.Pending != 3 {
t.Fatalf("pending = %d", st.Pending)
}
}
func TestEnqueuePostForgetsAPostAfterAnHour(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:<a@x>", []byte("m"), items(1)); err != nil {
t.Fatal(err)
}
now = now.Add(time.Hour)
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), items(1)); !errors.Is(err, ErrDuplicate) {
t.Fatalf("exactly one hour later it is still a duplicate, got %v", err)
}
now = now.Add(time.Second)
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), items(1)); err != nil {
t.Fatalf("after an hour the post is accepted again: %v", err)
}
if st, _ := s.OutboxStats(); st.Pending != 2 {
t.Fatalf("pending = %d", st.Pending)
}
}
func TestEnqueuePurgesExpiredRecordsOfEveryList(t *testing.T) {
s := newTestStore(t)
now := time.Unix(1_000_000, 0)
s.Now = func() time.Time { return now }
dev, _ := s.CreateList("dev", "example.org", "Dev")
ops, _ := s.CreateList("ops", "example.org", "Ops")
s.EnqueuePost(dev.ID, "mid:<a@x>", []byte("m"), items(1))
now = now.Add(2 * time.Hour)
s.EnqueuePost(ops.ID, "mid:<b@x>", []byte("m"), items(1))
var n int
if err := s.db.QueryRow(`SELECT COUNT(*) FROM delivered`).Scan(&n); err != nil || n != 1 {
t.Fatalf("records = %d (%v), want only the fresh one", n, err)
}
}
func TestEnqueuePostRecordsAndQueuesTogether(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:<a@x>", []byte("m"), items(2)); err == nil {
t.Fatal("want the queue error")
}
s.db.Exec(`DROP TRIGGER boom`)
// The failed attempt left no record behind: the MTA's retry is queued.
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), items(2)); err != nil {
t.Fatalf("retry after a failed queue write: %v", err)
}
if st, _ := s.OutboxStats(); st.Pending != 2 {
t.Fatalf("pending = %d", st.Pending)
}
}
func TestEnqueuePostRecordsAPostWithNoRecipients(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), nil); err != nil {
t.Fatal(err)
}
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), nil); !errors.Is(err, ErrDuplicate) {
t.Fatalf("want ErrDuplicate, got %v", err)
}
var n int
if err := s.db.QueryRow(`SELECT COUNT(*) FROM outbox_msgs`).Scan(&n); err != nil || n != 0 {
t.Fatalf("stored messages = %d (%v), want none without recipients", n, err)
}
}
func TestReleasingAHeldPostDeliversItEvenIfSeenAndRecordsIt(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:<a@x>", []byte("m"), items(1)); err != nil {
t.Fatal(err)
}
hid, _ := s.HoldMessage(l.ID, "a@x.com", []byte("x"), "r")
now = now.Add(50 * time.Minute)
if err := s.EnqueueFromHeld(hid, "mid:<a@x>", []byte("final"), items(2)); err != nil {
t.Fatalf("an approval always delivers: %v", err)
}
if st, _ := s.OutboxStats(); st.Pending != 3 {
t.Fatalf("pending = %d", st.Pending)
}
// The approval refreshed the record: a retry of the same post 20 minutes later is a duplicate.
now = now.Add(20 * time.Minute)
if err := s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), items(1)); !errors.Is(err, ErrDuplicate) {
t.Fatalf("want ErrDuplicate after a release, got %v", err)
}
}
func TestDeletingAListForgetsItsPosts(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
s.EnqueuePost(l.ID, "mid:<a@x>", []byte("m"), nil)
if err := s.DeleteList(l.ID); err != nil {
t.Fatal(err)
}
var n int
if err := s.db.QueryRow(`SELECT COUNT(*) FROM delivered`).Scan(&n); err != nil || n != 0 {
t.Fatalf("records = %d (%v)", n, err)
}
}