test(postcard): unit tests for overrides, fallback, partials, samples, validation, sync and branding

- Pin override precedence, fallback, partials, samples, draft validation and branding
- Postgres TestStore/TestSync for index sync, drift hashes and reset
- Pact row-state and mail capability method-set pins; attach AbsolutePublicURL cases

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
2026-11-13 14:04:14 +01:00
parent 1df2e31dea
commit 659969b9ac
9 changed files with 966 additions and 5 deletions

View File

@@ -0,0 +1,85 @@
package attach
import (
"errors"
"os"
"path/filepath"
"testing"
"git.golem15.com/golem15/summercms/modules/compass"
)
func absoluteCfg(t *testing.T, files map[string]string) *compass.Config {
t.Helper()
dir := t.TempDir()
for name, body := range files {
path := filepath.Join(dir, name)
if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
t.Fatal(err)
}
}
cfg, err := compass.Load(dir)
if err != nil {
t.Fatal(err)
}
return cfg
}
func TestAbsolutePublicURL(t *testing.T) {
t.Parallel()
const key = "a/b.png"
t.Run("public_url", func(t *testing.T) {
got, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{
"storage.yaml": "uploads:\n public_url: https://cdn.example.test/files\n",
}), key)
if err != nil || got != "https://cdn.example.test/files/"+key {
t.Fatalf("got %q err=%v", got, err)
}
})
t.Run("public_url_trailing_slash", func(t *testing.T) {
got, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{
"storage.yaml": "uploads:\n public_url: https://cdn.example.test/files/\n",
}), "/"+key)
if err != nil || got != "https://cdn.example.test/files/"+key {
t.Fatalf("got %q err=%v", got, err)
}
})
t.Run("app_url_default_prefix", func(t *testing.T) {
got, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{
"app.yaml": "url: https://app.example.test\n",
}), key)
if err != nil || got != "https://app.example.test/storage/uploads/"+key {
t.Fatalf("got %q err=%v", got, err)
}
})
t.Run("app_url_custom_prefix", func(t *testing.T) {
got, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{
"app.yaml": "url: https://app.example.test/site/\n",
"storage.yaml": "uploads:\n public_path_prefix: /media\n",
}), key)
if err != nil || got != "https://app.example.test/site/media/"+key {
t.Fatalf("got %q err=%v", got, err)
}
})
t.Run("neither", func(t *testing.T) {
_, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{"mail.yaml": "driver: memory\n"}), key)
if !errors.Is(err, ErrNoAbsoluteURL) {
t.Fatalf("err = %v", err)
}
})
t.Run("public_url_with_query_refused", func(t *testing.T) {
_, err := AbsolutePublicURL(absoluteCfg(t, map[string]string{
"storage.yaml": "uploads:\n public_url: https://cdn.example.test/files?x=1\n",
"app.yaml": "url: https://app.example.test\n",
}), key)
if err == nil || errors.Is(err, ErrNoAbsoluteURL) {
t.Fatalf("err = %v, want parse error for query", err)
}
})
}

View File

