diff --git a/modules/lagoon/attach/absolute_test.go b/modules/lagoon/attach/absolute_test.go
new file mode 100644
index 00000000..255988aa
--- /dev/null
+++ b/modules/lagoon/attach/absolute_test.go
@@ -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)
+ }
+ })
+}
diff --git a/modules/pact/capabilities_test.go b/modules/pact/capabilities_test.go
index e5ceea4d..a0dda0fc 100644
--- a/modules/pact/capabilities_test.go
+++ b/modules/pact/capabilities_test.go
@@ -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)
}
diff --git a/modules/postcard/brand_test.go b/modules/postcard/brand_test.go
new file mode 100644
index 00000000..76c92d75
--- /dev/null
+++ b/modules/postcard/brand_test.go
@@ -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{})
+ })
+}
diff --git a/modules/postcard/editor_test.go b/modules/postcard/editor_test.go
new file mode 100644
index 00000000..5eb172b7
--- /dev/null
+++ b/modules/postcard/editor_test.go
@@ -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", 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: "
static
", 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)
+ }
+ })
+}
diff --git a/modules/postcard/override_test.go b/modules/postcard/override_test.go
new file mode 100644
index 00000000..09ccec89
--- /dev/null
+++ b/modules/postcard/override_test.go
@@ -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: `Custom Ada
`,
+ 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: `
Body for Ada
`,
+ },
+ {
+ 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: `
`, Text: "{{ .Content }}\n"},
+ },
+ },
+ wantSub: "Welcome, Ada",
+ wantHTML: `
Hi Ada, thanks for joining.
`,
+ },
+ }
+ 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: ``, 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, "") {
+ 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: `{{ .Content }}`, 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, "") {
+ 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, `Hi Ada`) {
+ 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)
+ }
+}
diff --git a/modules/postcard/partials_test.go b/modules/postcard/partials_test.go
new file mode 100644
index 00000000..55ae8d58
--- /dev/null
+++ b/modules/postcard/partials_test.go
@@ -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, `
hello
`) {
+ 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, `
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")
+ }
+ })
+}
diff --git a/modules/postcard/samples_test.go b/modules/postcard/samples_test.go
new file mode 100644
index 00000000..b569ca10
--- /dev/null
+++ b/modules/postcard/samples_test.go
@@ -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)
+ }
+ }
+ })
+}
diff --git a/modules/postcard/store_postgres_test.go b/modules/postcard/store_postgres_test.go
new file mode 100644
index 00000000..5c0722da
--- /dev/null
+++ b/modules/postcard/store_postgres_test.go
@@ -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', '{{ .Content }}
', 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")
+ }
+ }
+ })
+}
diff --git a/scripts/check-phase35.sh b/scripts/check-phase35.sh
index 53a1776f..ee919129 100755
--- a/scripts/check-phase35.sh
+++ b/scripts/check-phase35.sh
@@ -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.