Files
summercms/modules/postcard/example_test.go

236 lines
7.7 KiB
Go

package postcard_test
import (
"context"
"errors"
"fmt"
"io/fs"
"strings"
"testing"
"testing/fstest"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/compass"
"git.golem15.com/golem15/summercms/modules/pact"
"git.golem15.com/golem15/summercms/modules/postcard"
)
// mailFS stands in for the plugin's embedded views/mail directory.
var mailFS = fstest.MapFS{
"views/mail/welcome.htm": {Data: []byte(`subject = "Welcome, {{ .name }}"
layout = "blog"
description = "Sent after registration"
==
Hi **{{ .name }}**, thanks for joining the blog.
`)},
"views/mail/layouts/blog.htm": {Data: []byte(`name = "Blog"
==
{{ .Content }}
-- The Acme blog
==
<div class="blog-mail">{{ .Content }}</div>
<style>{{ .brandCss }}{{ .css }}</style>
`)},
"views/mail/partials/note.htm": {Data: []byte(`name = "Note"
==
NOTE: {{ .text }}
==
<div class="note">{{ .text }}</div>
`)},
}
func ExampleMailer_Send() {
// At boot, postcard.BootPlugin registers what pact.HasMailTemplates
// declares; a test registers the same thing directly.
cat := postcard.NewCatalog()
err := cat.Register("acme.blog", mailFS,
[]string{"acme.blog::mail.welcome"},
map[string]string{"blog": "acme.blog::mail.layouts.blog"})
if err != nil {
fmt.Println(err)
return
}
driver := postcard.NewMemoryDriver() // mail.driver: memory
mailer := postcard.NewMailer(cat, driver, postcard.Options{From: "blog@example.com"})
err = mailer.Send(context.Background(), postcard.Message{
Template: "acme.blog::mail.welcome",
To: []string{"ada@example.com"},
Vars: map[string]any{"name": "Ada"},
})
if err != nil {
fmt.Println(err)
return
}
sent := driver.Messages()[0]
fmt.Println(sent.From, sent.To, sent.Subject)
fmt.Println(sent.Text)
fmt.Println(strings.Contains(sent.HTML, `<div class="blog-mail"><p>Hi <strong>Ada</strong>`))
// Header injection is refused before any driver sees the message.
err = mailer.Send(context.Background(), postcard.Message{
Template: "acme.blog::mail.welcome",
To: []string{"ada@example.com\r\nBcc: all@example.com"},
Vars: map[string]any{"name": "Ada"},
})
fmt.Println(err != nil, len(driver.Messages()))
// Output:
// blog@example.com [ada@example.com] Welcome, Ada
// Hi **Ada**, thanks for joining the blog.
//
// -- The Acme blog
// true
// true 1
}
// sendWelcome sends the welcome mail through the mailer published at boot.
func sendWelcome(ctx context.Context, app *backpack.App, email, name string) error {
mailer, ok := app.Lookup[postcard.Mailer]()
if !ok {
return errors.New("mailer not published")
}
return mailer.Send(ctx, postcard.Message{
Template: "acme.blog::mail.welcome",
To: []string{email},
Vars: map[string]any{"name": name},
})
}
func TestWelcomeMail(t *testing.T) {
mailFS := fstest.MapFS{"views/mail/welcome.htm": {Data: []byte("subject = \"Welcome, {{ .name }}\"\n==\nHi **{{ .name }}**.\n")}}
cat := postcard.NewCatalog()
if err := cat.Register("acme.blog", mailFS, []string{"acme.blog::mail.welcome"}, nil); err != nil {
t.Fatal(err)
}
driver := postcard.NewMemoryDriver()
mailer := postcard.NewMailer(cat, driver, postcard.Options{From: "blog@example.com"})
msg := postcard.Message{Template: "acme.blog::mail.welcome", To: []string{"ada@example.com"}, Vars: map[string]any{"name": "Ada"}}
if err := mailer.Send(context.Background(), msg); err != nil {
t.Fatal(err)
}
if got := driver.Messages()[0].Subject; got != "Welcome, Ada" {
t.Fatalf("subject = %q", got)
}
}
// BlogPlugin is the acme.blog plugin; only its mail partials are shown.
type BlogPlugin struct{}
var _ pact.HasMailPartials = BlogPlugin{}
func (BlogPlugin) ID() string { return "acme.blog" }
func (BlogPlugin) MailPartialsFS() fs.FS { return mailFS }
func (BlogPlugin) MailPartials() []string {
return []string{"acme.blog::mail.partials.note"}
}
// fixedOverrides overrides one template with a fixed subject and body.
type fixedOverrides struct{}
func (fixedOverrides) MailOverrides(_ context.Context, template string) (postcard.Overrides, error) {
if template != "acme.blog::mail.welcome" {
return postcard.Overrides{}, nil
}
return postcard.Overrides{Template: &postcard.TemplateOverride{
Subject: "Hello, {{ .name }}",
Body: "Good to see you, **{{ .name }}**.",
}}, nil
}
func newTestMailer(cat *postcard.Catalog, driver postcard.Driver) postcard.Mailer {
return postcard.NewMailer(cat, driver, postcard.Options{Overrides: fixedOverrides{}})
}
// previewWelcome renders an edited welcome mail without saving it.
func previewWelcome(ctx context.Context, app *backpack.App, subject, body string) (postcard.Preview, error) {
editor, ok := postcard.EditorFrom(app)
if !ok {
return postcard.Preview{}, errors.New("mailer not published")
}
draft := postcard.Draft{
Kind: postcard.KindTemplate,
Name: "acme.blog::mail.welcome",
Subject: subject,
Body: body,
}
if problem := editor.Validate(ctx, draft); problem != nil {
// problem.Field and problem.Rule say what to show next to which field.
return postcard.Preview{}, problem
}
return editor.Preview(ctx, draft)
}
// docsCatalog registers the example's welcome template and blog layout.
func docsCatalog(t *testing.T) *postcard.Catalog {
t.Helper()
cat := postcard.NewCatalog()
err := cat.Register("acme.blog", mailFS,
[]string{"acme.blog::mail.welcome"},
map[string]string{"blog": "acme.blog::mail.layouts.blog"})
if err != nil {
t.Fatal(err)
}
return cat
}
// TestDocsMailer publishes a mailer on an app, boots BlogPlugin's partials
// into it and runs sendWelcome, previewWelcome and newTestMailer.
func TestDocsMailer(t *testing.T) {
ctx := t.Context()
app := backpack.New(&compass.Config{})
if err := sendWelcome(ctx, app, "ada@example.com", "Ada"); err == nil {
t.Fatal("sendWelcome without a mailer succeeded")
}
driver := postcard.NewMemoryDriver()
if err := app.Publish(postcard.NewMailer(docsCatalog(t), driver, postcard.Options{From: "blog@example.com"})); err != nil {
t.Fatal(err)
}
if err := postcard.BootPlugin(app, BlogPlugin{}); err != nil {
t.Fatal(err)
}
if err := sendWelcome(ctx, app, "ada@example.com", "Ada"); err != nil {
t.Fatal(err)
}
if got := driver.Messages()[0].Subject; got != "Welcome, Ada" {
t.Fatalf("subject = %q", got)
}
preview, err := previewWelcome(ctx, app, "Hi {{ .name }}",
"Thanks for joining.\n\n{{ partial \"acme.blog::mail.partials.note\" \"text\" \"Reply any time\" }}\n")
if err != nil {
t.Fatal(err)
}
if !strings.Contains(preview.HTML, `<div class="note">Reply any time</div>`) || !strings.Contains(preview.Text, "NOTE: Reply any time") {
t.Fatalf("preview = %+v", preview)
}
var problem *postcard.DraftError
if _, err := previewWelcome(ctx, app, "Hi {{ .name", "Body"); !errors.As(err, &problem) || problem.Field != "subject" {
t.Fatalf("broken subject: %v", err)
}
// The declarations BootPlugin and the mailer call through interfaces.
p := BlogPlugin{}
if names := p.MailPartials(); len(names) != 1 {
t.Fatalf("MailPartials() = %v", names)
}
if _, err := fs.Stat(p.MailPartialsFS(), "views/mail/partials/note.htm"); err != nil {
t.Fatal(err)
}
if o, err := (fixedOverrides{}).MailOverrides(ctx, "acme.blog::mail.other"); err != nil || o.Template != nil {
t.Fatalf("MailOverrides(other) = %+v, %v", o, err)
}
overridden := postcard.NewMemoryDriver()
mailer := newTestMailer(docsCatalog(t), overridden)
if err := mailer.Send(ctx, postcard.Message{Template: "acme.blog::mail.welcome", To: []string{"ada@example.com"}, Vars: map[string]any{"name": "Ada"}}); err != nil {
t.Fatal(err)
}
if got := overridden.Messages()[0]; got.Subject != "Hello, Ada" || !strings.Contains(got.Text, "Good to see you, **Ada**.") {
t.Fatalf("overridden = %q %q", got.Subject, got.Text)
}
}