From 659969b9ac71f98836cf85edf4bc20a81a040469 Mon Sep 17 00:00:00 2001 From: Jakub Zych Date: Fri, 13 Nov 2026 14:04:14 +0100 Subject: [PATCH] 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 --- modules/lagoon/attach/absolute_test.go | 85 +++++++++ modules/pact/capabilities_test.go | 54 +++++- modules/postcard/brand_test.go | 115 ++++++++++++ modules/postcard/editor_test.go | 88 +++++++++ modules/postcard/override_test.go | 225 ++++++++++++++++++++++++ modules/postcard/partials_test.go | 113 ++++++++++++ modules/postcard/samples_test.go | 113 ++++++++++++ modules/postcard/store_postgres_test.go | 168 ++++++++++++++++++ scripts/check-phase35.sh | 10 ++ 9 files changed, 966 insertions(+), 5 deletions(-) create mode 100644 modules/lagoon/attach/absolute_test.go create mode 100644 modules/postcard/brand_test.go create mode 100644 modules/postcard/editor_test.go create mode 100644 modules/postcard/override_test.go create mode 100644 modules/postcard/partials_test.go create mode 100644 modules/postcard/samples_test.go create mode 100644 modules/postcard/store_postgres_test.go 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: `
{{ .Content }}
`, 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.