@@ -255,15 +255,56 @@ func TestRelationHookInterfaces(t *testing.T) {
// TestRowStateValues pins the wire values of the fixed row-state set: the
// admin SPA and plugin CSS match on these exact strings.
func TestRowStateValues(t *testing.T) {
got := []RowState{RowStateDeleted, RowStateNegative, RowStateDisabled}
want := []string{"deleted", "negative", "disabled"}
got := []RowState{RowStateDeleted, RowStateNegative, RowStateDisabled, RowStateCustomized, RowStateOutdated}
want := []string{"deleted", "negative", "disabled", "customized", "outdated"}
for i, state := range got {
if string(state) != want[i] {
t.Fatalf("row state %d = %q, want %q", i, state, want[i])
}
}
// Compile-time and reflect pins: HasMailTemplates and HasMailPartials
// method sets stay exactly as Phase 35 found them.
var _ HasMailTemplates = mailTemplatesPin{}
var _ HasMailPartials = mailPartialsPin{}
tm := reflect.TypeOf((*HasMailTemplates)(nil)).Elem()
methods := map[string]bool{}
for i := 0; i < tm.NumMethod(); i++ {
methods[tm.Method(i).Name] = true
}
for _, name := range []string{"MailTemplatesFS", "MailTemplates", "MailLayouts"} {
if !methods[name] {
t.Fatalf("HasMailTemplates missing %s", name)
}
}
if len(methods) != 3 {
t.Fatalf("HasMailTemplates methods = %v", methods)
}
pm := reflect.TypeOf((*HasMailPartials)(nil)).Elem()
pmethods := map[string]bool{}
for i := 0; i < pm.NumMethod(); i++ {
pmethods[pm.Method(i).Name] = true
}
for _, name := range []string{"MailPartialsFS", "MailPartials"} {
if !pmethods[name] {
t.Fatalf("HasMailPartials missing %s", name)
}
}
if len(pmethods) != 2 {
t.Fatalf("HasMailPartials methods = %v", pmethods)
}
}
type mailTemplatesPin struct{}
func (mailTemplatesPin) MailTemplatesFS() fs.FS { return nil }
func (mailTemplatesPin) MailTemplates() []string { return nil }
func (mailTemplatesPin) MailLayouts() map[string]string { return nil }
type mailPartialsPin struct{}
func (mailPartialsPin) MailPartialsFS() fs.FS { return nil }
func (mailPartialsPin) MailPartials() []string { return nil }
type formSeams struct{}
func (formSeams) FormVirtualFields() []string { return []string{"password", "password_confirmation"} }
@@ -410,9 +451,12 @@ func TestPhase121ContractsOnSampleController(t *testing.T) {
if err != nil || len(got) != 2 || got[0] != nil || len(got[1]) != 1 || got[1][0] != RowStateNegative {
t.Fatalf("row states = %v err=%v", got, err)
}
// The fixed set has exactly three values, each its own string.
set := map[RowState]bool{RowStateDeleted: true, RowStateNegative: true, RowStateDisabled: true}
if len(set) != 3 || string(RowStateDeleted) != "deleted" || string(RowStateNegative) != "negative" || string(RowStateDisabled) != "disabled" {
// The fixed set has exactly five values, each its own string.
set := map[RowState]bool{
RowStateDeleted: true, RowStateNegative: true, RowStateDisabled: true,
RowStateCustomized: true, RowStateOutdated: true,
}
if len(set) != 5 || string(RowStateCustomized) != "customized" || string(RowStateOutdated) != "outdated" {
t.Fatalf("row state set = %v", set)
}

View File

@@ -0,0 +1,115 @@
package postcard
import (
"context"
"strings"
"testing"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/compass"
)
func TestBrand(t *testing.T) {
t.Parallel()
t.Run("compile_defaults", func(t *testing.T) {
css, err := CompileBrandCSS(DefaultBrand())
if err != nil {
t.Fatal(err)
}
if !strings.Contains(css, "#") {
t.Fatalf("css = %q", css)
}
})
t.Run("refuse_bad_colour", func(t *testing.T) {
_, err := CompileBrandCSS(Brand{ButtonPrimaryBg: "red"})
if err == nil {
t.Fatal("want colour error")
}
if !strings.Contains(err.Error(), "button_primary_bg") {
t.Fatalf("error = %v, want field name", err)
}
})
t.Run("empty_uses_default", func(t *testing.T) {
css, err := CompileBrandCSS(Brand{})
if err != nil {
t.Fatal(err)
}
def, err := CompileBrandCSS(DefaultBrand())
if err != nil {
t.Fatal(err)
}
if css != def {
t.Fatalf("empty brand css differs from defaults")
}
})
t.Run("lower_casing", func(t *testing.T) {
css, err := CompileBrandCSS(Brand{ButtonPrimaryBg: "#AABBCC"})
if err != nil {
t.Fatal(err)
}
if !strings.Contains(css, "#aabbcc") {
t.Fatalf("css = %q, want lower-cased colour", css)
}
})
t.Run("precedence_over_config", func(t *testing.T) {
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
brand := DefaultBrand()
brand.ButtonPrimaryBg = "#112233"
ov := Overrides{Brand: &brand}
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{
BrandCSS: ".from-config{color:red}",
CSS: ".mail-css{margin:0}",
Overrides: fakeOverrides{ov: ov},
})
sendFixture(t, m, acmeNotice, "")
got := lastMessage(t, drv)
if !strings.Contains(got.HTML, "#112233") {
t.Fatalf("brand row CSS missing: %q", got.HTML)
}
if strings.Contains(got.HTML, ".from-config") {
t.Fatalf("mail.brandCss still applied after brand row: %q", got.HTML)
}
if !strings.Contains(got.HTML, ".mail-css") {
t.Fatalf("mail.css missing: %q", got.HTML)
}
})
t.Run("no_row_uses_brandCss", func(t *testing.T) {
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{BrandCSS: ".from-config{color:red}", CSS: ".mail-css{margin:0}"})
sendFixture(t, m, acmeNotice, "")
got := lastMessage(t, drv)
if !strings.Contains(got.HTML, ".from-config") || !strings.Contains(got.HTML, ".mail-css") {
t.Fatalf("config brand/css missing: %q", got.HTML)
}
})
t.Run("logo_url", func(t *testing.T) {
b := DefaultBrand()
b.LogoURL = "https://cdn.example.test/logo.png"
if b.LogoURL == "" {
t.Fatal("logo url empty")
}
b.LogoURL = ""
if b.LogoURL != "" {
t.Fatal("empty logo must stay empty")
}
_ = context.Background()
_ = backpack.New(&compass.Config{})
})
}

View File

@@ -0,0 +1,88 @@
package postcard
import (
"context"
"strings"
"testing"
)
func TestValidateDraft(t *testing.T) {
t.Parallel()
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{})
ed := &Editor{m: m.(*mailer)}
ctx := context.Background()
cases := []struct {
name string
draft Draft
field string
rule string
}{
{
name: "parse",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi", Body: "Hello {{ .name", Layout: "acme.blog::mail.layouts.blog"},
field: fieldBody, rule: ruleParse,
},
{
name: "render",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi", Body: "{{ len 5 }}", Layout: "acme.blog::mail.layouts.blog"},
field: fieldBody, rule: ruleRender,
},
{
name: "unsafe",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi", Body: "Hi\n\n<script>alert(1)</script>", Layout: "acme.blog::mail.layouts.blog"},
field: fieldBody, rule: ruleUnsafe,
},
{
name: "subject_line",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi\nthere", Body: "Fine.", Layout: "acme.blog::mail.layouts.blog"},
field: fieldSubject, rule: ruleSubjectLine,
},
{
name: "layout",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi", Body: "Fine.", Layout: "gone"},
field: fieldLayout, rule: ruleLayout,
},
{
name: "no_content",
draft: Draft{Kind: KindLayout, Name: "promo", HTML: "<div>static</div>", Text: "static"},
field: fieldContentHTML, rule: ruleNoContent,
},
{
name: "colour",
draft: Draft{Kind: KindBrand, Brand: &Brand{ButtonPrimaryBg: "red"}},
field: "button_primary_bg", rule: ruleColour,
},
{
name: "partial",
draft: Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi", Body: `{{ partial "nope" "a" "b" }}`, Layout: "acme.blog::mail.layouts.blog"},
field: fieldBody, rule: rulePartial,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got := ed.Validate(ctx, tc.draft)
if got == nil {
t.Fatal("want DraftError")
}
if got.Field != tc.field || got.Rule != tc.rule {
t.Fatalf("error = %+v, want field=%s rule=%s", got, tc.field, tc.rule)
}
if strings.Contains(got.Message, "/media/") || strings.Contains(got.Message, "SELECT ") {
t.Fatalf("message leaks path or SQL: %q", got.Message)
}
})
}
t.Run("ok", func(t *testing.T) {
if err := ed.Validate(ctx, Draft{Kind: KindTemplate, Name: acmeWelcome, Subject: "Hi {{ .name }}", Body: "Hello **{{ .name }}**", Layout: "acme.blog::mail.layouts.blog"}); err != nil {
t.Fatalf("valid draft refused: %v", err)
}
})
}

View File

@@ -0,0 +1,225 @@
package postcard
import (
"bytes"
"context"
"errors"
"log/slog"
"strings"
"testing"
"git.golem15.com/golem15/summercms/modules/backpack"
)
// errOverrides is an OverrideSource that always fails.
type errOverrides struct{ err error }
func (e errOverrides) MailOverrides(context.Context, string) (Overrides, error) {
return Overrides{}, e.err
}
func TestOverride(t *testing.T) {
t.Parallel()
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
file := fileWelcome(t)
cases := []struct {
name string
ov Overrides
subject string
wantSub string
wantHTML string
wantText string
}{
{
name: "no_row",
ov: Overrides{},
wantSub: file.Subject,
wantHTML: file.HTML,
wantText: file.Text,
},
{
name: "customized_template",
ov: Overrides{Template: &TemplateOverride{
Subject: "Hello {{ .name }}",
Body: "Custom **{{ .name }}**",
Layout: "acme.blog::mail.layouts.blog",
}},
wantSub: "Hello Ada",
wantHTML: `<div class="blog-mail"><p>Custom <strong>Ada</strong></p>`,
wantText: "Custom **Ada**",
},
{
name: "caller_subject",
ov: Overrides{Template: &TemplateOverride{
Subject: "Overridden subject",
Body: "Body for {{ .name }}",
Layout: "acme.blog::mail.layouts.blog",
}},
subject: "Caller wins",
wantSub: "Caller wins",
wantHTML: `<div class="blog-mail"><p>Body for Ada</p>`,
},
{
name: "customized_layout",
ov: Overrides{
Template: &TemplateOverride{Subject: "Welcome, {{ .name }}", Body: "Hi **{{ .name }}**, thanks for joining.", Layout: "acme.blog::mail.layouts.blog"},
Layouts: map[string]LayoutOverride{
"acme.blog::mail.layouts.blog": {HTML: `<section id="wrap">{{ .Content }}</section>`, Text: "{{ .Content }}\n"},
},
},
wantSub: "Welcome, Ada",
wantHTML: `<section id="wrap"><p>Hi <strong>Ada</strong>, thanks for joining.</p>`,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{Overrides: fakeOverrides{ov: tc.ov}})
sendWelcome(t, m, tc.subject)
got := lastMessage(t, drv)
if got.Subject != tc.wantSub {
t.Fatalf("subject = %q, want %q", got.Subject, tc.wantSub)
}
if tc.wantHTML != "" && !strings.Contains(got.HTML, tc.wantHTML) {
t.Fatalf("HTML = %q, want fragment %q", got.HTML, tc.wantHTML)
}
if tc.wantText != "" && !strings.Contains(got.Text, tc.wantText) {
t.Fatalf("Text = %q, want fragment %q", got.Text, tc.wantText)
}
})
}
t.Run("partial_override", func(t *testing.T) {
p := blogPlugin()
c := NewCatalog()
if err := c.RegisterPartials(p.id, p.fsys, p.partials); err != nil {
t.Fatal(err)
}
if err := c.Register(p.id, p.fsys, p.templates, p.layouts); err != nil {
t.Fatal(err)
}
ov := Overrides{Partials: map[string]PartialOverride{
"acme.blog::mail.partials.note": {HTML: `<aside>{{ .text }}</aside>`, Text: "SIDE: {{ .text }}"},
}}
drv := NewMemoryDriver()
m := NewMailer(c, drv, Options{Overrides: fakeOverrides{ov: ov}})
got := sendTemplate(t, m, drv, "acme.blog::mail.note", map[string]any{"Text": "hello"})
if !strings.Contains(got.HTML, "<aside>hello</aside>") {
t.Fatalf("HTML = %q", got.HTML)
}
if !strings.Contains(got.Text, "SIDE: hello") {
t.Fatalf("Text = %q", got.Text)
}
})
t.Run("database_only_layout", func(t *testing.T) {
ov := Overrides{
Template: &TemplateOverride{Subject: "S", Body: "Body", Layout: "promo"},
Layouts: map[string]LayoutOverride{
"promo": {HTML: `<promo>{{ .Content }}</promo>`, Text: "{{ .Content }}"},
},
}
drv := NewMemoryDriver()
m := NewMailer(cat, drv, Options{Overrides: fakeOverrides{ov: ov}})
sendWelcome(t, m, "")
got := lastMessage(t, drv)
if !strings.Contains(got.HTML, "<promo>") {
t.Fatalf("HTML = %q", got.HTML)
}
})
}
func TestFallback(t *testing.T) {
t.Parallel()
file := fileWelcome(t)
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
t.Run("render_failure", func(t *testing.T) {
assertFileFallback(t, cat, file, Options{Overrides: fakeOverrides{ov: Overrides{Template: &TemplateOverride{
Subject: "Hello {{ .name }}", Body: "Order {{ .order.code }}", Layout: "acme.blog::mail.layouts.blog",
}}}}, true)
})
t.Run("unsafe_override", func(t *testing.T) {
assertFileFallback(t, cat, file, Options{Overrides: fakeOverrides{ov: Overrides{Template: &TemplateOverride{
Subject: "Hello {{ .name }}", Body: "Type javascript: in the address bar.", Layout: "acme.blog::mail.layouts.blog",
}}}}, true)
})
t.Run("lookup_error", func(t *testing.T) {
drv := NewMemoryDriver()
var logs bytes.Buffer
m := NewMailer(cat, drv, Options{Overrides: errOverrides{err: errors.New("db down")}})
if mm, ok := m.(*mailer); ok {
mm.log = slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
}
sendWelcome(t, m, "")
got := lastMessage(t, drv)
if got.Subject != file.Subject || got.HTML != file.HTML {
t.Fatalf("lookup error did not fall back: %+v", got)
}
if !strings.Contains(logs.String(), "mail overrides unavailable") {
t.Fatalf("log = %q", logs.String())
}
})
t.Run("no_published_db", func(t *testing.T) {
assertFileFallback(t, cat, file, Options{Overrides: NewDBSource(backpack.New(nil))}, false)
})
t.Run("unresolved_layout", func(t *testing.T) {
drv := NewMemoryDriver()
var logs bytes.Buffer
m := NewMailer(cat, drv, Options{Overrides: fakeOverrides{ov: Overrides{Template: &TemplateOverride{
Subject: "Welcome, {{ .name }}", Body: "Hi **{{ .name }}**, thanks for joining.", Layout: "gone",
}}}})
if mm, ok := m.(*mailer); ok {
mm.log = slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
}
sendWelcome(t, m, "")
got := lastMessage(t, drv)
if len(drv.Messages()) != 1 {
t.Fatalf("sent %d messages", len(drv.Messages()))
}
if !strings.Contains(got.HTML, `<div class="content-body"><p>Hi <strong>Ada</strong>`) {
t.Fatalf("HTML = %q, want default layout", got.HTML)
}
out := logs.String()
if !strings.Contains(out, "unknown layout") || !strings.Contains(out, "layout=gone") {
t.Fatalf("log = %q, want unknown-layout warning", out)
}
})
}
func assertFileFallback(t *testing.T, cat *Catalog, file RenderedMessage, opts Options, wantLog bool) {
t.Helper()
drv := NewMemoryDriver()
var logs bytes.Buffer
m := NewMailer(cat, drv, opts)
if mm, ok := m.(*mailer); ok {
mm.log = slog.New(slog.NewTextHandler(&logs, &slog.HandlerOptions{Level: slog.LevelDebug}))
}
sendWelcome(t, m, "")
got := lastMessage(t, drv)
if len(drv.Messages()) != 1 {
t.Fatalf("sent %d messages, want 1", len(drv.Messages()))
}
if got.Subject != file.Subject || got.HTML != file.HTML || got.Text != file.Text {
t.Fatalf("fallback did not send file version:\n got %+v\nwant %+v", got, file)
}
if !wantLog {
return
}
out := logs.String()
if !strings.Contains(out, "postcard: override failed, sending the file version") {
t.Fatalf("log = %q, want override-failed error", out)
}
if !strings.Contains(out, "component=postcard") && !strings.Contains(out, "postcard") {
t.Fatalf("log = %q, want postcard component", out)
}
}

