319 lines
9.7 KiB
Go
319 lines
9.7 KiB
Go
// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice appear in all copies.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
// PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
package prosemirror
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestParseMarkdown_BlockHTML(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("<div>block</div>\n")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeParagraph, doc.Content[0].Type)
|
|
require.Len(t, doc.Content[0].Content, 1)
|
|
assert.Equal(t, NodeText, doc.Content[0].Content[0].Type)
|
|
require.NotNil(t, doc.Content[0].Content[0].Text)
|
|
assert.Equal(t, "block", *doc.Content[0].Content[0].Text)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLDivPreservesInlineMarks(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("<div>hello <strong>world</strong></div>\n")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
p := doc.Content[0]
|
|
require.Equal(t, NodeParagraph, p.Type)
|
|
|
|
var foundStrong bool
|
|
|
|
for _, ch := range p.Content {
|
|
if ch.Type != NodeText || ch.Text == nil {
|
|
continue
|
|
}
|
|
|
|
if *ch.Text != "world" {
|
|
continue
|
|
}
|
|
|
|
require.Len(t, ch.Marks, 1)
|
|
assert.Equal(t, MarkStrong, ch.Marks[0].Type)
|
|
|
|
foundStrong = true
|
|
}
|
|
|
|
assert.True(t, foundStrong, "expected bold mark on 'world' inside a single paragraph")
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLDivAroundSectionWithParagraphs(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("<div><section><p>a</p><p>b</p></section></div>\n")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 2)
|
|
assert.Equal(t, NodeParagraph, doc.Content[0].Type)
|
|
assert.Equal(t, NodeParagraph, doc.Content[1].Type)
|
|
assert.Equal(t, "a", *doc.Content[0].Content[0].Text)
|
|
assert.Equal(t, "b", *doc.Content[1].Content[0].Text)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLWithClosureLine(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Type 1 HTML block: closing tag is stored on ClosureLine, not in Lines.
|
|
// Script is stripped by the HTML sanitizer; nothing safe remains.
|
|
md := "<script>\nconsole.log(1)\n</script>\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, doc.Content)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLParagraphAndHeading(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("<p>a</p>\n<h2>Title</h2>\n")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 2)
|
|
assert.Equal(t, NodeParagraph, doc.Content[0].Type)
|
|
require.Len(t, doc.Content[0].Content, 1)
|
|
assert.Equal(t, "a", *doc.Content[0].Content[0].Text)
|
|
assert.Equal(t, NodeHeading, doc.Content[1].Type)
|
|
attrs, err := doc.Content[1].HeadingAttrs()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 2, attrs.Level)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLListAndBlockquote(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("<ul><li>one</li></ul>\n<blockquote><p>q</p></blockquote>\n")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 2)
|
|
assert.Equal(t, NodeBulletList, doc.Content[0].Type)
|
|
assert.Equal(t, NodeBlockquote, doc.Content[1].Type)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLTable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := "<table><tr><th>A</th><td>B</td></tr></table>\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeTable, doc.Content[0].Type)
|
|
require.Len(t, doc.Content[0].Content, 1)
|
|
assert.Equal(t, NodeTableRow, doc.Content[0].Content[0].Type)
|
|
require.Len(t, doc.Content[0].Content[0].Content, 2)
|
|
assert.Equal(t, NodeTableHeader, doc.Content[0].Content[0].Content[0].Type)
|
|
assert.Equal(t, NodeTableCell, doc.Content[0].Content[0].Content[1].Type)
|
|
|
|
thAttrs, err := doc.Content[0].Content[0].Content[0].TableCellAttrs()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, thAttrs.Colspan)
|
|
assert.Equal(t, 1, thAttrs.Rowspan)
|
|
|
|
tdAttrs, err := doc.Content[0].Content[0].Content[1].TableCellAttrs()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, tdAttrs.Colspan)
|
|
assert.Equal(t, 1, tdAttrs.Rowspan)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLNestedTableDoesNotHoistInnerRows(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := "<table><tr><td><table><tr><td>inner</td></tr></table></td></tr></table>\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeTable, doc.Content[0].Type)
|
|
// Outer table must have exactly one row; inner <tr> must not become a second outer row.
|
|
require.Len(t, doc.Content[0].Content, 1)
|
|
assert.Equal(t, NodeTableRow, doc.Content[0].Content[0].Type)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLTableCellSpans(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := `<table><tr><td colspan="3" rowspan="2">X</td></tr></table>` + "\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
cell := doc.Content[0].Content[0].Content[0]
|
|
require.Equal(t, NodeTableCell, cell.Type)
|
|
attrs, err := cell.TableCellAttrs()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 3, attrs.Colspan)
|
|
assert.Equal(t, 2, attrs.Rowspan)
|
|
}
|
|
|
|
func TestParseMarkdown_MarkdownTableCellWithBlockList(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := "| Header |\n| --- |\n| <ul><li>one</li><li>two</li></ul> |\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeTable, doc.Content[0].Type)
|
|
|
|
dataRow := doc.Content[0].Content[1]
|
|
assert.Equal(t, NodeTableRow, dataRow.Type)
|
|
cell := dataRow.Content[0]
|
|
assert.Equal(t, NodeTableCell, cell.Type)
|
|
|
|
require.Len(t, cell.Content, 1)
|
|
assert.Equal(t, NodeBulletList, cell.Content[0].Type)
|
|
require.Len(t, cell.Content[0].Content, 2)
|
|
assert.Equal(t, NodeListItem, cell.Content[0].Content[0].Type)
|
|
assert.Equal(t, NodeListItem, cell.Content[0].Content[1].Type)
|
|
|
|
li1Para := cell.Content[0].Content[0].Content[0]
|
|
require.Equal(t, NodeParagraph, li1Para.Type)
|
|
assert.Equal(t, "one", *li1Para.Content[0].Text)
|
|
|
|
li2Para := cell.Content[0].Content[1].Content[0]
|
|
require.Equal(t, NodeParagraph, li2Para.Type)
|
|
assert.Equal(t, "two", *li2Para.Content[0].Text)
|
|
}
|
|
|
|
func TestParseMarkdown_MarkdownTableCellWithOrderedList(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := "| Header |\n| --- |\n| <ol><li>first</li><li>second</li></ol> |\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeTable, doc.Content[0].Type)
|
|
|
|
dataRow := doc.Content[0].Content[1]
|
|
cell := dataRow.Content[0]
|
|
assert.Equal(t, NodeTableCell, cell.Type)
|
|
|
|
require.Len(t, cell.Content, 1)
|
|
assert.Equal(t, NodeOrderedList, cell.Content[0].Type)
|
|
require.Len(t, cell.Content[0].Content, 2)
|
|
assert.Equal(t, NodeListItem, cell.Content[0].Content[0].Type)
|
|
assert.Equal(t, NodeListItem, cell.Content[0].Content[1].Type)
|
|
}
|
|
|
|
func TestParseMarkdown_BlockHTMLScriptRemovedKeepsSafeContent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
md := "<p>ok</p>\n<script>bad()</script>\n"
|
|
doc, err := ParseMarkdown(md)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
assert.Equal(t, NodeParagraph, doc.Content[0].Type)
|
|
assert.Equal(t, "ok", *doc.Content[0].Content[0].Text)
|
|
}
|
|
|
|
func TestParseMarkdown_InlineRawHTML(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown("before <span>x</span> after")
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
p := doc.Content[0]
|
|
require.Equal(t, NodeParagraph, p.Type)
|
|
|
|
var joined strings.Builder
|
|
|
|
for _, ch := range p.Content {
|
|
require.Equal(t, NodeText, ch.Type)
|
|
require.NotNil(t, ch.Text)
|
|
joined.WriteString(*ch.Text)
|
|
}
|
|
|
|
// Sanitized HTML: span is unwrapped to plain text content.
|
|
assert.Equal(t, "before x after", joined.String())
|
|
}
|
|
|
|
func TestParseMarkdown_InlineRawHTMLStrong(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown(`a <strong>b</strong> c`)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
p := doc.Content[0]
|
|
require.Len(t, p.Content, 3)
|
|
assert.Equal(t, "a ", *p.Content[0].Text)
|
|
assert.Equal(t, "b", *p.Content[1].Text)
|
|
require.Len(t, p.Content[1].Marks, 1)
|
|
assert.Equal(t, MarkStrong, p.Content[1].Marks[0].Type)
|
|
assert.Equal(t, " c", *p.Content[2].Text)
|
|
}
|
|
|
|
func TestParseMarkdown_InlineRawHTMLScriptStripped(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown(`hi <script>evil()</script> there`)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
p := doc.Content[0]
|
|
|
|
var joined strings.Builder
|
|
|
|
for _, ch := range p.Content {
|
|
if ch.Type == NodeText && ch.Text != nil {
|
|
joined.WriteString(*ch.Text)
|
|
}
|
|
}
|
|
|
|
assert.NotContains(t, joined.String(), "script")
|
|
assert.NotContains(t, joined.String(), "evil")
|
|
assert.Contains(t, joined.String(), "hi")
|
|
assert.Contains(t, joined.String(), "there")
|
|
}
|
|
|
|
func TestParseMarkdown_InlineRawHTMLWithOuterBold(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
doc, err := ParseMarkdown(`**a <em>b</em> c**`)
|
|
require.NoError(t, err)
|
|
require.Len(t, doc.Content, 1)
|
|
p := doc.Content[0]
|
|
require.GreaterOrEqual(t, len(p.Content), 3)
|
|
|
|
var joined strings.Builder
|
|
|
|
for _, ch := range p.Content {
|
|
require.Equal(t, NodeText, ch.Type)
|
|
require.NotNil(t, ch.Text)
|
|
joined.WriteString(*ch.Text)
|
|
}
|
|
|
|
assert.Equal(t, "a b c", joined.String())
|
|
|
|
var mid *Node
|
|
|
|
for i := range p.Content {
|
|
if p.Content[i].Text != nil && *p.Content[i].Text == "b" {
|
|
mid = &p.Content[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
require.NotNil(t, mid, "expected inner <em> as text node b")
|
|
require.GreaterOrEqual(t, len(mid.Marks), 2)
|
|
assert.Equal(t, MarkStrong, mid.Marks[0].Type)
|
|
assert.Equal(t, MarkEm, mid.Marks[1].Type)
|
|
}
|