Files
summercms/modules/postcard/locale_test.go
Jakub Zych a0dde086d2 test(postcard): locale fallback, built-in layouts, partials and CSS inlining
- TestTemplateBase, TestTemplateFor and TestSendLocaleFallback pin the
  <template>-<locale> resolution and the order the override source is asked
- TestEnsureLocaleRows (Postgres): rows only for non-default locales without
  files, idempotent, customized content kept while file_hash follows the
  base, base_code from SyncIndex, reset of a fallback row, migrations roll back
- TestBuiltinLayoutsLogo, TestHeaderFooterPartials, TestButtonPartial and
  TestSiteName cover the finished default, system and minimal layouts
- TestInlineCSS, TestInlineCSSOptOut and TestInlineFailure cover inlining,
  the per-layout opt-out and the fallback when the inliner fails
- check-phase35.sh requires the new names (GO_TESTS, DOCKER_TESTS)
2026-11-13 21:31:44 +01:00

203 lines
7.5 KiB
Go

package postcard
import (
"context"
"reflect"
"sync"
"testing"
"testing/fstest"
)
// localeFS is a plugin whose welcome template ships a default-locale file
// and an English file, next to dashed names that are not locale variants.
func localeFS() fstest.MapFS {
tpl := func(subject string) *fstest.MapFile {
return &fstest.MapFile{Data: []byte("subject = \"" + subject + "\"\n==\n" + subject + " body for {{ .name }}.\n")}
}
return fstest.MapFS{
"views/mail/welcome.htm": tpl("Welcome"),
"views/mail/welcome-en.htm": tpl("Welcome EN"),
"views/mail/order.htm": tpl("Order"),
"views/mail/order-paid.htm": tpl("Order paid"),
"views/mail/cancel-notice.htm": tpl("Cancel notice"),
}
}
const (
localeWelcome = "acme.blog::mail.welcome"
localeOrder = "acme.blog::mail.order"
localePaid = "acme.blog::mail.order-paid"
)
// localeCatalog registers localeFS under acme.blog.
func localeCatalog(t *testing.T) *Catalog {
t.Helper()
cat := NewCatalog()
names := []string{localeWelcome, localeWelcome + "-en", localeOrder, localePaid, "acme.blog::mail.cancel-notice"}
if err := cat.Register("acme.blog", localeFS(), names, nil); err != nil {
t.Fatal(err)
}
return cat
}
// recordingOverrides is an OverrideSource that answers by template name and
// records the names it was asked for, in order.
type recordingOverrides struct {
mu sync.Mutex
by map[string]Overrides
asked []string
}
func (r *recordingOverrides) MailOverrides(_ context.Context, name string) (Overrides, error) {
r.mu.Lock()
defer r.mu.Unlock()
r.asked = append(r.asked, name)
return r.by[name], nil
}
func (r *recordingOverrides) names() []string {
r.mu.Lock()
defer r.mu.Unlock()
return append([]string(nil), r.asked...)
}
func TestTemplateBase(t *testing.T) {
t.Parallel()
cases := []struct {
name string
locales []string
want string
}{
{"acme.blog::mail.welcome-en", []string{"en", "pl"}, "acme.blog::mail.welcome"},
{"acme.blog::mail.welcome-pl", []string{"en", "pl"}, "acme.blog::mail.welcome"},
{"acme.blog::mail.welcome-EN", []string{"en", "pl"}, "acme.blog::mail.welcome"},
{"acme.blog::mail.welcome-pt-BR", []string{"pt-BR"}, "acme.blog::mail.welcome"},
// pt-BR wins over a shorter locale that also ends the name.
{"acme.blog::mail.welcome-pt-BR", []string{"BR", "pt-BR"}, "acme.blog::mail.welcome"},
{"acme.blog::mail.cancel-notice", []string{"en", "pl"}, "acme.blog::mail.cancel-notice"},
{"acme.blog::mail.welcome", []string{"en", "pl"}, "acme.blog::mail.welcome"},
// A locale that is not one of the application's is not stripped.
{"acme.blog::mail.welcome-de", []string{"en", "pl"}, "acme.blog::mail.welcome-de"},
{"welcome-en", []string{"en"}, "welcome-en"},
{"acme.blog::mail.welcome-en", nil, "acme.blog::mail.welcome-en"},
}
for _, tc := range cases {
if got := TemplateBase(tc.name, tc.locales); got != tc.want {
t.Errorf("TemplateBase(%q, %v) = %q, want %q", tc.name, tc.locales, got, tc.want)
}
}
}
func TestTemplateFor(t *testing.T) {
t.Parallel()
cat := localeCatalog(t)
cases := []struct {
name string
want string // the Name of the file returned; empty means not found
reason string
}{
{localeWelcome, localeWelcome, "own file"},
{localeWelcome + "-en", localeWelcome + "-en", "own file of a locale"},
{localeWelcome + "-de", localeWelcome, "locale without a file"},
{localeWelcome + "-pt-BR", localeWelcome, "language with a region subtag"},
{localeWelcome + "-zh_Hant", localeWelcome, "underscore subtag"},
{localePaid + "-en", localePaid, "longest registered base"},
{localeOrder + "-en", localeOrder, "shorter base of its own"},
{"acme.blog::mail.cancel-notice", "acme.blog::mail.cancel-notice", "dashed name with a file"},
{localeWelcome + "-now", "", "three letters are not a locale tag"},
{"acme.blog::mail.missing-de", "", "no base template"},
{"acme.shop::mail.welcome-de", "", "another plugin's namespace"},
{"welcome-de", "", "no namespace"},
{localeWelcome + "-", "", "empty tag"},
}
for _, tc := range cases {
f, ok := cat.TemplateFor(tc.name)
if tc.want == "" {
if ok {
t.Errorf("%s (%s): TemplateFor = %q, want not found", tc.name, tc.reason, f.Name)
}
continue
}
if !ok || f.Name != tc.want {
t.Errorf("%s (%s): TemplateFor = %q, %v, want %q", tc.name, tc.reason, f.Name, ok, tc.want)
continue
}
own, _ := cat.Template(tc.want)
if f.Hash != own.Hash || f.Subject != own.Subject {
t.Errorf("%s: file %+v is not %s's", tc.name, f, tc.want)
}
}
// Template keeps answering for registered names only.
if _, ok := cat.Template(localeWelcome + "-de"); ok {
t.Error("Template found a fallback-locale name")
}
}
func TestSendLocaleFallback(t *testing.T) {
t.Parallel()
cat := localeCatalog(t)
de, en := localeWelcome+"-de", localeWelcome+"-en"
deOverride := Overrides{Template: &TemplateOverride{Subject: "Willkommen {{ .name }}", Body: "Hallo."}}
baseOverride := Overrides{Template: &TemplateOverride{Subject: "Base {{ .name }}", Body: "Base body."}}
cases := []struct {
name string
template string
by map[string]Overrides
wantSub string
wantAsked []string
}{
{"own_customization", de, map[string]Overrides{de: deOverride, localeWelcome: baseOverride}, "Willkommen Ada", []string{de}},
{"base_customization", de, map[string]Overrides{localeWelcome: baseOverride}, "Base Ada", []string{de, localeWelcome}},
{"base_file", de, nil, "Welcome", []string{de, localeWelcome}},
{"file_backed_locale", en, map[string]Overrides{localeWelcome: baseOverride}, "Welcome EN", []string{en}},
{"file_backed_locale_customized", en, map[string]Overrides{en: {Template: &TemplateOverride{Subject: "Custom EN", Body: "x"}}}, "Custom EN", []string{en}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
src := &recordingOverrides{by: tc.by}
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{Overrides: src})
sendFixture(t, m, tc.template, "")
got := lastMessage(t, drv)
if got.Subject != tc.wantSub {
t.Errorf("subject = %q, want %q", got.Subject, tc.wantSub)
}
if asked := src.names(); !reflect.DeepEqual(asked, tc.wantAsked) {
t.Errorf("override source asked for %v, want %v", asked, tc.wantAsked)
}
})
}
t.Run("file_versions_match", func(t *testing.T) {
// Without an override source a fallback name sends the base file
// exactly, and a file-backed locale its own file.
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{})
sendFixture(t, m, localeWelcome, "")
base := lastMessage(t, drv)
sendFixture(t, m, de, "")
if got := lastMessage(t, drv); got.Subject != base.Subject || got.HTML != base.HTML || got.Text != base.Text {
t.Errorf("welcome-de = %+v, want the base file %+v", got, base)
}
sendFixture(t, m, en, "")
if got := lastMessage(t, drv); got.Subject != "Welcome EN" || got.Text == base.Text {
t.Errorf("welcome-en = %+v, want its own file", got)
}
})
t.Run("unknown_template", func(t *testing.T) {
src := &recordingOverrides{}
m := NewMailer(cat, NewMemoryDriver(), Options{Overrides: src})
for _, name := range []string{"acme.blog::mail.missing-de", localeWelcome + "-now"} {
err := m.Send(context.Background(), Message{Template: name, To: []string{"ada@example.com"}})
if err == nil || err.Error() != "postcard: unknown template "+name {
t.Errorf("Send(%s) error = %v, want postcard: unknown template %s", name, err, name)
}
}
if asked := src.names(); len(asked) != 0 {
t.Errorf("an unknown template asked the override source for %v", asked)
}
})
}