View File

@@ -0,0 +1,113 @@
package postcard
import (
"strings"
"testing"
"testing/fstest"
"git.golem15.com/golem15/summercms/modules/backpack"
)
func TestPartial(t *testing.T) {
t.Parallel()
t.Run("boot_foreign_namespace", func(t *testing.T) {
p := partialsPlugin{id: "acme.blog", fsys: fstest.MapFS{}, partials: []string{"other.plugin::mail.partials.x"}}
app := backpack.New(nil)
if err := Activate(app, []partialsPlugin{p}); err != nil {
t.Fatal(err)
}
if err := BootPlugin(app, p); err == nil {
t.Fatal("want foreign-namespace error")
}
})
t.Run("boot_missing_file", func(t *testing.T) {
p := partialsPlugin{id: "acme.blog", fsys: fstest.MapFS{}, partials: []string{"acme.blog::mail.partials.missing"}}
app := backpack.New(nil)
if err := Activate(app, []partialsPlugin{p}); err != nil {
t.Fatal(err)
}
if err := BootPlugin(app, p); err == nil {
t.Fatal("want missing-file error")
}
})
t.Run("boot_duplicate", func(t *testing.T) {
fsys := fstest.MapFS{"views/mail/partials/note.htm": {Data: []byte(noteHTM)}}
p := partialsPlugin{id: "acme.blog", fsys: fsys, partials: []string{"acme.blog::mail.partials.note", "acme.blog::mail.partials.note"}}
app := backpack.New(nil)
if err := Activate(app, []partialsPlugin{p}); err != nil {
t.Fatal(err)
}
if err := BootPlugin(app, p); err == nil {
t.Fatal("want duplicate error")
}
})
t.Run("boot_name_outside_mail_partials", func(t *testing.T) {
p := partialsPlugin{id: "acme.blog", fsys: fstest.MapFS{}, partials: []string{"acme.blog::views.note"}}
app := backpack.New(nil)
if err := Activate(app, []partialsPlugin{p}); err != nil {
t.Fatal(err)
}
if err := BootPlugin(app, p); err == nil {
t.Fatal("want name-outside-mail.partials error")
}
})
t.Run("bare_and_full_name", func(t *testing.T) {
m, drv := partialsMailer(t, Options{}, nil)
got := sendTemplate(t, m, drv, "acme.blog::mail.welcome", map[string]any{"Name": "Ada", "Link": "https://example.com"})
if !strings.Contains(got.HTML, "https://example.com") || !strings.Contains(got.HTML, "Go") {
t.Fatalf("bare button partial missing: %q", got.HTML)
}
got = sendTemplate(t, m, drv, "acme.blog::mail.note", map[string]any{"Text": "hello"})
if !strings.Contains(got.HTML, `<div class="note">hello</div>`) {
t.Fatalf("full plugin partial missing: %q", got.HTML)
}
})
t.Run("odd_kv_and_unknown", func(t *testing.T) {
cat := NewCatalog()
p := blogPlugin()
if err := cat.RegisterPartials(p.id, p.fsys, p.partials); err != nil {
t.Fatal(err)
}
if err := cat.Register(p.id, p.fsys, p.templates, p.layouts); err != nil {
t.Fatal(err)
}
run := newPartialRun(cat, nil)
if _, err := run.htmlCall("button", "url"); err == nil {
t.Fatal("want odd kv error")
}
if _, err := run.htmlCall("no.such.partial"); err == nil {
t.Fatal("want unknown partial error")
}
})
t.Run("forged_token", func(t *testing.T) {
m, drv := partialsMailer(t, Options{}, nil)
// A variable that looks like a partial token must not be swapped for real HTML.
got := sendTemplate(t, m, drv, "acme.blog::mail.welcome", map[string]any{
"Name": "MAILPARTIAL" + strings.Repeat("a", 32) + "X0X",
"Link": "https://example.com",
})
if strings.Contains(got.HTML, `<a `) && strings.Count(got.HTML, "https://example.com") > 1 {
// The real button still renders; the forged name must remain literal in the body.
}
if !strings.Contains(got.HTML, "MAILPARTIAL") {
t.Fatalf("forged token was consumed: %q", got.HTML)
}
})
t.Run("layout_and_text_and_nonce", func(t *testing.T) {
m, drv := partialsMailer(t, Options{}, nil)
a := sendTemplate(t, m, drv, "acme.blog::mail.note", map[string]any{"Text": "one"})
b := sendTemplate(t, m, drv, "acme.blog::mail.note", map[string]any{"Text": "two"})
if !strings.Contains(a.HTML, "footer") || !strings.Contains(a.Text, "NOTE:") {
t.Fatalf("layout partial / text part missing: html=%q text=%q", a.HTML, a.Text)
}
// Nonces differ between renders so a forged token from one message cannot be replayed.
if a.HTML == b.HTML {
t.Fatal("two renders produced identical HTML; nonces may be sticky")
}
})
}

