Merge pull request 'Harden the test suite' (#8) from chore/test-hardening into main
This commit is contained in:
commit
aad87be74c
5 changed files with 406 additions and 0 deletions
118
internal/app/app.go
Normal file
118
internal/app/app.go
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
// Package app wires the store, router, LMTP server and REST API together.
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/emersion/go-smtp"
|
||||
|
||||
"codeberg.org/squidd/parsimony/internal/api"
|
||||
"codeberg.org/squidd/parsimony/internal/config"
|
||||
"codeberg.org/squidd/parsimony/internal/ingest"
|
||||
"codeberg.org/squidd/parsimony/internal/outbound"
|
||||
"codeberg.org/squidd/parsimony/internal/router"
|
||||
"codeberg.org/squidd/parsimony/internal/store"
|
||||
)
|
||||
|
||||
// App is a running daemon.
|
||||
type App struct {
|
||||
// LMTPAddr and APIAddr are the addresses actually bound.
|
||||
// APIAddr is empty when the API is disabled.
|
||||
LMTPAddr string
|
||||
APIAddr string
|
||||
|
||||
store *store.Store
|
||||
lmtp *smtp.Server
|
||||
lns []net.Listener // closed by Close so Serve returns even if Close wins the race with it
|
||||
web *http.Server
|
||||
wg sync.WaitGroup
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// releaser lets the API approve held messages through the router.
|
||||
type releaser struct {
|
||||
rt *router.Router
|
||||
out outbound.Sender
|
||||
}
|
||||
|
||||
func (r releaser) Release(ctx context.Context, id int64) error { return r.rt.Release(ctx, r.out, id) }
|
||||
|
||||
// Start opens the database and begins serving. The REST API runs only when
|
||||
// apiToken is not empty.
|
||||
func Start(cfg config.Config, apiToken string) (*App, error) {
|
||||
st, err := store.Open(cfg.DB)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("store: %w", err)
|
||||
}
|
||||
a := &App{store: st}
|
||||
|
||||
rt := router.New(st)
|
||||
rt.BaseURL = cfg.BaseURL
|
||||
relay := &outbound.SMTPRelay{Addr: cfg.Relay.Addr}
|
||||
a.lmtp = ingest.NewServer(rt, relay)
|
||||
|
||||
if cfg.LMTP.Network == "unix" {
|
||||
os.Remove(cfg.LMTP.Addr)
|
||||
}
|
||||
lmtpLn, err := net.Listen(cfg.LMTP.Network, cfg.LMTP.Addr)
|
||||
if err != nil {
|
||||
st.Close()
|
||||
return nil, fmt.Errorf("listen lmtp: %w", err)
|
||||
}
|
||||
a.LMTPAddr = lmtpLn.Addr().String()
|
||||
a.lns = append(a.lns, lmtpLn)
|
||||
|
||||
var apiLn net.Listener
|
||||
if apiToken != "" {
|
||||
apiLn, err = net.Listen("tcp", cfg.API.Listen)
|
||||
if err != nil {
|
||||
lmtpLn.Close()
|
||||
st.Close()
|
||||
return nil, fmt.Errorf("listen api: %w", err)
|
||||
}
|
||||
a.APIAddr = apiLn.Addr().String()
|
||||
a.lns = append(a.lns, apiLn)
|
||||
a.web = &http.Server{Handler: api.New(st, apiToken, releaser{rt, relay}), ReadHeaderTimeout: 10 * time.Second}
|
||||
}
|
||||
|
||||
a.wg.Add(1)
|
||||
go func() {
|
||||
defer a.wg.Done()
|
||||
if err := a.lmtp.Serve(lmtpLn); err != nil && !errors.Is(err, smtp.ErrServerClosed) && !errors.Is(err, net.ErrClosed) {
|
||||
log.Printf("lmtp: %v", err)
|
||||
}
|
||||
}()
|
||||
if a.web != nil {
|
||||
a.wg.Add(1)
|
||||
go func() {
|
||||
defer a.wg.Done()
|
||||
if err := a.web.Serve(apiLn); err != nil && !errors.Is(err, http.ErrServerClosed) && !errors.Is(err, net.ErrClosed) {
|
||||
log.Printf("api: %v", err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
// Close stops the servers and closes the database. It is safe to call twice.
|
||||
func (a *App) Close() {
|
||||
a.once.Do(func() {
|
||||
for _, ln := range a.lns {
|
||||
ln.Close()
|
||||
}
|
||||
a.lmtp.Close()
|
||||
if a.web != nil {
|
||||
a.web.Close()
|
||||
}
|
||||
a.wg.Wait()
|
||||
a.store.Close()
|
||||
})
|
||||
}
|
||||
212
internal/app/app_test.go
Normal file
212
internal/app/app_test.go
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/emersion/go-smtp"
|
||||
|
||||
"codeberg.org/squidd/parsimony/internal/config"
|
||||
)
|
||||
|
||||
// sink is a fake SMTP relay that records what it receives.
|
||||
type sink struct {
|
||||
mu sync.Mutex
|
||||
msgs []sunk
|
||||
}
|
||||
|
||||
type sunk struct {
|
||||
from string
|
||||
to []string
|
||||
data string
|
||||
}
|
||||
|
||||
func (s *sink) NewSession(*smtp.Conn) (smtp.Session, error) { return &sinkSession{s: s}, nil }
|
||||
|
||||
type sinkSession struct {
|
||||
s *sink
|
||||
from string
|
||||
to []string
|
||||
}
|
||||
|
||||
func (x *sinkSession) Reset() { x.from, x.to = "", nil }
|
||||
func (x *sinkSession) Logout() error { return nil }
|
||||
func (x *sinkSession) Mail(f string, _ *smtp.MailOptions) error {
|
||||
x.from = f
|
||||
return nil
|
||||
}
|
||||
func (x *sinkSession) Rcpt(t string, _ *smtp.RcptOptions) error {
|
||||
x.to = append(x.to, t)
|
||||
return nil
|
||||
}
|
||||
func (x *sinkSession) Data(r io.Reader) error {
|
||||
b, _ := io.ReadAll(r)
|
||||
x.s.mu.Lock()
|
||||
x.s.msgs = append(x.s.msgs, sunk{x.from, x.to, string(b)})
|
||||
x.s.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sink) count() int {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
return len(s.msgs)
|
||||
}
|
||||
|
||||
func startSink(t *testing.T) (string, *sink) {
|
||||
t.Helper()
|
||||
sk := &sink{}
|
||||
srv := smtp.NewServer(sk)
|
||||
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
go srv.Serve(ln)
|
||||
t.Cleanup(func() { srv.Close() })
|
||||
return ln.Addr().String(), sk
|
||||
}
|
||||
|
||||
func testConfig(t *testing.T, relay string) config.Config {
|
||||
t.Helper()
|
||||
var c config.Config
|
||||
c.DB = t.TempDir() + "/p.db"
|
||||
c.LMTP.Network = "tcp"
|
||||
c.LMTP.Addr = "127.0.0.1:0"
|
||||
c.Relay.Addr = relay
|
||||
c.API.Listen = "127.0.0.1:0"
|
||||
return c
|
||||
}
|
||||
|
||||
func call(t *testing.T, a *App, method, path, body, token string) int {
|
||||
t.Helper()
|
||||
req, _ := http.NewRequest(method, "http://"+a.APIAddr+path, strings.NewReader(body))
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
return resp.StatusCode
|
||||
}
|
||||
|
||||
func lmtpSend(t *testing.T, addr, from, rcpt, msg string) error {
|
||||
t.Helper()
|
||||
conn, err := net.Dial("tcp", addr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c := smtp.NewClientLMTP(conn)
|
||||
defer c.Close()
|
||||
if err := c.Hello("localhost"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := c.Mail(from, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := c.Rcpt(rcpt, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
w, err := c.Data()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
w.Write([]byte(msg))
|
||||
_, err = w.CloseWithLMTPResponse()
|
||||
return err
|
||||
}
|
||||
|
||||
func TestEndToEnd(t *testing.T) {
|
||||
relayAddr, relay := startSink(t)
|
||||
a, err := Start(testConfig(t, relayAddr), "tok")
|
||||
if err != nil {
|
||||
t.Fatalf("start: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { a.Close() })
|
||||
|
||||
if code := call(t, a, "GET", "/api/v1/health", "", ""); code != 200 {
|
||||
t.Fatalf("health = %d", code)
|
||||
}
|
||||
if code := call(t, a, "GET", "/api/v1/lists", "", ""); code != 401 {
|
||||
t.Fatalf("unauthenticated = %d", code)
|
||||
}
|
||||
if code := call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok"); code != 201 {
|
||||
t.Fatalf("create list = %d", code)
|
||||
}
|
||||
for _, m := range []string{"alice@example.com", "bob@example.com"} {
|
||||
if code := call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"`+m+`"}`, "tok"); code != 201 {
|
||||
t.Fatalf("add %s = %d", m, code)
|
||||
}
|
||||
}
|
||||
|
||||
msg := "From: Alice <alice@example.com>\r\nSubject: hello\r\n\r\nbody\r\n"
|
||||
if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil {
|
||||
t.Fatalf("lmtp: %v", err)
|
||||
}
|
||||
if relay.count() != 2 {
|
||||
t.Fatalf("relay got %d messages, want 2", relay.count())
|
||||
}
|
||||
got := relay.msgs[0]
|
||||
if !strings.Contains(got.data, "List-Id: Dev <dev.example.org>") || !strings.HasPrefix(got.from, "dev+bounce-") {
|
||||
t.Fatalf("unexpected relayed mail: %+v", got)
|
||||
}
|
||||
if err := lmtpSend(t, a.LMTPAddr, "mallory@evil.com", "dev@example.org", msg); err == nil {
|
||||
t.Fatal("non-member must be rejected")
|
||||
}
|
||||
if relay.count() != 2 {
|
||||
t.Fatal("rejected mail must not be relayed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStartWithoutTokenDisablesAPI(t *testing.T) {
|
||||
relayAddr, _ := startSink(t)
|
||||
a, err := Start(testConfig(t, relayAddr), "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { a.Close() })
|
||||
if a.APIAddr != "" {
|
||||
t.Fatalf("API must be disabled, listening on %s", a.APIAddr)
|
||||
}
|
||||
if conn, err := net.DialTimeout("tcp", a.LMTPAddr, time.Second); err != nil {
|
||||
t.Fatalf("LMTP must still run: %v", err)
|
||||
} else {
|
||||
conn.Close()
|
||||
}
|
||||
}
|
||||
|
||||
func TestStartFailsOnBadDatabase(t *testing.T) {
|
||||
c := testConfig(t, "127.0.0.1:1")
|
||||
c.DB = "/nonexistent-dir/x/p.db"
|
||||
if _, err := Start(c, ""); err == nil {
|
||||
t.Fatal("want error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStartFailsWhenPortIsBusy(t *testing.T) {
|
||||
ln, _ := net.Listen("tcp", "127.0.0.1:0")
|
||||
defer ln.Close()
|
||||
c := testConfig(t, "127.0.0.1:1")
|
||||
c.LMTP.Addr = ln.Addr().String()
|
||||
if _, err := Start(c, ""); err == nil {
|
||||
t.Fatal("want error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCloseIsIdempotentAndStopsListeners(t *testing.T) {
|
||||
relayAddr, _ := startSink(t)
|
||||
a, _ := Start(testConfig(t, relayAddr), "tok")
|
||||
addr := a.LMTPAddr
|
||||
a.Close()
|
||||
a.Close()
|
||||
if c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond); err == nil {
|
||||
c.Close()
|
||||
t.Fatal("LMTP still accepting after Close")
|
||||
}
|
||||
}
|
||||
|
|
@ -113,3 +113,18 @@ func TestFakeRecords(t *testing.T) {
|
|||
t.Fatalf("fake: %+v", f.Sent)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSMTPRelayDefaultBatchSize(t *testing.T) {
|
||||
addr, cap := startServer(t)
|
||||
r := &SMTPRelay{Addr: addr} // BatchSize left at zero
|
||||
var to []string
|
||||
for i := 0; i < 120; i++ {
|
||||
to = append(to, fmt.Sprintf("u%d@x.com", i))
|
||||
}
|
||||
if err := r.Send(context.Background(), "b@example.org", to, []byte("Subject: x\r\n\r\n.\r\n")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(cap.msgs) != 3 {
|
||||
t.Fatalf("default batch size must be %d, got %d transactions", DefaultBatchSize, len(cap.msgs))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -314,3 +314,58 @@ func TestSystemBounceAddressDiscarded(t *testing.T) {
|
|||
t.Fatalf("%v %v", handled, err)
|
||||
}
|
||||
}
|
||||
|
||||
// flaky fails for the listed addresses.
|
||||
type flaky struct {
|
||||
bad map[string]bool
|
||||
sent []string
|
||||
}
|
||||
|
||||
func (f *flaky) Send(_ context.Context, _ string, to []string, _ []byte) error {
|
||||
if f.bad[to[0]] {
|
||||
return errors.New("rejected")
|
||||
}
|
||||
f.sent = append(f.sent, to[0])
|
||||
return nil
|
||||
}
|
||||
|
||||
func TestSendSkipsFailedRecipients(t *testing.T) {
|
||||
e := newEnv(t)
|
||||
res, _ := e.r.Route("alice@example.com", "dev@example.org", []byte(sample))
|
||||
f := &flaky{bad: map[string]bool{"alice@example.com": true}}
|
||||
if err := e.r.Send(e.ctx, f, res); err != nil {
|
||||
t.Fatalf("partial failure must not fail the delivery: %v", err)
|
||||
}
|
||||
if len(f.sent) != 1 || f.sent[0] != "bob@example.com" {
|
||||
t.Fatalf("sent: %v", f.sent)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSendFailsWhenNobodyIsReached(t *testing.T) {
|
||||
e := newEnv(t)
|
||||
res, _ := e.r.Route("alice@example.com", "dev@example.org", []byte(sample))
|
||||
f := &flaky{bad: map[string]bool{"alice@example.com": true, "bob@example.com": true}}
|
||||
if err := e.r.Send(e.ctx, f, res); err == nil {
|
||||
t.Fatal("want an error so the MTA retries")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIncomingListHeadersAreStripped(t *testing.T) {
|
||||
r := setup(t) // no BaseURL: One-Click must not survive from the outside
|
||||
msg := "From: Alice <alice@example.com>\r\nList-Unsubscribe-Post: List-Unsubscribe=One-Click\r\n" +
|
||||
"List-Unsubscribe: <https://evil.example/u>\r\nList-Post: <mailto:evil@x.com>\r\nPrecedence: bulk\r\n\r\nx\r\n"
|
||||
res, err := r.Route("alice@example.com", "dev@example.org", []byte(msg))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
h := header(t, res.Data)
|
||||
if h.Get("List-Unsubscribe-Post") != "" {
|
||||
t.Error("spoofed List-Unsubscribe-Post survived")
|
||||
}
|
||||
if strings.Contains(h.Get("List-Unsubscribe"), "evil") || strings.Contains(h.Get("List-Post"), "evil") {
|
||||
t.Errorf("spoofed list headers survived: %v", h)
|
||||
}
|
||||
if n := len(h["Precedence"]); n != 1 || h.Get("Precedence") != "list" {
|
||||
t.Errorf("Precedence = %v", h["Precedence"])
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,12 @@ func TestPendingTokens(t *testing.T) {
|
|||
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")
|
||||
|
|
|
|||
Loading…
Reference in a new issue