122 lines
4.1 KiB
Go
122 lines
4.1 KiB
Go
package basic
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// TestMarkdown_Execute_Normal covers table, list, heading and metadata ops.
|
|
func TestMarkdown_Execute_Normal(t *testing.T) {
|
|
t.Parallel()
|
|
tool := markdown{}
|
|
|
|
t.Run("table", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{
|
|
"operation": "table",
|
|
"headers": []any{"name", "score"},
|
|
"rows": []any{[]any{"ada", "90"}, []any{"grace", "100"}},
|
|
})
|
|
assertNoErr(t, err)
|
|
want := "| name | score |\n| --- | --- |\n| ada | 90 |\n| grace | 100 |\n"
|
|
if got := fieldString(t, mapResult(t, got), "result"); got != want {
|
|
t.Fatalf("table = %q, want %q", got, want)
|
|
}
|
|
})
|
|
|
|
t.Run("bulleted list", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "list", "items": []any{"a", "b"}})
|
|
assertNoErr(t, err)
|
|
if want := "- a\n- b\n"; fieldString(t, mapResult(t, got), "result") != want {
|
|
t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
|
|
}
|
|
})
|
|
|
|
t.Run("ordered list", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "list", "items": []any{"a", "b"}, "ordered": true})
|
|
assertNoErr(t, err)
|
|
if want := "1. a\n2. b\n"; fieldString(t, mapResult(t, got), "result") != want {
|
|
t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
|
|
}
|
|
})
|
|
|
|
t.Run("heading", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "heading", "level": 2, "text": "Title"})
|
|
assertNoErr(t, err)
|
|
if want := "## Title\n"; fieldString(t, mapResult(t, got), "result") != want {
|
|
t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
|
|
}
|
|
})
|
|
|
|
t.Run("metadata with front matter", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "metadata", "content": "---\ntitle: Hi\n---\nBody text"})
|
|
assertNoErr(t, err)
|
|
m := mapResult(t, got)
|
|
meta := m["meta"].(map[string]string)
|
|
if meta["title"] != "Hi" {
|
|
t.Fatalf("meta = %v, want title=Hi", meta)
|
|
}
|
|
if got := m["body"].(string); got != "Body text" {
|
|
t.Fatalf("body = %q, want Body text", got)
|
|
}
|
|
})
|
|
|
|
t.Run("metadata without front matter", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "metadata", "content": "just body"})
|
|
assertNoErr(t, err)
|
|
m := mapResult(t, got)
|
|
if meta := m["meta"].(map[string]string); len(meta) != 0 {
|
|
t.Fatalf("meta = %v, want empty", meta)
|
|
}
|
|
if got := m["body"].(string); got != "just body" {
|
|
t.Fatalf("body = %q", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestMarkdown_Execute_Errors covers bad operation inputs.
|
|
func TestMarkdown_Execute_Errors(t *testing.T) {
|
|
t.Parallel()
|
|
tool := markdown{}
|
|
cases := []struct {
|
|
name string
|
|
args map[string]any
|
|
target error
|
|
}{
|
|
{name: "unknown operation", args: map[string]any{"operation": "quote"}, target: ErrUnsupported},
|
|
{name: "table without headers", args: map[string]any{"operation": "table", "rows": []any{}}, target: ErrInvalidArgument},
|
|
{name: "list without items", args: map[string]any{"operation": "list"}, target: ErrInvalidArgument},
|
|
{name: "heading level too low", args: map[string]any{"operation": "heading", "level": 0, "text": "x"}, target: ErrInvalidArgument},
|
|
{name: "heading level too high", args: map[string]any{"operation": "heading", "level": 7, "text": "x"}, target: ErrInvalidArgument},
|
|
{name: "heading without text", args: map[string]any{"operation": "heading", "level": 1}, target: ErrInvalidArgument},
|
|
{name: "metadata without content", args: map[string]any{"operation": "metadata"}, target: ErrInvalidArgument},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := run(t, tool, tc.args)
|
|
assertIs(t, err, tc.target)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestMarkdown_Schema verifies required operation.
|
|
func TestMarkdown_Schema(t *testing.T) {
|
|
t.Parallel()
|
|
p, err := markdown{}.Parameters()
|
|
assertNoErr(t, err)
|
|
reqs := p["required"].([]any)
|
|
if len(reqs) != 1 || reqs[0] != "operation" {
|
|
t.Fatalf("required = %v, want [operation]", reqs)
|
|
}
|
|
if !strings.Contains(p["properties"].(map[string]any)["operation"].(map[string]any)["enum"].([]any)[0].(string), "table") {
|
|
t.Fatalf("enum should include table")
|
|
}
|
|
}
|