Feature/xdg base dir 2

packer/cache.go

@@ -10,12 +10,18 @@ import (
 // When the directory is not absolute, CachePath will try to make a
 // a cache depending on the operating system.
 //
+// TODO: Update this with better examples
 // NOTE: cache directory will change depending on operating system dependent
-// ex:
+// For Windows:
 //   PACKER_CACHE_DIR=""            CacheDir() => "./packer_cache/
 //   PACKER_CACHE_DIR=""            CacheDir("foo") => "./packer_cache/foo
 //   PACKER_CACHE_DIR="bar"         CacheDir("foo") => "./bar/foo
 //   PACKER_CACHE_DIR="/home/there" CacheDir("foo", "bar") => "/home/there/foo/bar
+// For Unix:
+//   PACKER_CACHE_DIR="",            XDG_CONFIG_HOME="", Default_config CacheDir() => "$HOME/cache/packer"
+//   PACKER_CACHE_DIR="",            XDG_CONFIG_HOME="", Default_config CacheDir("foo") => "$HOME/cache/packer/foo"
+//   PACKER_CACHE_DIR="bar",         XDG_CONFIG_HOME="", Default_config CacheDir("foo") => "./bar/foo
+//   PACKER_CACHE_DIR="/home/there", XDG_CONFIG_HOME="", Default_config CacheDir("foo", "bar") => "/home/there/foo/bar
 func CachePath(paths ...string) (path string, err error) {
 	defer func() {
 		// create the dir based on return path if it doesn't exist
@@ -27,9 +33,5 @@ func CachePath(paths ...string) (path string, err error) {
 	}
 
 	paths = append([]string{cacheDir}, paths...)
-	result, err := filepath.Abs(filepath.Join(paths...))
-	if err != nil {
-		return "", err
-	}
-	return result, err
+	return filepath.Abs(filepath.Join(paths...))
 }

packer/cache_config_unix.go

@@ -13,9 +13,9 @@ func getDefaultCacheDir() string {
 	if xdgCacheHome := os.Getenv("XDG_CACHE_HOME"); xdgCacheHome != "" {
 		return filepath.Join(xdgCacheHome, "packer")
 	}
-		homeDir := os.Getenv("HOME")
-		defaultConfigFileDir = filepath.Join(homeDir, ".cache", "packer")
-	}
+
+	homeDir := os.Getenv("HOME")
+	defaultConfigFileDir = filepath.Join(homeDir, ".cache", "packer")
 
 	return defaultConfigFileDir
 }

packer/cache_config_unix_test.go

@@ -0,0 +1,108 @@
+// +build darwin freebsd linux netbsd openbsd solaris
+
+package packer
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCachePath(t *testing.T) {
+	// temporary directories for env vars
+	xdgCacheHomeTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+	defer os.RemoveAll(xdgCacheHomeTempDir)
+	packerCacheTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+	defer os.RemoveAll(packerCacheTempDir)
+
+	// reset env
+	packerCacheDir := os.Getenv("PACKER_CACHE_DIR")
+	os.Setenv("PACKER_CACHE_DIR", "")
+	defer func() {
+		os.Setenv("PACKER_CACHE_DIR", packerCacheDir)
+	}()
+
+	xdgCacheHomeDir := os.Getenv("XDG_CACHE_HOME")
+	os.Setenv("XDG_CACHE_HOME", "")
+	defer func() {
+		os.Setenv("XDG_CACHE_HOME", xdgCacheHomeDir)
+	}()
+
+	type args struct {
+		paths []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		env     map[string]string
+		want    string
+		wantErr bool
+	}{
+		{
+			"base",
+			args{},
+			nil,
+			filepath.Join(os.Getenv("HOME"), ".cache", "packer"),
+			false,
+		},
+		{
+			"base and path",
+			args{[]string{"a", "b"}},
+			nil,
+			filepath.Join(os.Getenv("HOME"), ".cache", "packer", "a", "b"),
+			false,
+		},
+		{
+			"env PACKER_CACHE_DIR and path",
+			args{[]string{"a", "b"}},
+			map[string]string{"PACKER_CACHE_DIR": packerCacheTempDir},
+			filepath.Join(packerCacheTempDir, "a", "b"),
+			false,
+		},
+		{
+			"env XDG_CACHE_HOME and path",
+			args{[]string{"a", "b"}},
+			map[string]string{"XDG_CACHE_HOME": xdgCacheHomeTempDir},
+			filepath.Join(xdgCacheHomeTempDir, "packer", "a", "b"),
+			false,
+		},
+		{
+			"env PACKER_CACHE_DIR, XDG_CACHE_HOME, and path",
+			args{[]string{"a", "b"}},
+			map[string]string{
+				"XDG_CACHE_HOME":   xdgCacheHomeTempDir,
+				"PACKER_CACHE_DIR": packerCacheTempDir,
+			},
+			filepath.Join(packerCacheTempDir, "a", "b"),
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for k, v := range tt.env {
+				os.Setenv(k, v)
+			}
+			got, err := CachePath(tt.args.paths...)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CachePath() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("CachePath() = %v, want %v", got, tt.want)
+			}
+			resetTestEnv()
+		})
+	}
+}
+
+func resetTestEnv() {
+	os.Setenv("PACKER_CACHE_DIR", "")
+	os.Setenv("XDG_CACHE_HOME", "")
+}

