Self-hosted email delivery platform that enables applications to send emails via HTTP APIs while handling SMTP delivery, templates, storage, security, and analytics. Fully self-hostable alternative to services like SendGrid or Mailgun.
Go email-relayemail-routinghttp-to-smtpmail-deliverymailchimp-alternativemailgun-alternativemailsendermailservermailtemplatemailtestpostmark-alternativesend-emailsendgrid-alternativesendmailtransactional-emailtransactional-outbox
// Copyright (c) 2026 Jonas Kaninda.
//
// This file is part of Posta.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
package email
import (
"mime"
"net/mail"
"regexp"
"strings"
"testing"
)
var encodedWordRe = regexp.MustCompile(`=\?[^?\s]+\?[QqBb]\?[^?\s]*\?=`)
// RFC 2047 ignores the whitespace between encoded-words, but some relays keep
// it, so a subject split mid-word arrives as "subscri ptions". Encoded-words
// must therefore break only at spaces; such a relay may still double one.
func TestBuildMessageSubjectSplitsBetweenWords(t *testing.T) {
for _, subject := range []string{
"Your availability alert — new rooms found for 3 subscriptions",
"Réservation confirmée : votre séjour à l’hôtel Côte d’Azur commence bientôt",
"Места появились по 3 подпискам",
} {
raw := buildMessage("[email protected]", []string{"[email protected]"},
subject, "", "body", nil, nil, "", "", false)
msg, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("built message does not parse: %v", err)
}
value := msg.Header.Get("Subject")
if got, _ := new(mime.WordDecoder).DecodeHeader(value); got != subject {
t.Errorf("subject %q decodes as %q", subject, got)
}
naive := encodedWordRe.ReplaceAllStringFunc(value, func(w string) string {
s, _ := new(mime.WordDecoder).Decode(w)
return s
})
if strings.Join(strings.Fields(naive), " ") != subject {
t.Errorf("subject %q arrives as %q\nencoded: %s", subject, naive, value)
}
}
}
// RFC 5322 recommends header lines of at most 78 characters, and RFC 2047
// limits a line that carries encoded-words to 76, so long subjects must be
// folded.
func TestBuildMessageFoldsLongSubject(t *testing.T) {
for _, subject := range []string{
strings.TrimSpace(strings.Repeat("New rooms found for 3 subscriptions. ", 30)),
strings.TrimSpace(strings.Repeat("Места появились по 3 подпискам. ", 30)),
} {
raw := buildMessage("[email protected]", []string{"[email protected]"},
subject, "", "body", nil, nil, "", "", false)
head, _, _ := strings.Cut(string(raw), "\r\n\r\n")
for _, line := range strings.Split(head, "\r\n") {
limit := 78
if encodedWordRe.MatchString(line) {
limit = 76
}
if len(line) > limit {
t.Errorf("header line is %d characters, want <= %d: %s", len(line), limit, line)
}
}
msg, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("built message does not parse: %v", err)
}
if got, _ := new(mime.WordDecoder).DecodeHeader(msg.Header.Get("Subject")); got != subject {
t.Errorf("folded subject decodes as %q, want %q", got, subject)
}
}
}
// The workspace default sender name is encoded the same way, so a long
// non-ASCII name must also break only between words and stay within the
// RFC 2047 line limit.
func TestBuildMessageDefaultSenderNameSplitsBetweenWords(t *testing.T) {
const name = "Акме — компания, которая производит абсолютно всё"
from := resolveSenderWithDefault("[email protected]", name)
raw := buildMessage(from, []string{"[email protected]"},
"subject", "", "body", nil, nil, "", "", false)
head, _, _ := strings.Cut(string(raw), "\r\n\r\n")
for _, line := range strings.Split(head, "\r\n") {
if encodedWordRe.MatchString(line) && len(line) > 76 {
t.Errorf("header line is %d characters, want <= 76: %s", len(line), line)
}
}
msg, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("built message does not parse: %v", err)
}
addrs, err := msg.Header.AddressList("From")
if err != nil || len(addrs) != 1 || addrs[0].Name != name {
t.Fatalf("From parses as %v (%v), want name %q", addrs, err, name)
}
naive := encodedWordRe.ReplaceAllStringFunc(msg.Header.Get("From"), func(w string) string {
s, _ := new(mime.WordDecoder).Decode(w)
return s
})
if want := name + " <[email protected]>"; strings.Join(strings.Fields(naive), " ") != want {
t.Errorf("From arrives as %q, want %q", naive, want)
}
}
// A readable UTF-8 sender (as stored for display) is encoded only on the wire,
// and senders stored pre-encoded by older versions still go out intact.
func TestBuildMessageEncodesNonASCIISender(t *testing.T) {
const name = "Санаторий.ру"
for _, from := range []string{
`"Санаторий.ру" <[email protected]>`,
"=?UTF-8?b?0KHQsNC90LDRgtC+0YDQuNC5LtGA0YM=?= <[email protected]>",
} {
raw := buildMessage(from, []string{"[email protected]"},
"subject", "", "body", nil, nil, "", "", false)
head, _, _ := strings.Cut(string(raw), "\r\n\r\n")
if !isASCII(head) {
t.Errorf("from %q: header is not ASCII:\n%s", from, head)
}
msg, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("from %q: built message does not parse: %v", from, err)
}
addrs, err := msg.Header.AddressList("From")
if err != nil || len(addrs) != 1 || addrs[0].Name != name || addrs[0].Address != "[email protected]" {
t.Errorf("from %q: From parses as %v (%v), want %q <[email protected]>", from, addrs, err, name)
}
}
}
// Plain text that merely looks like an encoded-word must reach the reader as
// written, not be decoded by their client.
func TestBuildMessageSubjectKeepsLiteralEncodedWordSyntax(t *testing.T) {
const subject = "Use =?UTF-8?Q?hi?= in your template"
raw := buildMessage("[email protected]", []string{"[email protected]"},
subject, "", "body", nil, nil, "", "", false)
msg, err := mail.ReadMessage(strings.NewReader(string(raw)))
if err != nil {
t.Fatalf("built message does not parse: %v", err)
}
if got, _ := new(mime.WordDecoder).DecodeHeader(msg.Header.Get("Subject")); got != subject {
t.Errorf("subject decodes as %q, want %q", got, subject)
}
}