Handle more edge cases, unit tests

templatestrings.go

@@ -1,6 +1,7 @@
 package templatestrings
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 
@@ -18,32 +19,47 @@ func InitTemplateStrings(stringsDir string, fileExt string, defaultVariant strin
 		map[string]map[string]string{},
 		defaultVariant,
 	}
+	// Check directory
+	if stat, err := os.Stat(stringsDir); err != nil {
+		return nil, err
+	} else if !stat.IsDir() {
+		return nil, errors.New("specified directory is no dir")
+	}
 	// Load strings
 	variants := append(otherVariants, defaultVariant)
 	for _, variant := range variants {
+		// Check if variant is empty
+		if variant == "" {
+			return nil, errors.New("language variant needs to have a name")
+		}
+		// Check if variant already loaded
 		if _, ok := ts.templateStrings[variant]; ok {
-			// Already loaded
 			continue
 		}
-		variantStrings := map[string]string{}
-		f, err := os.Open(filepath.Join(stringsDir, variant+fileExt))
+		fb, err := os.ReadFile(filepath.Join(stringsDir, variant+fileExt))
 		if err != nil {
-			if os.IsNotExist(err) {
-				continue
-			}
-			return nil, err
+			// Just ignore the file
+			continue
 		}
-		err = yaml.NewDecoder(f).Decode(variantStrings)
-		if err != nil {
+		variantStrings := map[string]string{}
+		if err = yaml.Unmarshal(fb, variantStrings); err != nil {
+			// Error loading YAML
 			return nil, err
 		}
 		ts.templateStrings[variant] = variantStrings
 	}
+	// Checks
+	if len(ts.templateStrings) == 0 {
+		return nil, errors.New("no variants initialized")
+	}
+	if _, ok := ts.templateStrings[ts.defaultVariant]; !ok {
+		return nil, errors.New("default variant not loaded")
+	}
 	return ts, nil
 }
 
 // Get a string
-// input: lang, name or just name (uses default)
+// input: language, name or just name (uses default language)
 func (ts *TemplateStrings) GetTemplateStringVariant(input ...string) (result string) {
 	var lang, name string
 	if l := len(input); l == 1 {
@@ -55,7 +71,7 @@ func (ts *TemplateStrings) GetTemplateStringVariant(input ...string) (result str
 		lang = input[0]
 		name = input[1]
 	} else {
-		// Wrong number of input strings
+		// Wrong number of input strings, return empty string
 		return ""
 	}
 	m, ok := ts.templateStrings[lang]
@@ -69,7 +85,7 @@ func (ts *TemplateStrings) GetTemplateStringVariant(input ...string) (result str
 	return
 }
 
-// Get a func to use for templates
+// Get a function to use in templates
 func (ts *TemplateStrings) GetTemplateStringVariantFunc() func(...string) string {
 	return func(s ...string) string {
 		return ts.GetTemplateStringVariant(s...)

templatestrings_test.go

@@ -0,0 +1,122 @@
+package templatestrings
+
+import (
+	"testing"
+)
+
+func TestAll(t *testing.T) {
+	t.Run("Faulty initialization", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "en", "faulty")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("Missing dir", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata/x", ".yaml", "en")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("Missing file", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "en", "x")
+		if err != nil {
+			t.Error()
+		}
+	})
+	t.Run("File as directory", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata/en.yaml", ".yaml", "en")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("Missing default variant", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "x", "en")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("No variants", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "x")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("Language twice", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "en", "en", "de")
+		if err != nil {
+			t.Error()
+		}
+	})
+	t.Run("Empty language", func(t *testing.T) {
+		_, err := InitTemplateStrings("testdata", ".yaml", "")
+		if err == nil {
+			t.Error()
+		}
+	})
+	t.Run("Wrong number of inputs", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("simple", "en", "x") != "" {
+			t.Error()
+		}
+	})
+	t.Run("Default variant", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("simple") != "Simple" {
+			t.Error()
+		}
+	})
+	t.Run("Specified variant", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("en", "simple") != "Simple" {
+			t.Error()
+		}
+		if ts.GetTemplateStringVariant("de", "simple") != "Einfach" {
+			t.Error()
+		}
+	})
+	t.Run("Fallback to default variant", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("de", "fallback") != "Fallback" {
+			t.Error()
+		}
+	})
+	t.Run("Missing variant", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("x", "simple") != "Simple" {
+			t.Error()
+		}
+	})
+	t.Run("Missing string", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariant("x") != "" {
+			t.Error()
+		}
+	})
+	t.Run("Template func", func(t *testing.T) {
+		ts, err := InitTemplateStrings("testdata", ".yaml", "en", "de")
+		if err != nil {
+			t.FailNow()
+		}
+		if ts.GetTemplateStringVariantFunc()("simple") != "Simple" {
+			t.Error()
+		}
+	})
+}

testdata/de.yaml

@@ -0,0 +1 @@
+simple: Einfach

testdata/en.yaml

@@ -0,0 +1,2 @@
+simple: Simple
+fallback: Fallback

testdata/faulty.yaml

@@ -0,0 +1 @@
+hsjdfhksjdhfjshdf, iusdhfjshdkjfhs