packer/cache_config_windows_test.go

@@ -0,0 +1,54 @@
+// +build windows
+
+package packer
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCachePath(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Getwd: %v", err)
+	}
+	tmp := os.TempDir()
+
+	// reset env
+	cd := os.Getenv("PACKER_CACHE_DIR")
+	os.Setenv("PACKER_CACHE_DIR", "")
+	defer func() {
+		os.Setenv("PACKER_CACHE_DIR", cd)
+	}()
+
+	type args struct {
+		paths []string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		env     map[string]string
+		want    string
+		wantErr bool
+	}{
+		{"base", args{}, nil, filepath.Join(wd, "packer_cache"), false},
+		{"base and path", args{[]string{"a", "b"}}, nil, filepath.Join(wd, "packer_cache", "a", "b"), false},
+		{"env and path", args{[]string{"a", "b"}}, map[string]string{"PACKER_CACHE_DIR": tmp}, filepath.Join(tmp, "a", "b"), false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for k, v := range tt.env {
+				os.Setenv(k, v)
+			}
+			got, err := CachePath(tt.args.paths...)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CachePath() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("CachePath() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pathing/config_file_unix.go

@@ -3,6 +3,7 @@
 package pathing
 
 import (
+	"errors"
 	"log"
 	"os"
 	"path/filepath"
@@ -14,15 +15,20 @@ const (
 )
 
 func configDir() (path string, err error) {
+
+	if cd := os.Getenv("PACKER_CONFIG_DIR"); cd != "" {
+		log.Printf("Detected config directory from env var: %s", cd)
+		return filepath.Join(cd, defaultConfigDir), nil
+	}
+
 	var dir string
 	homedir := os.Getenv("HOME")
+
 	if homedir == "" {
-		return "", err
+		return "", errors.New("No $HOME environment variable found, required to set Config Directory")
 	}
-	if cd := os.Getenv("PACKER_CONFIG_DIR"); cd != "" {
-		log.Printf("Detected config directory from env var: %s", cd)
-		dir = filepath.Join(cd, defaultConfigDir)
-	} else if hasDefaultConfigFileLocation(homedir) {
+
+	if hasDefaultConfigFileLocation(homedir) {
 		dir = filepath.Join(homedir, defaultConfigDir)
 		log.Printf("Old default config directory found: %s", dir)
 	} else if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {

pathing/config_file_unix_test.go

@@ -0,0 +1,141 @@
+// +build darwin freebsd linux netbsd openbsd solaris
+
+package pathing
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestConfigPath(t *testing.T) {
+	// temporary directories for env vars
+	xdgConfigHomeTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+	defer os.RemoveAll(xdgConfigHomeTempDir)
+
+	packerConfigTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+	defer os.RemoveAll(packerConfigTempDir)
+
+	homeTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+	defer os.RemoveAll(homeTempDir)
+
+	homeDirDefaultConfigTempDir, err := ioutil.TempDir(os.TempDir(), "*")
+	if err != nil {
+		t.Fatalf("Failed to create temp test directory: failing test: %v", err)
+	}
+
+	err = os.Mkdir(filepath.Join(homeDirDefaultConfigTempDir, defaultConfigDir), 0755)
+	if err != nil {
+		t.Fatalf("Failed to create temp test file: failing test: %v", err)
+	}
+	defer os.RemoveAll(homeDirDefaultConfigTempDir)
+
+	// reset env
+	packerConfigDir := os.Getenv("PACKER_CONFIG_DIR")
+	os.Setenv("PACKER_CONFIG_DIR", "")
+	defer func() {
+		os.Setenv("PACKER_CONFIG_DIR", packerConfigDir)
+	}()
+
+	xdgConfigHomeDir := os.Getenv("XDG_CONFIG_HOME")
+	os.Setenv("XDG_CONFIG_HOME", "")
+	defer func() {
+		os.Setenv("XDG_CONFIG_HOME", xdgConfigHomeDir)
+	}()
+
+	homeDir := os.Getenv("HOME")
+	os.Setenv("HOME", "")
+	defer func() {
+		os.Setenv("HOME", homeDir)
+	}()
+
+	tests := []struct {
+		name    string
+		env     map[string]string
+		want    string
+		wantErr bool
+	}{
+		{
+			"no HOME env var",
+			nil,
+			"",
+			true,
+		},
+		{
+			"base",
+			map[string]string{"HOME": homeTempDir},
+			filepath.Join(homeTempDir, ".config", "packer"),
+			false,
+		},
+		{
+			"XDG_CONFIG_HOME set without default file",
+			map[string]string{
+				"XDG_CONFIG_HOME": xdgConfigHomeTempDir,
+				"HOME":            homeTempDir,
+			},
+			filepath.Join(xdgConfigHomeTempDir, "packer"),
+			false,
+		},
+		{
+			"env PACKER_CONFIG_DIR",
+			map[string]string{"PACKER_CONFIG_DIR": packerConfigTempDir},
+			filepath.Join(packerConfigTempDir, defaultConfigDir),
+			false,
+		},
+		{
+			"env PACKER_CONFIG_DIR, XDG_CONFIG_HOME",
+			map[string]string{
+				"XDG_CONFIG_HOME":   xdgConfigHomeTempDir,
+				"PACKER_CONFIG_DIR": packerConfigTempDir,
+			},
+			filepath.Join(packerConfigTempDir, defaultConfigDir),
+			false,
+		},
+		{
+			"Old Default Config Found",
+			map[string]string{"HOME": homeDirDefaultConfigTempDir},
+			filepath.Join(homeDirDefaultConfigTempDir, defaultConfigDir),
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for k, v := range tt.env {
+				os.Setenv(k, v)
+			}
+			got, err := ConfigDir()
+			if (err != nil) != tt.wantErr {
+				t.Errorf(
+					"Name: %v, ConfigPath() error = %v, wantErr %v",
+					tt.name,
+					err,
+					tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf(
+					"Name: %v, ConfigPath() = %v, want %v",
+					tt.name,
+					got,
+					tt.want)
+			}
+			resetTestEnv()
+		})
+	}
+}
+
+func resetTestEnv() {
+	os.Setenv("PACKER_CONFIG_DIR", "")
+	os.Setenv("XDG_CONFIG_HOME", "")
+	os.Setenv("HOME", "")
+}