diff --git a/internal/router/router.go b/internal/router/router.go new file mode 100644 index 0000000..936f678 --- /dev/null +++ b/internal/router/router.go @@ -0,0 +1,55 @@ +// Package router decides what happens to an incoming message. +package router + +import ( + "errors" + + "codeberg.org/squidd/parsimony/internal/store" +) + +var ( + // ErrUnknownList means the recipient address is not a list. + ErrUnknownList = errors.New("unknown list") + // ErrNotMember means the sender may not post to the list. + ErrNotMember = errors.New("sender is not a member") +) + +// Result describes how to deliver an accepted message. +type Result struct { + List store.List + Recipients []string // subscriber addresses + Data []byte // message to send +} + +// Router applies list policy to incoming messages. +type Router struct{ store *store.Store } + +// New creates a Router backed by s. +func New(s *store.Store) *Router { return &Router{store: s} } + +// Route validates a message from sender to the list address rcpt. +func (r *Router) Route(sender, rcpt string, data []byte) (Result, error) { + l, err := r.store.FindList(rcpt) + if errors.Is(err, store.ErrNotFound) { + return Result{}, ErrUnknownList + } + if err != nil { + return Result{}, err + } + ok, err := r.store.IsMember(l.ID, sender) + if err != nil { + return Result{}, err + } + if !ok { + return Result{}, ErrNotMember + } + members, err := r.store.Members(l.ID) + if err != nil { + return Result{}, err + } + rcpts := make([]string, len(members)) + for i, m := range members { + rcpts[i] = m.Address + } + return Result{List: l, Recipients: rcpts, Data: data}, nil +} diff --git a/internal/router/router_test.go b/internal/router/router_test.go new file mode 100644 index 0000000..6c20209 --- /dev/null +++ b/internal/router/router_test.go @@ -0,0 +1,58 @@ +package router + +import ( + "errors" + "testing" + + "codeberg.org/squidd/parsimony/internal/store" +) + +func setup(t *testing.T) *Router { + t.Helper() + s, err := store.Open(":memory:") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { s.Close() }) + l, _ := s.CreateList("dev", "example.org", "Dev") + s.AddMember(l.ID, "alice@example.com", "Alice") + s.AddMember(l.ID, "bob@example.com", "Bob") + return New(s) +} + +func TestRouteMemberPost(t *testing.T) { + r := setup(t) + res, err := r.Route("alice@example.com", "dev@example.org", []byte("Subject: hi\r\n\r\nbody\r\n")) + if err != nil { + t.Fatalf("route: %v", err) + } + if res.List.Name != "dev" { + t.Fatalf("list: %+v", res.List) + } + if len(res.Recipients) != 2 { + t.Fatalf("want 2 recipients, got %v", res.Recipients) + } +} + +func TestRouteSenderCaseInsensitive(t *testing.T) { + r := setup(t) + if _, err := r.Route("ALICE@Example.com", "dev@example.org", nil); err != nil { + t.Fatalf("route: %v", err) + } +} + +func TestRouteNonMemberRejected(t *testing.T) { + r := setup(t) + _, err := r.Route("mallory@evil.com", "dev@example.org", nil) + if !errors.Is(err, ErrNotMember) { + t.Fatalf("want ErrNotMember, got %v", err) + } +} + +func TestRouteUnknownList(t *testing.T) { + r := setup(t) + _, err := r.Route("alice@example.com", "nope@example.org", nil) + if !errors.Is(err, ErrUnknownList) { + t.Fatalf("want ErrUnknownList, got %v", err) + } +}