tests: around 60% code coverage for config package

easier to unit test our util commands like this

cli/app.go

@@ -56,7 +56,10 @@ var appListCommand = &cli.Command{
 		// FIXME: Needs to use flags
 		// TODO: Sorting of output to make servers in alphabetical
 		// Looks like sorting a 2d slice of strings might be messy though
-		apps := config.LoadAppFiles()
+		apps, err := config.LoadAppFiles()
+		if err != nil {
+			logrus.Fatal(err)
+		}
 		tableCol := []string{"Name", "Type", "Server"}
 		table := createTable(tableCol)
 		for name, appFile := range apps {

cli/server.go

@@ -5,6 +5,7 @@ import (
 
 	"coopcloud.tech/abra/client"
 	"coopcloud.tech/abra/config"
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
@@ -18,13 +19,16 @@ var serverListCommand = &cli.Command{
 		dockerContextStore := client.NewDefaultDockerContextStore()
 		contexts, err := dockerContextStore.Store.List()
 		if err != nil {
-			panic(err)
+			logrus.Fatal(err)
 		}
 		tableColumns := []string{"Name", "Connection"}
 		table := createTable(tableColumns)
 		defer table.Render()
 
-		serverNames := config.ReadServerNames()
+		serverNames, err := config.ReadServerNames()
+		if err != nil {
+			logrus.Fatal(err)
+		}
 		for _, serverName := range serverNames {
 
 			var row []string

config/env.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io/fs"
 	"io/ioutil"
-	"log"
 	"os"
 	"path"
 	"path/filepath"
@@ -35,12 +34,18 @@ type AppFile struct {
 
 type AppFiles = map[AppName]AppFile
 
-func LoadAppFiles() AppFiles {
+func LoadAppFiles() (AppFiles, error) {
 	appFiles := make(AppFiles)
-	servers := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+	servers, err := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+	if err != nil {
+		return nil, err
+	}
 	for _, server := range servers {
 		serverDir := path.Join(ABRA_SERVER_FOLDER, server)
-		files := getAllFilesInDirectory(serverDir)
+		files, err := getAllFilesInDirectory(serverDir)
+		if err != nil {
+			return nil, err
+		}
 		for _, file := range files {
 			appName := strings.TrimSuffix(file.Name(), ".env")
 			appFilePath := path.Join(ABRA_SERVER_FOLDER, server, file.Name())
@@ -50,7 +55,7 @@ func LoadAppFiles() AppFiles {
 			}
 		}
 	}
-	return appFiles
+	return appFiles, nil
 }
 
 // GetApp loads an apps settings, reading it from file, in preparation to use it
@@ -64,15 +69,19 @@ func GetApp(apps AppFiles, name AppName) (App, error) {
 		return App{}, fmt.Errorf("cannot find app file with name '%s'", name)
 	}
 	app, err := readAppFile(appFile, name)
-
 	if err != nil {
-		log.Fatalf(err.Error())
+		return App{}, err
 	}
 	return app, nil
 }
 
+// TODO: maybe better names than read and get
+
 func readAppFile(appFile AppFile, name AppName) (App, error) {
-	env := readEnv(appFile.Path)
+	env, err := readEnv(appFile.Path)
+	if err != nil {
+		return App{}, fmt.Errorf("env file for '%s' couldn't be read: %s", name, err.Error())
+	}
 	app, err := makeApp(env, name)
 	if err != nil {
 		return App{}, fmt.Errorf("env file for '%s' has issues: %s", name, err.Error())
@@ -80,13 +89,13 @@ func readAppFile(appFile AppFile, name AppName) (App, error) {
 	return app, nil
 }
 
-func readEnv(filePath string) AppEnv {
+func readEnv(filePath string) (AppEnv, error) {
 	var envFile AppEnv
 	envFile, err := godotenv.Read(filePath)
 	if err != nil {
-		log.Fatalln(err.Error())
+		return nil, err
 	}
-	return envFile
+	return envFile, nil
 }
 
 func makeApp(env AppEnv, name string) (App, error) {
@@ -107,17 +116,20 @@ func makeApp(env AppEnv, name string) (App, error) {
 	}, nil
 }
 
-func ReadServerNames() []string {
-	serverNames := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
-	return serverNames
+func ReadServerNames() ([]string, error) {
+	serverNames, err := getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
+	if err != nil {
+		return nil, err
+	}
+	return serverNames, nil
 }
 
 // getAllFilesInDirectory returns filenames of all files in directory
-func getAllFilesInDirectory(directory string) []fs.FileInfo {
+func getAllFilesInDirectory(directory string) ([]fs.FileInfo, error) {
 	var realFiles []fs.FileInfo
 	files, err := ioutil.ReadDir(directory)
 	if err != nil {
-		logrus.Fatal(err.Error())
+		return nil, err
 	}
 	for _, file := range files {
 		// Follow any symlinks
@@ -128,7 +140,7 @@ func getAllFilesInDirectory(directory string) []fs.FileInfo {
 		} else {
 			realFile, err := os.Stat(realPath)
 			if err != nil {
-				logrus.Fatal(err.Error())
+				return nil, err
 			}
 			if !realFile.IsDir() {
 				realFiles = append(realFiles, file)
@@ -136,18 +148,18 @@ func getAllFilesInDirectory(directory string) []fs.FileInfo {
 		}
 
 	}
-	return realFiles
+	return realFiles, nil
 }
 
 // getAllFoldersInDirectory returns both folder and symlink paths
-func getAllFoldersInDirectory(directory string) []string {
+func getAllFoldersInDirectory(directory string) ([]string, error) {
 	var folders []string
 	files, err := ioutil.ReadDir(directory)
 	if err != nil {
-		logrus.Fatal(err.Error())
+		return nil, err
 	}
 	if len(files) == 0 {
-		logrus.Fatal("directory is empty: '%s'", directory)
+		return nil, fmt.Errorf("directory is empty: '%s'", directory)
 	}
 	for _, file := range files {
 		// Check if file is directory or symlink
@@ -162,5 +174,5 @@ func getAllFoldersInDirectory(directory string) []string {
 			}
 		}
 	}
-	return folders
+	return folders, nil
 }

config/env_test.go

@@ -0,0 +1,113 @@
+package config
+
+import (
+	"os"
+	"path"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var testFolder = os.ExpandEnv("$PWD/../tests/resources/test_folder")
+var validAbraConf = os.ExpandEnv("$PWD/../tests/resources/valid_abra_config")
+
+// make sure these are in alphabetical order
+var tFolders = []string{"folder1", "folder2"}
+var tFiles = []string{"bar", "foo"}
+
+var appName = "ecloud"
+var serverName = "evil.corp"
+
+var expectedAppEnv = AppEnv{
+	"DOMAIN": "ecloud.evil.corp",
+	"TYPE":   "ecloud",
+}
+
+var expectedApp = App{
+	Name:   appName,
+	Type:   expectedAppEnv["TYPE"],
+	Domain: expectedAppEnv["DOMAIN"],
+	Env:    expectedAppEnv,
+}
+
+var expectedAppFile = AppFile{
+	Path:   path.Join(validAbraConf, "servers", serverName, appName+".env"),
+	Server: serverName,
+}
+
+var expectedAppFiles = map[string]AppFile{
+	appName: expectedAppFile,
+}
+
+// var expectedServerNames = []string{"evil.corp"}
+
+func TestGetAllFoldersInDirectory(t *testing.T) {
+	folders, err := getAllFoldersInDirectory(testFolder)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(folders, tFolders) {
+		t.Fatalf("did not get expected folders. Expected: (%s), Got: (%s)", strings.Join(tFolders, ","), strings.Join(folders, ","))
+	}
+}
+
+func TestGetAllFilesInDirectory(t *testing.T) {
+	files, err := getAllFilesInDirectory(testFolder)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fileNames []string
+	for _, file := range files {
+		fileNames = append(fileNames, file.Name())
+	}
+	if !reflect.DeepEqual(fileNames, tFiles) {
+		t.Fatalf("did not get expected files. Expected: (%s), Got: (%s)", strings.Join(tFiles, ","), strings.Join(fileNames, ","))
+	}
+}
+
+func TestReadEnv(t *testing.T) {
+	env, err := readEnv(expectedAppFile.Path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(env, expectedAppEnv) {
+		t.Fatalf(
+			"did not get expected application settings. Expected: DOMAIN=%s TYPE=%s; Got: DOMAIN=%s TYPE=%s",
+			expectedAppEnv["DOMAIN"],
+			expectedAppEnv["TYPE"],
+			env["DOMAIN"],
+			env["TYPE"],
+		)
+	}
+}
+
+func TestMakeApp(t *testing.T) {
+	app, err := makeApp(expectedAppEnv, appName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(app, expectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
+	}
+}
+
+func TestReadAppFile(t *testing.T) {
+	app, err := readAppFile(expectedAppFile, appName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(app, expectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
+	}
+}
+
+func TestGetApp(t *testing.T) {
+	// TODO: Test failures as well as successes
+	app, err := GetApp(expectedAppFiles, appName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(app, expectedApp) {
+		t.Fatalf("did not get expected app type. Expected: %s; Got: %s", app, expectedApp)
+	}
+}

tests/resources/test_folder/folder1/readme.txt

@@ -0,0 +1,5 @@
+--------- readme.txt---------
+
+        LEAVE ME HERE
+
+-----------------------------

tests/resources/valid_abra_config/servers/evil.corp/ecloud.env

@@ -0,0 +1,2 @@
+TYPE=ecloud
+DOMAIN=ecloud.evil.corp