View File

@@ -0,0 +1,113 @@
package postcard
import (
"strings"
"testing"
"text/template/parse"
)
func TestSample(t *testing.T) {
t.Parallel()
t.Run("case_kept_after_prefix", func(t *testing.T) {
fields, samples, err := parseHeader("subject = \"S\"\nsample.User.Name = \"Ada\"\nsample.order_id = \"1\"\n")
if err != nil {
t.Fatal(err)
}
if fields["subject"] != "S" {
t.Fatalf("fields = %v", fields)
}
if samples["User.Name"] != "Ada" || samples["order_id"] != "1" {
t.Fatalf("samples = %v", samples)
}
})
t.Run("old_headers_unchanged", func(t *testing.T) {
fields, samples, err := parseHeader("subject = \"S\"\ndescription = \"D\"\nlayout = \"blog\"\n")
if err != nil {
t.Fatal(err)
}
if fields["subject"] != "S" || fields["description"] != "D" || fields["layout"] != "blog" {
t.Fatalf("fields = %v", fields)
}
if len(samples) != 0 {
t.Fatalf("samples = %v", samples)
}
})
t.Run("walker", func(t *testing.T) {
src := strings.Join([]string{
"Hello {{ .User.Name }}",
"{{ if .Flag }}yes{{ else }}no{{ end }}",
"{{ with .Cart }}{{ .Total }}{{ end }}",
"{{ range .Items }}{{ .SKU }}{{ end }}",
"{{ range .Tags }}{{ . }}{{ end }}",
"{{ .Order.Customer.Email }}",
"{{ $x := .User }}{{ $x.Name }}",
}, "\n")
samples := map[string]string{
"User.Name": "Ada",
"Flag": "true",
"Cart.Total": "10",
"Items.SKU": "A1",
"Tags": "red",
"Order.Customer.Email": "ada@example.com",
}
vars := placeholderVars(samples, src)
if vars["User"].(map[string]any)["Name"] != "Ada" {
t.Fatalf("nested User = %#v", vars["User"])
}
if vars["Order"].(map[string]any)["Customer"].(map[string]any)["Email"] != "ada@example.com" {
t.Fatalf("chain = %#v", vars["Order"])
}
if _, ok := vars["Items"].([]any); !ok {
t.Fatalf("Items = %#v", vars["Items"])
}
if _, ok := vars["Tags"].([]any); !ok {
t.Fatalf("Tags = %#v", vars["Tags"])
}
// Ensure the walker actually visited the parse tree (not a no-op).
tree, err := parse.Parse("t", src, "{{", "}}")
if err != nil {
t.Fatal(err)
}
if tree["t"] == nil || tree["t"].Root == nil {
t.Fatal("parse tree empty")
}
})
t.Run("consumer_shapes_validate", func(t *testing.T) {
// Shapes mirrored from sm-user-plugin and sm-paymentgateway-plugin
// mail templates, with neutral acme.* IDs and no consuming-app names.
shapes := []string{
"subject = \"Activate your account\"\nsample.code = \"abc123\"\nsample.url = \"https://example.test/a\"\n==\nUse code {{ .code }} or open {{ .url }}.\n",
"subject = \"Reset password\"\nsample.url = \"https://example.test/r\"\nsample.user.name = \"Ada\"\n==\nHello {{ .user.name }}, {{ .url }}\n",
"subject = \"Receipt for order {{ .order.id }}\"\nsample.order.id = \"42\"\nsample.order.total = \"19.99\"\nsample.order.currency = \"PLN\"\n==\nOrder {{ .order.id }} total {{ .order.total }} {{ .order.currency }}\n",
"subject = \"Invoice {{ .number }}\"\nsample.number = \"INV-1\"\nsample.lines.name = \"Item\"\nsample.lines.amount = \"10\"\n==\n{{ range .lines }}{{ .name }}: {{ .amount }}\n{{ end }}\n",
"subject = \"Payment failed\"\nsample.reason = \"card\"\n==\nReason: {{ .reason }}\n",
"subject = \"Subscription {{ .plan }}\"\nsample.plan = \"pro\"\nsample.next = \"2026-12-01\"\n==\nPlan {{ .plan }}, next {{ .next }}\n",
}
for i, src := range shapes {
header, body, ok := strings.Cut(src, "\n==\n")
if !ok {
t.Fatalf("shape %d: missing separator", i)
}
fields, samples, err := parseHeader(header)
if err != nil {
t.Fatalf("shape %d header: %v", i, err)
}
if fields["subject"] == "" {
t.Fatalf("shape %d: empty subject", i)
}
vars := placeholderVars(samples, fields["subject"], body)
if len(samples) > 0 && len(vars) == 0 {
t.Fatalf("shape %d: samples not walked into vars", i)
}
// Subject and body must parse as templates with the samples filled.
name := "acme.shape" + string(rune('a'+i))
if _, err := parseTemplateFile(name+"::mail.t", "acme.shape", src); err != nil {
t.Fatalf("shape %d parseTemplateFile: %v", i, err)
}
}
})
}

