package tests
import (
"bytes"
"testing"
"github.com/olekukonko/tablewriter"
"github.com/olekukonko/tablewriter/renderer"
"github.com/olekukonko/tablewriter/tw"
)
// TestHTMLBasicTable verifies that a basic HTML table with headers and rows is rendered correctly.
func TestHTMLBasicTable(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
table.Header([]string{"Name", "Age", "City"})
table.Append([]string{"Alice", "25", "New York"})
table.Append([]string{"Bob", "30", "Boston"})
table.Render()
expected := `
| NAME | AGE | CITY |
|---|
| Alice | 25 | New York |
| Bob | 30 | Boston |
`
if !visualCheckHTML(t, "HTMLBasicTable", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLWithFooterAndAlignment tests an HTML table with a footer and custom column alignments.
func TestHTMLWithFooterAndAlignment(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
tablewriter.WithHeaderConfig(tw.CellConfig{
Formatting: tw.CellFormatting{
AutoFormat: tw.Off,
},
Alignment: tw.CellAlignment{Global: tw.AlignCenter},
}),
tablewriter.WithRowConfig(tw.CellConfig{
Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.AlignLeft, tw.AlignRight, tw.AlignCenter}},
}),
tablewriter.WithFooterConfig(tw.CellConfig{
Alignment: tw.CellAlignment{Global: tw.AlignRight},
}),
)
table.Header([]string{"Item", "Qty", "Price"})
table.Append([]string{"Apple", "5", "1.20"})
table.Append([]string{"Banana", "12", "0.35"})
table.Footer([]string{"", "Total", "7.20"})
table.Render()
expected := `
| Item | Qty | Price |
|---|
| Apple | 5 | 1.20 |
| Banana | 12 | 0.35 |
| Total | 7.20 |
`
if !visualCheckHTML(t, "HTMLWithFooterAndAlignment", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLEscaping verifies HTML content escaping behavior with and without EscapeContent enabled.
func TestHTMLEscaping(t *testing.T) {
// Test case 1: Default (EscapeContent = true)
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
table.Header([]string{"Tag", "Attribute"})
table.Append([]string{"
", "should escape < & >"})
table.Render()
expectedEscaped := `
| TAG | ATTRIBUTE |
|---|
| <br> | should escape < & > |
`
if !visualCheckHTML(t, "HTMLEscaping_Default", buf.String(), expectedEscaped) {
t.Log("--- Debug Log for HTMLEscaping_Default ---")
t.Log(table.Debug())
}
// Test case 2: EscapeContent = false
buf.Reset()
tableNoEscape := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML(renderer.HTMLConfig{EscapeContent: false})),
)
tableNoEscape.Header([]string{"Tag", "Attribute"})
tableNoEscape.Append([]string{"
", "should NOT escape < & >"})
tableNoEscape.Render()
expectedUnescaped := `
| TAG | ATTRIBUTE |
|---|
| should NOT escape < & > |
`
if !visualCheckHTML(t, "HTMLEscaping_Disabled", buf.String(), expectedUnescaped) {
t.Log("--- Debug Log for HTMLEscaping_Disabled ---")
t.Log(table.Debug())
}
}
// TestHTMLMultiLine tests HTML table rendering with multiline cell content, noting that newlines create separate rows.
func TestHTMLMultiLine(t *testing.T) {
// Test case 1: Default behavior (newlines split into separate rows)
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
table.Append([]string{"Line 1\nLine 2", "Single Line"})
table.Render()
expected := `
`
if !visualCheckHTML(t, "HTMLMultiLine_Default", buf.String(), expected) {
t.Logf("MultiLine Default Output: %s", buf.String())
t.Error(table.Debug())
}
// Test case 2: With AddLinesTag (no effect due to newline pre-splitting)
buf.Reset()
tableLinesTag := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML(renderer.HTMLConfig{AddLinesTag: true})),
)
tableLinesTag.Append([]string{"Line 1\nLine 2", "Single Line"})
tableLinesTag.Render()
expectedLinesTag := `
`
if !visualCheckHTML(t, "HTMLMultiLine_LinesTag", buf.String(), expectedLinesTag) {
t.Logf("MultiLine LinesTag Output: %s", buf.String())
t.Log(table.Debug())
}
}
// TestHTMLHorizontalMerge verifies HTML table rendering with horizontal cell merges in headers, rows, and footers.
func TestHTMLHorizontalMerge(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
tablewriter.WithConfig(tablewriter.Config{
Header: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}},
Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}},
Footer: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}},
}),
)
table.Header([]string{"A", "Merged Header", "Merged Header"})
table.Append([]string{"Data 1", "Data 2", "Data 2"})
table.Append([]string{"Merged Row", "Merged Row", "Data 3"})
table.Footer([]string{"Footer 1", "Merged Footer", "Merged Footer"})
table.Render()
expected := `
| A | MERGED HEADER |
|---|
| Data 1 | Data 2 |
| Merged Row | Data 3 |
| Footer 1 | Merged Footer |
`
if !visualCheckHTML(t, "HTMLHorizontalMerge", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLVerticalMerge tests HTML table rendering with vertical cell merges based on repeated values.
func TestHTMLVerticalMerge(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
tablewriter.WithConfig(tablewriter.Config{
Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeVertical}},
}),
)
table.Header([]string{"Category", "Item", "Value"})
table.Append([]string{"Fruit", "Apple", "10"})
table.Append([]string{"Fruit", "Banana", "5"})
table.Append([]string{"Fruit", "Orange", "8"})
table.Append([]string{"Dairy", "Milk", "2"})
table.Append([]string{"Dairy", "Cheese", "4"})
table.Append([]string{"Other", "Bread", "3"})
table.Render()
expected := `
| CATEGORY | ITEM | VALUE |
|---|
| Fruit | Apple | 10 |
| Banana | 5 |
| Orange | 8 |
| Dairy | Milk | 2 |
| Cheese | 4 |
| Other | Bread | 3 |
`
if !visualCheckHTML(t, "HTMLVerticalMerge", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLCombinedMerge verifies HTML table rendering with both horizontal and vertical cell merges.
func TestHTMLCombinedMerge(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
tablewriter.WithConfig(tablewriter.Config{
Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeBoth}},
}),
)
table.Header([]string{"Region", "Quarter", "Sales", "Target"})
table.Append([]string{"North", "Q1", "1000", "900"})
table.Append([]string{"North", "Q2", "1200", "1100"})
table.Append([]string{"South", "Q1+Q2", "Q1+Q2", "2000"})
table.Append([]string{"East", "Q1", "800", "850"})
table.Append([]string{"East", "Q2", "950", "850"})
table.Render()
expected := `
| REGION | QUARTER | SALES | TARGET |
|---|
| North | Q1 | 1000 | 900 |
| Q2 | 1200 | 1100 |
| South | Q1+Q2 | 2000 |
| East | Q1 | 800 | 850 |
| Q2 | 950 |
`
if !visualCheckHTML(t, "HTMLCombinedMerge", buf.String(), expected) {
t.Logf("Combined Merge Output: %s", buf.String())
t.Error(table.Debug())
}
}
// TestHTMLHierarchicalMerge tests HTML table rendering with hierarchical cell merges.
func TestHTMLHierarchicalMerge(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
tablewriter.WithConfig(tablewriter.Config{
Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHierarchical}},
}),
tablewriter.WithHeaderConfig(tw.CellConfig{
Formatting: tw.CellFormatting{
AutoFormat: tw.Off,
},
Alignment: tw.CellAlignment{Global: tw.AlignCenter},
}),
)
table.Header([]string{"L1", "L2", "L3"})
table.Append([]string{"A", "a", "1"})
table.Append([]string{"A", "b", "2"})
table.Append([]string{"A", "b", "3"})
table.Append([]string{"B", "c", "4"})
table.Render()
expected := `
`
if !visualCheckHTML(t, "HTMLHierarchicalMerge", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLEmptyTable verifies HTML rendering for empty tables and tables with only headers.
func TestHTMLEmptyTable(t *testing.T) {
// Test case 1: Completely empty table
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
table.Render()
expected := `
`
if !visualCheckHTML(t, "HTMLEmptyTable", buf.String(), expected) {
t.Logf("Empty table output: '%s'", buf.String())
t.Error(table.Debug())
}
// Test case 2: Header-only table
buf.Reset()
tableHeaderOnly := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
tableHeaderOnly.Header([]string{"Col A"})
tableHeaderOnly.Render()
expectedHeaderOnly := `
`
if !visualCheckHTML(t, "HTMLEmptyTable_HeaderOnly", buf.String(), expectedHeaderOnly) {
t.Log(table.Debug())
}
}
// TestHTMLCSSClasses tests HTML table rendering with custom CSS classes for table, sections, and rows.
func TestHTMLCSSClasses(t *testing.T) {
var buf bytes.Buffer
htmlCfg := renderer.HTMLConfig{
TableClass: "my-table", HeaderClass: "my-thead", BodyClass: "my-tbody",
FooterClass: "my-tfoot", RowClass: "my-row", HeaderRowClass: "my-header-row",
FooterRowClass: "my-footer-row",
}
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML(htmlCfg)),
tablewriter.WithHeaderConfig(tw.CellConfig{
Formatting: tw.CellFormatting{AutoFormat: tw.Off},
Alignment: tw.CellAlignment{Global: tw.AlignCenter},
}),
)
table.Header([]string{"H1"})
table.Append([]string{"R1"})
table.Footer([]string{"F1"})
table.Render()
expected := `
`
if !visualCheckHTML(t, "HTMLCSSClasses", buf.String(), expected) {
t.Error(table.Debug())
}
}
// TestHTMLStructureStrict verifies the exact HTML structure of a table without whitespace or formatting variations.
func TestHTMLStructureStrict(t *testing.T) {
var buf bytes.Buffer
table := tablewriter.NewTable(&buf,
tablewriter.WithRenderer(renderer.NewHTML()),
)
table.Header([]string{"A", "B"})
table.Append([]string{"1", "2"})
table.Append([]string{"3", "4"})
table.Footer([]string{"F1", "F2"})
table.Render()
expectedStructure := ``
outputNormalized := normalizeHTMLStrict(buf.String())
if outputNormalized != expectedStructure {
t.Errorf("HTMLStructureStrict: Mismatch")
t.Errorf("Expected Structure:\n%s", expectedStructure)
t.Errorf("Got Normalized Output:\n%s", outputNormalized)
t.Errorf("Got Raw Output:\n%s", buf.String())
}
}