enable to configure directory providers to search in a deeper path

Author: Oppodelldog

discovery_test.go

@@ -7,9 +7,10 @@ import (
 	"path"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"fmt"
 	"io/ioutil"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNew(t *testing.T) {
@@ -129,7 +130,7 @@ func TestFileDiscovery_Discover_ifFileWasFoundReturnsFilePath(t *testing.T) {
 func ExampleFileDiscovery_Discover() {
 
 	// for this demonstration we create a test file in /tmp
-	testFilePath := "/tmp/test-file.yml";
+	testFilePath := "/tmp/test-file.yml"
 	ioutil.WriteFile(testFilePath, []byte("test"), 0666)
 
 	// Discovery needs at least one FileLocationProvider which provides a file location to search for.

providers.go

@@ -3,38 +3,43 @@ package filediscovery
 import (
 	"fmt"
 	"os"
+	"os/user"
 	"path"
 	"path/filepath"
-	"os/user"
 )
 
 var workingDirProviderFunc = os.Getwd
 
 // WorkingDirProvider provides the working directory as a possible file location
-func WorkingDirProvider() FileLocationProvider {
+func WorkingDirProvider(subFolders ...string) FileLocationProvider {
 
 	return func(fileName string) (string, error) {
 		dir, err := workingDirProviderFunc()
 		if err != nil {
 			return "", err
 		}
 
-		return path.Join(dir, fileName), nil
+		subFoldersPath := createPath(subFolders...)
+
+		return path.Join(dir, subFoldersPath, fileName), nil
 	}
 }
 
 var executableDirProviderFunc = os.Executable
 
 // ExecutableDirProvider provides the executables directory as a possible file location
-func ExecutableDirProvider() FileLocationProvider {
+func ExecutableDirProvider(subFolders ...string) FileLocationProvider {
 
 	return func(fileName string) (string, error) {
 		dir, err := executableDirProviderFunc()
 		if err != nil {
 			return "", err
 		}
 
-		return path.Join(filepath.Dir(dir), fileName), nil
+		executableDir := filepath.Dir(dir)
+		subFoldersPath := createPath(subFolders...)
+
+		return path.Join(executableDir, subFoldersPath, fileName), nil
 	}
 }
 
@@ -54,7 +59,6 @@ func EnvVarFilePathProvider(envVar string) FileLocationProvider {
 	}
 }
 
-
 var homeFolderLookupFunc = user.Current
 
 // HomeConfigDirProvider provides the working directory as a possible file location
@@ -66,11 +70,17 @@ func HomeConfigDirProvider(subFolders ...string) FileLocationProvider {
 			return "", err
 		}
 
-		subfoldersPath := ""
-		for _, subfolder := range subFolders {
-			subfoldersPath = path.Join(subfoldersPath, subfolder)
-		}
+		subFoldersPath := createPath(subFolders...)
 
-		return path.Join(usr.HomeDir, subfoldersPath, fileName), nil
+		return path.Join(usr.HomeDir, subFoldersPath, fileName), nil
 	}
-}
+}
+
+func createPath(subFolders ...string) string {
+	subFoldersPath := ""
+	for _, subfolder := range subFolders {
+		subFoldersPath = path.Join(subFoldersPath, subfolder)
+	}
+
+	return subFoldersPath
+}

providers_test.go

@@ -3,29 +3,55 @@ package filediscovery
 import (
 	"os"
 	"path"
-	"path/filepath"
 	"testing"
 
 	"errors"
 
-	"github.com/stretchr/testify/assert"
 	"os/user"
+	"path/filepath"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestWorkingDirProvider(t *testing.T) {
-	testFileName := "testfile"
-	provider := WorkingDirProvider()
-	result, err := provider(testFileName)
-	if err != nil {
-		t.Fatalf("Did not expect provider to return an error, but got: %v", err)
-	}
 
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("Did not expect os.Getwd to return an error, but got: %v", err)
 	}
 
-	assert.Equal(t, path.Join(wd, testFileName), result)
+	testFileName := "testfile"
+
+	testDataSet := map[string]struct {
+		SubFolders   []string
+		ExpectedPath string
+	}{
+		"simple call": {
+			SubFolders:   []string{},
+			ExpectedPath: path.Join(wd, testFileName),
+		},
+		"one subdir": {
+			SubFolders:   []string{"subdir1"},
+			ExpectedPath: path.Join(wd, "subdir1", testFileName),
+		},
+		"two subdirs": {
+			SubFolders:   []string{"subdir1", "subdir2"},
+			ExpectedPath: path.Join(wd, "subdir1", "subdir2", testFileName),
+		},
+	}
+
+	for testCaseName, testData := range testDataSet {
+		t.Run(testCaseName, func(t *testing.T) {
+
+			provider := WorkingDirProvider(testData.SubFolders...)
+			result, err := provider(testFileName)
+			if err != nil {
+				t.Fatalf("Did not expect provider to return an error, but got: %v", err)
+			}
+
+			assert.Equal(t, testData.ExpectedPath, result)
+		})
+	}
 }
 
 func TestWorkingDirProvider_error(t *testing.T) {
@@ -45,20 +71,41 @@ func TestWorkingDirProvider_error(t *testing.T) {
 func TestExecutableDirProvider(t *testing.T) {
 	testFileName := "testfile"
 
-	provider := ExecutableDirProvider()
-	result, err := provider(testFileName)
-	if err != nil {
-		t.Fatalf("Did not expect provider to return an error, but got: %v", err)
-	}
-
 	executableFilePath, err := os.Executable()
 	if err != nil {
 		t.Fatalf("Did not expect os.Executable to return an error, but got: %v", err)
 	}
+	executableFilePath = filepath.Dir(executableFilePath)
+
+	testDataSet := map[string]struct {
+		SubFolders   []string
+		ExpectedPath string
+	}{
+		"simple call": {
+			SubFolders:   []string{},
+			ExpectedPath: path.Join(executableFilePath, testFileName),
+		},
+		"one subdir": {
+			SubFolders:   []string{"subdir1"},
+			ExpectedPath: path.Join(executableFilePath, "subdir1", testFileName),
+		},
+		"two subdirs": {
+			SubFolders:   []string{"subdir1", "subdir2"},
+			ExpectedPath: path.Join(executableFilePath, "subdir1", "subdir2", testFileName),
+		},
+	}
 
-	expectedFilePath := path.Join(filepath.Dir(executableFilePath), testFileName)
+	for testCaseName, testData := range testDataSet {
+		t.Run(testCaseName, func(t *testing.T) {
+			provider := ExecutableDirProvider(testData.SubFolders...)
+			result, err := provider(testFileName)
+			if err != nil {
+				t.Fatalf("Did not expect provider to return an error, but got: %v", err)
+			}
 
-	assert.Equal(t, expectedFilePath, result)
+			assert.Equal(t, testData.ExpectedPath, result)
+		})
+	}
 }
 
 func TestExecutableDirProvider_error(t *testing.T) {
@@ -101,27 +148,45 @@ func TestEnvVarFilePathProvider_error(t *testing.T) {
 	testFileName := "" // not necessary for this test, since filename comes from env var
 	_, err := provider(testFileName)
 	assert.Error(t, err)
-
 }
 
 func TestHomeConfigDirProvider(t *testing.T) {
 	testFileName := "testfile"
 
-	subfolder1 := ".config"
-	subfolder2 := "some-project"
-	provider := HomeConfigDirProvider(subfolder1, subfolder2)
-	result, err := provider(testFileName)
-	if err != nil {
-		t.Fatalf("Did not expect provider to return an error, but got: %v", err)
-	}
-
 	usr, err := user.Current()
 	if err != nil {
 		t.Fatalf("Did not expect user.Current to return an error, but got: %v", err)
 	}
 
-	expectedFilepath := path.Join(usr.HomeDir, subfolder1, subfolder2, testFileName)
-	assert.Equal(t, expectedFilepath, result)
+	testDataSet := map[string]struct {
+		SubFolders   []string
+		ExpectedPath string
+	}{
+		"simple call": {
+			SubFolders:   []string{},
+			ExpectedPath: path.Join(usr.HomeDir, testFileName),
+		},
+		"one subdir": {
+			SubFolders:   []string{"subdir1"},
+			ExpectedPath: path.Join(usr.HomeDir, "subdir1", testFileName),
+		},
+		"two subdirs": {
+			SubFolders:   []string{"subdir1", "subdir2"},
+			ExpectedPath: path.Join(usr.HomeDir, "subdir1", "subdir2", testFileName),
+		},
+	}
+
+	for testCaseName, testData := range testDataSet {
+		t.Run(testCaseName, func(t *testing.T) {
+			provider := HomeConfigDirProvider(testData.SubFolders...)
+			result, err := provider(testFileName)
+			if err != nil {
+				t.Fatalf("Did not expect provider to return an error, but got: %v", err)
+			}
+
+			assert.Equal(t, testData.ExpectedPath, result)
+		})
+	}
 }
 
 func TestHomeConfigDirProvider_UserLookupReturnsError(t *testing.T) {