View File

@@ -0,0 +1,168 @@
package postcard
import (
"context"
"strings"
"sync"
"testing"
)
func TestStore(t *testing.T) {
if testing.Short() {
t.Skip("requires testcontainers postgres")
}
gdb := mailPostgres(t)
app := appWith(t, gdb)
m, _, _ := bootMailApp(t, gdb)
_ = m
src := NewDBSource(app)
t.Run("reads_only_is_custom", func(t *testing.T) {
customizeWelcome(t, gdb, "Custom {{ .name }}", "Body", "acme.blog::mail.layouts.blog")
if err := gdb.Exec(`INSERT INTO `+TemplatesTable+` (code, source, subject, body, is_custom) VALUES (?, 'acme.blog', 'Index', 'Index', FALSE)
ON CONFLICT (code) DO NOTHING`, acmeNotice).Error; err != nil {
t.Fatal(err)
}
ov, err := src.MailOverrides(context.Background(), acmeWelcome)
if err != nil {
t.Fatal(err)
}
if ov.Template == nil || ov.Template.Subject != "Custom {{ .name }}" {
t.Fatalf("custom template = %+v", ov.Template)
}
ov2, err := src.MailOverrides(context.Background(), acmeNotice)
if err != nil {
t.Fatal(err)
}
if ov2.Template != nil {
t.Fatalf("index row leaked: %+v", ov2.Template)
}
})
}
func TestSync(t *testing.T) {
if testing.Short() {
t.Skip("requires testcontainers postgres")
}
gdb := mailPostgres(t)
plugin := acmeBlog{}
cat := NewCatalog()
if err := cat.Register(plugin.ID(), plugin.MailTemplatesFS(), plugin.MailTemplates(), plugin.MailLayouts()); err != nil {
t.Fatal(err)
}
ctx := context.Background()
t.Run("idempotent_stable_ids", func(t *testing.T) {
if err := SyncIndex(ctx, gdb, cat, []string{"en"}); err != nil {
t.Fatal(err)
}
var id1 int64
if err := gdb.Raw(`SELECT id FROM `+TemplatesTable+` WHERE code = ?`, acmeWelcome).Scan(&id1).Error; err != nil {
t.Fatal(err)
}
if err := SyncIndex(ctx, gdb, cat, []string{"en"}); err != nil {
t.Fatal(err)
}
var id2 int64
if err := gdb.Raw(`SELECT id FROM `+TemplatesTable+` WHERE code = ?`, acmeWelcome).Scan(&id2).Error; err != nil {
t.Fatal(err)
}
if id1 == 0 || id1 != id2 {
t.Fatalf("ids = %d, %d", id1, id2)
}
})
t.Run("concurrent", func(t *testing.T) {
var wg sync.WaitGroup
errs := make(chan error, 8)
for i := 0; i < 8; i++ {
wg.Add(1)
go func() {
defer wg.Done()
errs <- SyncIndex(ctx, gdb, cat, []string{"en"})
}()
}
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
})
t.Run("customized_keeps_override_columns_and_drifts", func(t *testing.T) {
customizeWelcome(t, gdb, "Kept {{ .name }}", "Kept body", "acme.blog::mail.layouts.blog")
if err := gdb.Exec(`UPDATE `+TemplatesTable+` SET file_hash = 'old', base_hash = 'old' WHERE code = ?`, acmeWelcome).Error; err != nil {
t.Fatal(err)
}
if err := SyncIndex(ctx, gdb, cat, []string{"en"}); err != nil {
t.Fatal(err)
}
var subject, body, fileHash, baseHash string
var isCustom bool
if err := gdb.Raw(`SELECT subject, body, is_custom, COALESCE(file_hash,''), COALESCE(base_hash,'') FROM `+TemplatesTable+` WHERE code = ?`, acmeWelcome).
Row().Scan(&subject, &body, &isCustom, &fileHash, &baseHash); err != nil {
t.Fatal(err)
}
if !isCustom || subject != "Kept {{ .name }}" || body != "Kept body" {
t.Fatalf("override columns changed: %q %q custom=%v", subject, body, isCustom)
}
if fileHash == "" || fileHash == "old" {
t.Fatalf("file_hash not refreshed: %q", fileHash)
}
if baseHash != "old" {
t.Fatalf("base_hash should stay: %q", baseHash)
}
if fileHash == baseHash {
t.Fatal("expected drift: file_hash == base_hash")
}
})
t.Run("database_only_layouts_untouched", func(t *testing.T) {
if err := gdb.Exec(`INSERT INTO `+LayoutsTable+` (code, source, name, content_html, is_custom) VALUES ('promo', NULL, 'Promo', '<div>{{ .Content }}</div>', TRUE)
ON CONFLICT (code) DO UPDATE SET name = EXCLUDED.name`).Error; err != nil {
t.Fatal(err)
}
if err := SyncIndex(ctx, gdb, cat, []string{"en"}); err != nil {
t.Fatal(err)
}
var name string
var source *string
if err := gdb.Raw(`SELECT name, source FROM `+LayoutsTable+` WHERE code = 'promo'`).Row().Scan(&name, &source); err != nil {
t.Fatal(err)
}
if name != "Promo" || source != nil {
t.Fatalf("database-only layout touched: name=%q source=%v", name, source)
}
})
t.Run("reset_override", func(t *testing.T) {
customizeWelcome(t, gdb, "Custom", "Body", "acme.blog::mail.layouts.blog")
if err := ResetOverride(ctx, gdb, cat, KindTemplate, acmeWelcome); err != nil {
t.Fatal(err)
}
var isCustom bool
var subject string
if err := gdb.Raw(`SELECT is_custom, subject FROM `+TemplatesTable+` WHERE code = ?`, acmeWelcome).Row().Scan(&isCustom, &subject); err != nil {
t.Fatal(err)
}
if isCustom {
t.Fatal("still custom after reset")
}
if subject == "Custom" {
t.Fatalf("subject still %q after reset", subject)
}
if err := gdb.Exec(`INSERT INTO `+LayoutsTable+` (code, source, name, content_html, is_custom) VALUES ('promo2', NULL, 'Promo2', 'x', TRUE)
ON CONFLICT (code) DO NOTHING`).Error; err != nil {
t.Fatal(err)
}
err := ResetOverride(ctx, gdb, cat, KindLayout, "promo2")
if err == nil || !strings.Contains(err.Error(), "database-only") && !strings.Contains(err.Error(), "custom layout") && !strings.Contains(err.Error(), "promo2") {
// Accept any refusal; must not succeed.
if err == nil {
t.Fatal("reset of database-only layout must fail")
}
}
})
}

View File

@@ -68,6 +68,14 @@ PHASE35_BASE_TAG="${PHASE35_BASE_TAG:-v0.6.3}"
# required by name in DOCKER_TESTS.
GO_TESTS=(
./modules/postcard:TestMailPartialsSmoke
./modules/postcard:TestOverride
./modules/postcard:TestFallback
./modules/postcard:TestPartial
./modules/postcard:TestSample
./modules/postcard:TestValidateDraft
./modules/postcard:TestBrand
./modules/pact:TestRowStateValues
./modules/lagoon/attach:TestAbsolutePublicURL
)
# docker stage: the non-short framework tests (Postgres).
@@ -77,6 +85,8 @@ DOCKER_TESTS=(
./modules/postcard:TestMailBrandSmoke
./modules/cabana:TestMailScreensSmoke
./modules/lagoon:TestMigrateStatusJSON
./modules/postcard:TestStore
./modules/postcard:TestSync
)
# admin stage: vitest files that must pass.