written straight into a table is hoisted back out of it by every HTML // parser, which lands it exactly where the bug put it. A table with rows of // its own gets a row instead, spanning every column and picking up the side // padding of the rows above so the footer lines up with the copy. func TestAppendToContentAddsARowToATable(t *testing.T) { body := `` + `` + `` + `

Banner	Logo
Copy	Aside

` out := AppendToContent(body, "[F]") want := `[F]` if !strings.Contains(out, want) { t.Fatalf("expected %s in:\n%s", want, out) } } // A builder export (Unlayer, Beefree, Stripo) is a stack of full-width rows // each centring a card of its own, so the deepest element holding the whole // message is the full-width cell. Appending there is inside the document but // still hard left; the footer has to centre itself on the card's width. func TestAppendToContentCentresItselfInABuilderExport(t *testing.T) { row := `

`, "\xa4\xa4\xa4\xa4", } { out := AppendToContent(body, "[F]") if !strings.Contains(out, "[F]") { t.Errorf("fragment was dropped from %q: %q", body, out) } if !isSplice(body, out) { t.Errorf("body was rewritten, not spliced:\n in %q\nout %q", body, out) } } } // isSplice reports whether out is body with one run of text inserted: the // common prefix and the common suffix together have to account for all of it. func isSplice(body, out string) bool { p := 0 for p < len(body) && p < len(out) && body[p] == out[p] { p++ } s := 0 for s < len(body)-p && s < len(out)-p && body[len(body)-1-s] == out[len(out)-1-s] { s++ } return p+s >= len(body) } // HTML mail leaves end tags off constantly, and the outline has to close the // same elements a browser would or the shape it reports is not the shape the // reader sees. func TestAppendToContentReadsMarkupWithOmittedEndTags(t *testing.T) { // An unclosed

before the next cell: the second cell is a sibling of // the first, not something nested inside it, so the table is two columns // across and the appended row has to span both. body := `
One
Two
Three Four
` if out := AppendToContent(body, "[F]"); !strings.Contains(out, `[F]`) { t.Errorf("omitted end tags mis-read the table:\n%s", out) } // A trailing slash inside an unquoted attribute value is part of the // value, not a self-closing tag. Read as one, the element never opens and // everything written inside it becomes a sibling, which moves the end of // the content somewhere the reader does not see it. unquoted := `
a
b
` if out := AppendToContent(unquoted, "[F]"); !strings.Contains(out, "

[F]") { t.Errorf("an unquoted path was read as a self-closing tag:\n%s", out) } } // The padding shorthand is top / right / bottom / left, and the sides only // mirror each other until it names all four. func TestAppendedRowMatchesAFourValuePadding(t *testing.T) { body := `

` if out := AppendToContent(body, "[F]"); !strings.Contains(out, `style="padding-left:40px;padding-right:20px"`) { t.Errorf("the appended row did not line up with the copy above it:\n%s", out) } } // mjmlSection is one MJML row: a centred 600px div wrapping a full-width // table, between the Outlook conditional comments MJML emits around it. func mjmlSection(text string) string { return `` + `

` + `` + `

` + `

` + `` + `

` + `

` + text + `

` + `

` + `` } // MJML is the most common way a designed email reaches us, and it writes its // centring as "margin:0px auto". Matching the hand-written "margin:0 auto" as // text missed it, and a multi-section export went out hard left. func TestAppendToContentHandlesMJML(t *testing.T) { page := func(sections ...string) string { return `

` + strings.Join(sections, "") + `

` } // One section is a single container all the way down, so the line goes // inside the last text block, padded like the copy around it. one := AppendToContent(page(mjmlSection("Hello")), "[F]") if !strings.Contains(one, "Hello[F]

Hi