test: add unit tests for markdown, param_map, and string_slice

markdown_test.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestParseMarkdownFile(t *testing.T) {
+	tests := []struct {
+		name            string
+		content         string
+		wantContent     string
+		wantFrontmatter map[string]string
+		wantErr         bool
+	}{
+		{
+			name: "markdown with frontmatter",
+			content: `---
+title: Test Title
+author: Test Author
+---
+This is the content
+of the markdown file.
+`,
+			wantContent: "This is the content\nof the markdown file.\n",
+			wantFrontmatter: map[string]string{
+				"title":  "Test Title",
+				"author": "Test Author",
+			},
+			wantErr: false,
+		},
+		{
+			name: "markdown without frontmatter",
+			content: `This is a simple markdown file
+without any frontmatter.
+`,
+			wantContent: "without any frontmatter.\n",
+			wantFrontmatter: map[string]string{},
+			wantErr: false,
+		},
+		{
+			name: "empty file",
+			content: "",
+			wantContent: "",
+			wantFrontmatter: map[string]string{},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary file
+			tmpDir := t.TempDir()
+			tmpFile := filepath.Join(tmpDir, "test.md")
+			if err := os.WriteFile(tmpFile, []byte(tt.content), 0644); err != nil {
+				t.Fatalf("failed to create temp file: %v", err)
+			}
+
+			// Parse the file
+			var frontmatter map[string]string
+			content, err := parseMarkdownFile(tmpFile, &frontmatter)
+
+			// Check error
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parseMarkdownFile() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			// Check content
+			if content != tt.wantContent {
+				t.Errorf("parseMarkdownFile() content = %q, want %q", content, tt.wantContent)
+			}
+
+			// Check frontmatter
+			if len(frontmatter) != len(tt.wantFrontmatter) {
+				t.Errorf("parseMarkdownFile() frontmatter length = %d, want %d", len(frontmatter), len(tt.wantFrontmatter))
+			}
+			for k, v := range tt.wantFrontmatter {
+				if frontmatter[k] != v {
+					t.Errorf("parseMarkdownFile() frontmatter[%q] = %q, want %q", k, frontmatter[k], v)
+				}
+			}
+		})
+	}
+}
+
+func TestParseMarkdownFile_FileNotFound(t *testing.T) {
+	var frontmatter map[string]string
+	_, err := parseMarkdownFile("/nonexistent/file.md", &frontmatter)
+	if err == nil {
+		t.Error("parseMarkdownFile() expected error for non-existent file, got nil")
+	}
+}

param_map_test.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestParamMap_Set(t *testing.T) {
+	tests := []struct {
+		name    string
+		value   string
+		wantKey string
+		wantVal string
+		wantErr bool
+	}{
+		{
+			name:    "valid key=value",
+			value:   "key=value",
+			wantKey: "key",
+			wantVal: "value",
+			wantErr: false,
+		},
+		{
+			name:    "key=value with equals in value",
+			value:   "key=value=with=equals",
+			wantKey: "key",
+			wantVal: "value=with=equals",
+			wantErr: false,
+		},
+		{
+			name:    "empty value",
+			value:   "key=",
+			wantKey: "key",
+			wantVal: "",
+			wantErr: false,
+		},
+		{
+			name:    "invalid format - no equals",
+			value:   "keyvalue",
+			wantErr: true,
+		},
+		{
+			name:    "invalid format - only key",
+			value:   "key",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := paramMap{}
+			err := p.Set(tt.value)
+
+			if (err != nil) != tt.wantErr {
+				t.Errorf("paramMap.Set() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if !tt.wantErr {
+				if p[tt.wantKey] != tt.wantVal {
+					t.Errorf("paramMap[%q] = %q, want %q", tt.wantKey, p[tt.wantKey], tt.wantVal)
+				}
+			}
+		})
+	}
+}
+
+func TestParamMap_String(t *testing.T) {
+	p := paramMap{
+		"key1": "value1",
+		"key2": "value2",
+	}
+	s := p.String()
+	if s == "" {
+		t.Error("paramMap.String() returned empty string")
+	}
+}
+
+func TestParamMap_SetMultiple(t *testing.T) {
+	p := paramMap{}
+
+	if err := p.Set("key1=value1"); err != nil {
+		t.Fatalf("paramMap.Set() failed: %v", err)
+	}
+	if err := p.Set("key2=value2"); err != nil {
+		t.Fatalf("paramMap.Set() failed: %v", err)
+	}
+
+	if len(p) != 2 {
+		t.Errorf("paramMap length = %d, want 2", len(p))
+	}
+	if p["key1"] != "value1" {
+		t.Errorf("paramMap[key1] = %q, want %q", p["key1"], "value1")
+	}
+	if p["key2"] != "value2" {
+		t.Errorf("paramMap[key2] = %q, want %q", p["key2"], "value2")
+	}
+}

string_slice_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestStringSlice_Set(t *testing.T) {
+	s := stringSlice{}
+
+	values := []string{"first", "second", "third"}
+	for _, v := range values {
+		if err := s.Set(v); err != nil {
+			t.Errorf("stringSlice.Set(%q) error = %v", v, err)
+		}
+	}
+
+	if len(s) != len(values) {
+		t.Errorf("stringSlice length = %d, want %d", len(s), len(values))
+	}
+
+	for i, want := range values {
+		if s[i] != want {
+			t.Errorf("stringSlice[%d] = %q, want %q", i, s[i], want)
+		}
+	}
+}
+
+func TestStringSlice_String(t *testing.T) {
+	s := stringSlice{"value1", "value2", "value3"}
+	str := s.String()
+	if str == "" {
+		t.Error("stringSlice.String() returned empty string")
+	}
+}
+
+func TestStringSlice_SetEmpty(t *testing.T) {
+	s := stringSlice{}
+
+	if err := s.Set(""); err != nil {
+		t.Errorf("stringSlice.Set(\"\") error = %v", err)
+	}
+
+	if len(s) != 1 {
+		t.Errorf("stringSlice length = %d, want 1", len(s))
+	}
+	if s[0] != "" {
+		t.Errorf("stringSlice[0] = %q, want empty string", s[0])
+	}
+}