add some tests

Author: dariubs

.github/workflows/validate.yml

@@ -1,4 +1,4 @@
-name: Validate and compile
+name: Test
 
 on:
   push:
@@ -7,7 +7,7 @@ on:
     branches: [main]
 
 jobs:
-  validate:
+  test:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -18,12 +18,6 @@ jobs:
           go-version: "1.21"
           cache-dependency-path: compiler/go.sum
 
-      - name: Build compiler
-        run: make build
-
-      - name: Validate and compile template
-        run: cd template && ../compiler/bin/compile
-
-      - name: Check template output is up to date
-        run: |
-          cd template && OUTPUT=$(../compiler/bin/compile -print-out) && git diff --exit-code "$OUTPUT" || (echo "::error::$OUTPUT is out of date. Run: make build && cd template && ../compiler/bin/compile" && exit 1)
+      - name: Run tests
+        run: go test ./...
+        working-directory: compiler

compiler/compile/render_test.go

@@ -0,0 +1,80 @@
+package compile
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestGroupByMainCategory_sortByName(t *testing.T) {
+	info := &Info{} // no PositionOrder
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	items := map[string]*Item{
+		"b": {Name: "B", MainCategory: "tools"},
+		"a": {Name: "A", MainCategory: "tools"},
+	}
+	byCat := GroupByMainCategory(info, categories, items)
+	list := byCat["tools"]
+	if len(list) != 2 {
+		t.Fatalf("expected 2 items, got %d", len(list))
+	}
+	if list[0].Name != "A" || list[1].Name != "B" {
+		t.Errorf("expected order A, B; got %s, %s", list[0].Name, list[1].Name)
+	}
+}
+
+func TestGroupByMainCategory_sortByPosition(t *testing.T) {
+	info := &Info{PositionOrder: []string{"featured", "ordinary"}}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	items := map[string]*Item{
+		"a": {Name: "A", MainCategory: "tools", Position: "ordinary"},
+		"b": {Name: "B", MainCategory: "tools", Position: "featured"},
+	}
+	byCat := GroupByMainCategory(info, categories, items)
+	list := byCat["tools"]
+	if len(list) != 2 {
+		t.Fatalf("expected 2 items, got %d", len(list))
+	}
+	if list[0].Name != "B" || list[1].Name != "A" {
+		t.Errorf("expected featured first (B, A); got %s, %s", list[0].Name, list[1].Name)
+	}
+}
+
+func TestRender_containsTitleAndContents(t *testing.T) {
+	info := &Info{Name: "Awesome List", Description: "A list."}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	items := map[string]*Item{
+		"foo": {
+			Name: "Foo", URL: "https://foo.com", MainCategory: "tools",
+		},
+	}
+	items["foo"].onelinerValue = "A tool."
+	byCat := GroupByMainCategory(info, categories, items)
+	md := Render(info, categories, byCat)
+	if !strings.Contains(md, "# Awesome List") {
+		t.Error("output should contain title")
+	}
+	if !strings.Contains(md, "## Contents") {
+		t.Error("output should contain Contents")
+	}
+	if !strings.Contains(md, "## Tools") {
+		t.Error("output should contain Tools section")
+	}
+	if !strings.Contains(md, "[Foo](https://foo.com)") {
+		t.Error("output should contain item link")
+	}
+}
+
+func TestEscapeMarkdownBracket(t *testing.T) {
+	// escapeMarkdownBracket is unexported; test via Render with item name containing ]
+	info := &Info{Name: "T", Description: "D"}
+	categories := []Category{{ID: "x", Name: "X"}}
+	items := map[string]*Item{
+		"a": {Name: "Item [extra]", URL: "https://x.com", MainCategory: "x"},
+	}
+	items["a"].onelinerValue = "Desc."
+	byCat := GroupByMainCategory(info, categories, items)
+	md := Render(info, categories, byCat)
+	if !strings.Contains(md, `\]`) {
+		t.Error("expected bracket in name to be escaped")
+	}
+}

compiler/compile/validate_test.go

@@ -0,0 +1,78 @@
+package compile
+
+import (
+	"testing"
+)
+
+func TestValidate_emptyInfo(t *testing.T) {
+	info := &Info{}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	items := map[string]*Item{}
+	errs := Validate(info, categories, items)
+	if len(errs) < 2 {
+		t.Fatalf("expected at least 2 errors for empty info, got %d", len(errs))
+	}
+}
+
+func TestValidate_valid(t *testing.T) {
+	info := &Info{Name: "Test", Description: "Desc"}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	item := &Item{
+		Name: "Foo", Slug: "foo", URL: "https://foo.com",
+		MainCategory: "tools",
+	}
+	item.onelinerValue = "A tool."
+	items := map[string]*Item{"foo": item}
+	errs := Validate(info, categories, items)
+	if len(errs) != 0 {
+		t.Fatalf("expected no errors, got %v", errs)
+	}
+}
+
+func TestValidate_slugMismatch(t *testing.T) {
+	info := &Info{Name: "Test", Description: "Desc"}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	item := &Item{
+		Name: "Foo", Slug: "wrong", URL: "https://foo.com",
+		MainCategory: "tools",
+	}
+	item.onelinerValue = "A tool."
+	items := map[string]*Item{"foo": item}
+	errs := Validate(info, categories, items)
+	if len(errs) == 0 {
+		t.Fatal("expected error for slug mismatch")
+	}
+}
+
+func TestValidate_unknownCategory(t *testing.T) {
+	info := &Info{Name: "Test", Description: "Desc"}
+	categories := []Category{{ID: "tools", Name: "Tools"}}
+	item := &Item{
+		Name: "Foo", Slug: "foo", URL: "https://foo.com",
+		MainCategory: "unknown",
+	}
+	item.onelinerValue = "A tool."
+	items := map[string]*Item{"foo": item}
+	errs := Validate(info, categories, items)
+	if len(errs) == 0 {
+		t.Fatal("expected error for unknown main_category")
+	}
+}
+
+func TestOnelinerSuffix(t *testing.T) {
+	tests := []struct {
+		in   string
+		want string
+	}{
+		{"hello", "hello."},
+		{"hello.", "hello."},
+		{"  hi  ", "hi."},
+		{"", ""},
+	}
+	for _, tt := range tests {
+		got := OnelinerSuffix(tt.in)
+		if got != tt.want {
+			t.Errorf("OnelinerSuffix(%q) = %q, want %q", tt.in, got, tt.want)
+		}
+	}
+}