code")
}
func TestMarkdownToConfluence_CodeBlock(t *testing.T) {
input := "```go\nfmt.Println(\"hello\")\n```"
result, err := MarkdownToConfluence([]byte(input))
require.NoError(t, err)
assert.Contains(t, result, `ac:name="code"`)
assert.Contains(t, result, `ac:name="language">go`)
assert.Contains(t, result, ``)
}
func TestMarkdownToConfluence_CodeBlockNoLanguage(t *testing.T) {
input := "```\nsome code\n```"
result, err := MarkdownToConfluence([]byte(input))
require.NoError(t, err)
assert.Contains(t, result, `ac:name="code"`)
assert.NotContains(t, result, `ac:name="language"`)
}
func TestMarkdownToConfluence_Table(t *testing.T) {
input := "| A | B |\n|---|---|\n| 1 | 2 |"
result, err := MarkdownToConfluence([]byte(input))
require.NoError(t, err)
assert.Contains(t, result, "A | ")
assert.Contains(t, result, "1 | ")
}
func TestMarkdownToConfluence_Blockquote(t *testing.T) {
result, err := MarkdownToConfluence([]byte("> Important note"))
require.NoError(t, err)
assert.Contains(t, result, `ac:name="info"`)
assert.Contains(t, result, "Important note")
}
func TestMarkdownToConfluence_Image(t *testing.T) {
result, err := MarkdownToConfluence([]byte(""))
require.NoError(t, err)
assert.Contains(t, result, "
|---|
Name | Age |
|---|---|
Alice | 30 |
Important note
Before
Author:
Author:
Content
Left
Right
Left column
Right column
Hello
helloworld
plan : vclock
single
a text b
elements
// previously caused the merge logic to swallow the gap and
// concatenate the spans.
name: "whitespace-separated code elements stay separate",
input: `Благодаря previous_backup_id tt restore plan видит разрыв.
`,
expected: "`previous_backup_id` `tt restore plan`",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := ConfluenceToMarkdown(tt.input)
require.NoError(t, err)
assert.Contains(t, result, tt.expected)
})
}
}
func TestRoundTrip_ListNoTrailingWhitespace(t *testing.T) {
xmlInput := `- item 1
- item 2
- item 3
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
assert.Contains(t, xmlOutput, "- item 1
")
assert.Contains(t, xmlOutput, "- item 2
")
assert.Contains(t, xmlOutput, "- item 3
")
assert.NotContains(t, xmlOutput, "item 1\nТоварищ!
// contents include a literal `|`. Without escaping, the pipe was treated as a
// column separator at re-parse time, splitting a single cell across columns
// and dropping content. Cells must escape `|` as `\|` per the GFM spec.
func TestRoundTrip_TablePipeInCode(t *testing.T) {
xmlInput := `` +
`Команда
Где
Действие
mode --target=<incremental|full> --storage=<config>
менеджер
Возвращает mode + from_vclock.
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
// The pipe inside the code span must be escaped in the markdown so the
// table parser does not treat it as a column boundary.
assert.Contains(t, md, `\|`)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
// All three columns must survive the round-trip.
assert.Contains(t, xmlOutput, `mode --target=<incremental|full> --storage=<config>`)
assert.Contains(t, xmlOutput, "менеджер")
assert.Contains(t, xmlOutput, "from_vclock")
}
// TestEscapeTablePipes_NoDoubleEscape guards the helper against doubling up
// already-escaped pipes (e.g. when a cell's rendered markdown was produced by
// an upstream that already escaped some pipes itself).
func TestEscapeTablePipes_NoDoubleEscape(t *testing.T) {
cases := map[string]string{
"": "",
"plain": "plain",
"a|b": `a\|b`,
`already\|done`: `already\|done`,
"`a|b`": "`a\\|b`",
}
for in, want := range cases {
got := escapeTablePipes(in)
assert.Equal(t, want, got, "input=%q", in)
}
}
// TestRoundTrip_PageLink locks in the fix for Основной документ:
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
require.Contains(t, md, `data-page-link`)
require.Contains(t, md, `data-space-key="TSC"`)
require.Contains(t, md, `data-content-title="Бекапы и Point-in-time recovery в кластере Tarantool"`)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
assert.Contains(t, xmlOutput, ` inside an outer - was flattened into a single flat list
// because the markdown was emitted with a 2-space indent (insufficient for
// ordered lists, which need ≥3) and a blank line that turned the list loose.
func TestRoundTrip_NestedOrderedList(t *testing.T) {
xmlInput := `
` +
`- Outer one.
` +
`- Inner one.
` +
`- Inner two.
` +
`
` +
`- Outer two.
` +
`- Outer three.
` +
`
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
// Nested must survive — a flattened version would have 5 sibling - s.
// Whitespace between closing tags is normalized away in this assertion.
noWS := strings.Join(strings.Fields(xmlOutput), "")
assert.Contains(t, noWS, "
- Outerone.
")
assert.Contains(t, xmlOutput, "- Inner one.
")
assert.Contains(t, xmlOutput, "- Inner two.
")
assert.Contains(t, noWS, "
")
assert.Contains(t, xmlOutput, "- Outer two.
")
// List must remain tight — no wrappers around items.
assert.NotContains(t, xmlOutput, "
Outer one.")
assert.NotContains(t, xmlOutput, "
Inner one.")
}
// TestRoundTrip_NestedMixedList guards the same fix for an OL containing a
// nested UL, which is what the tt.xml mismatch exercised.
func TestRoundTrip_NestedMixedList(t *testing.T) {
xmlInput := `
` +
`- Outer one.
` +
`- Bullet one.
` +
`- Bullet two.
` +
`
` +
`- Outer two.
` +
`
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
noWS := strings.Join(strings.Fields(xmlOutput), "")
assert.Contains(t, noWS, "- Outerone.
")
assert.Contains(t, xmlOutput, "- Bullet one.
")
assert.Contains(t, xmlOutput, "- Bullet two.
")
assert.Contains(t, noWS, "
")
assert.Contains(t, xmlOutput, "- Outer two.
")
assert.NotContains(t, xmlOutput, "Outer one.")
}
// TestRoundTrip_DoubleNestedUnorderedList covers a UL nested inside another
// UL — pre-fix the cumulative indent computation didn't account for the
// parent list, so deeply nested items collapsed.
func TestRoundTrip_DoubleNestedUnorderedList(t *testing.T) {
xmlInput := `
` +
`- Top one.
` +
`- Mid one.
` +
`- Deep one.
` +
`- Deep two.
` +
`
` +
`- Mid two.
` +
`
` +
`
`
md, err := ConfluenceToMarkdown(xmlInput)
require.NoError(t, err)
xmlOutput, err := MarkdownToConfluence([]byte(md))
require.NoError(t, err)
noWS := strings.Join(strings.Fields(xmlOutput), "")
assert.Contains(t, noWS, "- Topone.
")
assert.Contains(t, noWS, "- Midone.
")
assert.Contains(t, xmlOutput, "- Deep one.
")
assert.Contains(t, xmlOutput, "- Deep two.
")
assert.Contains(t, xmlOutput, "- Mid two.
")
// Three nesting levels collapse to three closing
s.
assert.Equal(t, 3, strings.Count(xmlOutput, "
"))
}