parsimony/internal/router/publisher_test.go
tgiachi d4f706523f feat(router): the publishers post policy refuses non-publishers
- Route on a publishers list lets through a member flagged publisher, after the
  unchanged discard and loop checks, and applies the usual From header check
- anyone else gets the new ErrNotPublisher: never held, archived or queued
- ingest answers ErrNotPublisher with 550 5.7.1 only the publishers of this list may post
- tests: publisher ok, plain member and stranger refused, disabled publisher posts,
  identity mismatch held and released, discard rules first, other policies unchanged
2026-11-10 12:37:00 +01:00

143 lines
4.6 KiB
Go

package router
import (
"errors"
"strings"
"testing"
"codeberg.org/squidd/parsimony/internal/store"
)
// newsletterEnv is the test list with the publishers post policy and alice as its only publisher.
func newsletterEnv(t *testing.T) *env {
t.Helper()
e := newEnv(t)
if err := e.s.SetPolicies(e.list.ID, store.PostPublishers, store.JoinOpen, store.ArchivePrivate); err != nil {
t.Fatal(err)
}
if err := e.s.SetPublisher(e.list.ID, "alice@example.com", true); err != nil {
t.Fatal(err)
}
return e
}
// nothingKept checks that a refused post left no trace: not held, not archived, not queued.
func nothingKept(t *testing.T, e *env) {
t.Helper()
if held, _ := e.s.ListHeld(e.list.ID); len(held) != 0 {
t.Fatalf("held: %+v", held)
}
if msgs, _, _ := e.s.ListMessages(e.list.ID, 10, 0); len(msgs) != 0 {
t.Fatalf("archived: %+v", msgs)
}
if st, _ := e.s.OutboxStats(); st.Pending != 0 {
t.Fatalf("queued: %+v", st)
}
}
func TestAPublisherPostsToANewsletter(t *testing.T) {
e := newsletterEnv(t)
res, err := e.r.Route("Alice@Example.com", "dev@example.org", postFrom("Alice <alice@example.com>"))
if err != nil {
t.Fatal(err)
}
if err := e.send(res); err != nil {
t.Fatal(err)
}
if len(e.out.Sent) != 2 {
t.Fatalf("every member receives it: sent %d", len(e.out.Sent))
}
}
func TestAPlainMemberMayNotPostToANewsletter(t *testing.T) {
e := newsletterEnv(t)
_, err := e.r.Route("bob@example.com", "dev@example.org", postFrom("bob@example.com"))
if !errors.Is(err, ErrNotPublisher) {
t.Fatalf("want ErrNotPublisher, got %v", err)
}
nothingKept(t, e)
}
func TestAStrangerMayNotPostToANewsletter(t *testing.T) {
e := newsletterEnv(t)
for _, from := range []string{"mallory@evil.com", "alice@example.com"} {
_, err := e.r.Route("mallory@evil.com", "dev@example.org", postFrom(from))
if !errors.Is(err, ErrNotPublisher) {
t.Fatalf("From %s: want ErrNotPublisher, got %v", from, err)
}
}
nothingKept(t, e)
}
func TestAPublisherDisabledByBouncesStillPosts(t *testing.T) {
e := newsletterEnv(t)
for i := 0; i < store.BounceThreshold; i++ {
e.s.RecordHardBounce(e.alice, store.BounceThreshold)
}
res, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("alice@example.com"))
if err != nil {
t.Fatal(err)
}
if len(res.Recipients) != 1 || res.Recipients[0].Address != "bob@example.com" {
t.Fatalf("a disabled publisher posts but does not receive: %+v", res.Recipients)
}
}
func TestAPublisherWithAnotherFromHeaderIsHeld(t *testing.T) {
e := newsletterEnv(t)
_, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("Bob <bob@example.com>"))
if !errors.Is(err, ErrHeld) {
t.Fatalf("want ErrHeld, got %v", err)
}
held, _ := e.s.ListHeld(e.list.ID)
if len(held) != 1 || !strings.Contains(held[0].Reason, "From header does not match") {
t.Fatalf("held: %+v", held)
}
if st, _ := e.s.OutboxStats(); st.Pending != 0 {
t.Fatal("nothing may be queued")
}
}
func TestAReleasedPublisherPostIsDelivered(t *testing.T) {
e := newsletterEnv(t)
e.r.Route("alice@example.com", "dev@example.org", postFrom("Bob <bob@example.com>"))
held, _ := e.s.ListHeld(e.list.ID)
if err := e.release(held[0].ID); err != nil {
t.Fatal(err)
}
if len(e.out.Sent) != 2 {
t.Fatalf("the admin approved it: sent %d", len(e.out.Sent))
}
if held, _ := e.s.ListHeld(e.list.ID); len(held) != 0 {
t.Fatal("released")
}
}
func TestNewsletterDiscardRulesComeFirst(t *testing.T) {
e := newsletterEnv(t)
for _, sender := range []string{"alice@example.com", "bob@example.com", "stranger@x.com"} {
for _, h := range []string{"List-Id: <dev.example.org>\r\n", "Auto-Submitted: auto-replied\r\n"} {
if _, err := e.r.Route(sender, "dev@example.org", withHeaders(h)); !errors.Is(err, ErrDiscarded) {
t.Fatalf("%s %q: want ErrDiscarded, got %v", sender, h, err)
}
}
}
nothingKept(t, e)
}
func TestAPublisherFlagChangesNothingOnOtherPolicies(t *testing.T) {
e := newEnv(t)
// members: a plain member posts, a stranger is refused as a non-member.
if _, err := e.r.Route("bob@example.com", "dev@example.org", postFrom("bob@example.com")); err != nil {
t.Fatalf("members policy: %v", err)
}
if _, err := e.r.Route("x@y.com", "dev@example.org", postFrom("x@y.com")); !errors.Is(err, ErrNotMember) {
t.Fatalf("members policy, stranger: %v", err)
}
// moderated: a publisher is held like everybody else.
e.s.SetPublisher(e.list.ID, "alice@example.com", true)
e.s.SetPolicies(e.list.ID, store.PostModerated, store.JoinOpen, store.ArchivePrivate)
if _, err := e.r.Route("alice@example.com", "dev@example.org", postFrom("alice@example.com")); !errors.Is(err, ErrHeld) {
t.Fatalf("moderated policy: %v", err)
}
}