236 lines
7.7 KiB
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)
|
|
}
|
|
}
|