Skip to content

armgit / posta

Public Imported from GitHub
0

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.

6.4 KB
Raw Blame
// 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)
	}
}