refactor: refactor template loading to use helper functions and add tests

- Refactor `LoadTemplates` to utilize the new `loadTemplatesFromFS` helper function.
- Remove complex logic from `LoadTemplates` function.
- Introduce new `LoadTemplatesFromDir` function for loading templates from a directory.
- Create helper function `loadTemplatesFromFS` to handle loading templates from the filesystem.
- Add test for `LoadTemplates` to verify loading templates from an embedded filesystem.
- Add new embedded filesystem sample template in tests.
- Change test template name from `test.tmpl` to `foo.tmpl`.
- Create new template file `test.tmpl` with content "Hello, {{.Name}}!".

Signed-off-by: appleboy <[email protected]>

Author: appleboy

util/template.go

@@ -68,38 +68,34 @@ func GetTemplateByBytes(name string, data map[string]interface{}) ([]byte, error
 // LoadTemplates loads all the templates found in the templates directory from the embedded filesystem.
 // It returns an error if reading the directory or parsing any template fails.
 func LoadTemplates(files embed.FS) error {
-	tmplFiles, err := fs.ReadDir(files, templatesDir)
-	if err != nil {
-		return err
-	}
-
-	for _, tmpl := range tmplFiles {
-		if tmpl.IsDir() {
-			continue
-		}
-
-		pt, err := template.ParseFS(files, templatesDir+"/"+tmpl.Name())
-		if err != nil {
-			return err
-		}
-
-		templates[tmpl.Name()] = pt
-	}
-	return nil
+	return loadTemplatesFromFS(files, templatesDir)
 }
 
+// LoadTemplatesFromDir loads all the templates found in the specified directory from the filesystem.
+// It returns an error if reading the directory or parsing any template fails.
 func LoadTemplatesFromDir(dir string) error {
-	tmplFiles, err := fs.ReadDir(os.DirFS(dir), ".")
+	return loadTemplatesFromFS(os.DirFS(dir), ".")
+}
+
+// loadTemplatesFromFS is a helper function that loads templates from the given filesystem and directory.
+// It returns an error if reading the directory or parsing any template fails.
+func loadTemplatesFromFS(fsys fs.FS, dir string) error {
+	tmplFiles, err := fs.ReadDir(fsys, dir)
 	if err != nil {
 		return err
 	}
 
+	pattern := dir + "/"
+	if dir == "." {
+		pattern = ""
+	}
+
 	for _, tmpl := range tmplFiles {
 		if tmpl.IsDir() {
 			continue
 		}
 
-		pt, err := template.ParseFS(os.DirFS(dir), tmpl.Name())
+		pt, err := template.ParseFS(fsys, pattern+tmpl.Name())
 		if err != nil {
 			return err
 		}

util/template_test.go

@@ -2,6 +2,7 @@ package util
 
 import (
 	"bytes"
+	"embed"
 	"html/template"
 	"os"
 	"testing"
@@ -45,7 +46,7 @@ func TestNewTemplateByStringWithCustomVars(t *testing.T) {
 
 func TestProcessTemplate(t *testing.T) {
 	// Set up test data
-	testTemplateName := "test.tmpl"
+	testTemplateName := "foo.tmpl"
 	testTemplateText := "Hello {{.Name}}!"
 	testData := Data{"Name": "World"}
 
@@ -110,3 +111,37 @@ func TestLoadTemplatesFromDir(t *testing.T) {
 		t.Errorf("Unexpected output. Got: %v, Want: %v", buf.String(), expected)
 	}
 }
+
+// Create an embedded filesystem with a sample template
+//
+//go:embed templates/*
+var testFiles embed.FS
+
+func TestLoadTemplates(t *testing.T) {
+	// Load templates from the embedded filesystem
+	err := LoadTemplates(testFiles)
+	if err != nil {
+		t.Fatalf("Failed to load templates from embedded filesystem: %v", err)
+	}
+
+	// Check if the template was loaded correctly
+	templateFile := "test.tmpl"
+	tmpl, ok := templates[templateFile]
+	if !ok {
+		t.Fatalf("Template %s not found in loaded templates", templateFile)
+	}
+
+	// Process the loaded template
+	data := Data{"Name": "World"}
+	var buf bytes.Buffer
+	err = tmpl.Execute(&buf, data)
+	if err != nil {
+		t.Fatalf("Failed to execute loaded template: %v", err)
+	}
+
+	// Check the output
+	expected := "Hello, World!"
+	if buf.String() != expected {
+		t.Errorf("Unexpected output. Got: %v, Want: %v", buf.String(), expected)
+	}
+}

util/templates/test.tmpl

@@ -0,0 +1 @@
+Hello, {{.Name}}!