new flag to set config file path

Author: Alex Rios

files.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/json"
+
 	"github.com/spf13/afero"
 )
 
@@ -42,8 +43,8 @@ func (c *ConfigFile) enforceDefaults() {
 	}
 }
 
-func loadConfig(fs afero.Fs) (ConfigFile, error) {
-	file, err := afero.ReadFile(fs, DefaultConfigurationFileName)
+func loadConfig(fs afero.Fs, path string) (ConfigFile, error) {
+	file, err := afero.ReadFile(fs, path)
 	if err != nil {
 		return ConfigFile{}, err
 	}
@@ -57,16 +58,16 @@ func loadConfig(fs afero.Fs) (ConfigFile, error) {
 	return configFile, nil
 }
 
-func isFirstRun(fs afero.Fs) (bool, error) {
-	exists, err := afero.Exists(fs, DefaultConfigurationFileName)
+func isFirstRun(fs afero.Fs, path string) (bool, error) {
+	exists, err := afero.Exists(fs, path)
 	if err != nil {
 		return false, err
 	}
 	return !exists, nil
 }
 
-func configureFirstRun(fs afero.Fs) error {
-	err := afero.WriteFile(fs, DefaultConfigurationFileName, []byte(DefaultConfigurationFileContent), 0644)
+func configureFirstRun(fs afero.Fs, path string) error {
+	err := afero.WriteFile(fs, path, []byte(DefaultConfigurationFileContent), 0644)
 	if err != nil {
 		return err
 	}

files_test.go

@@ -1,24 +1,42 @@
 package main
 
 import (
-	"github.com/spf13/afero"
-	"github.com/stretchr/testify/assert"
+	"path/filepath"
 	"syscall"
 	"testing"
+
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFirstRun(t *testing.T) {
 	t.Run("is the first time running", func(t *testing.T) {
 		fs := afero.NewMemMapFs()
-		firstRun, err := isFirstRun(fs)
+		firstRun, err := isFirstRun(fs, DefaultConfigurationFileName)
+
+		assert.Nil(t, err)
+		assert.True(t, firstRun)
+	})
+	t.Run("is the first time running given a config path", func(t *testing.T) {
+		fs := afero.NewMemMapFs()
+		firstRun, err := isFirstRun(fs, filepath.Join("newpath", DefaultConfigurationFileName))
 
 		assert.Nil(t, err)
 		assert.True(t, firstRun)
 	})
 	t.Run("is NOT the first time running", func(t *testing.T) {
 		fs := afero.NewMemMapFs()
 		_, _ = fs.Create(DefaultConfigurationFileName)
-		firstRun, err := isFirstRun(fs)
+		firstRun, err := isFirstRun(fs, DefaultConfigurationFileName)
+
+		assert.Nil(t, err)
+		assert.False(t, firstRun)
+	})
+	t.Run("is NOT the first time running given a config path", func(t *testing.T) {
+		fs := afero.NewMemMapFs()
+		path := filepath.Join("newpath", DefaultConfigurationFileName)
+		_, _ = fs.Create(path)
+		firstRun, err := isFirstRun(fs, path)
 
 		assert.Nil(t, err)
 		assert.False(t, firstRun)
@@ -28,14 +46,21 @@ func TestFirstRun(t *testing.T) {
 func TestConfigureFirstRun(t *testing.T) {
 	t.Run("configure first time use files", func(t *testing.T) {
 		fs := afero.NewMemMapFs()
-		err := configureFirstRun(fs)
+		err := configureFirstRun(fs, DefaultConfigurationFileName)
+
+		assert.Nil(t, err)
+	})
+
+	t.Run("configure first time use files given a config path", func(t *testing.T) {
+		fs := afero.NewMemMapFs()
+		err := configureFirstRun(fs, filepath.Join("newpath", DefaultConfigurationFileName))
 
 		assert.Nil(t, err)
 	})
 
 	t.Run("cannot configure when is a read only dir", func(t *testing.T) {
 		fs := afero.NewReadOnlyFs(afero.NewMemMapFs())
-		err := configureFirstRun(fs)
+		err := configureFirstRun(fs, DefaultConfigurationFileName)
 		if assert.Error(t, err) {
 			assert.Equal(t, syscall.Errno(1), err)
 		}
@@ -45,9 +70,22 @@ func TestConfigureFirstRun(t *testing.T) {
 func TestLoadConfig(t *testing.T) {
 	t.Run("loading config file", func(t *testing.T) {
 		fs := afero.NewMemMapFs()
-		_ = configureFirstRun(fs)
+		_ = configureFirstRun(fs, DefaultConfigurationFileName)
+
+		config, err := loadConfig(fs, DefaultConfigurationFileName)
+		assert.Nil(t, err)
+		assert.Equal(t, ":8080", config.Addr)
+		assert.Equal(t, 1, len(config.Responses))
+		assert.Equal(t, 200, config.Responses[0].Status)
+		assert.Equal(t, "GET", config.Responses[0].Method)
+		assert.Equal(t, "0ms", config.Responses[0].Latency)
+	})
+	t.Run("loading config file", func(t *testing.T) {
+		path := filepath.Join("newpath", DefaultConfigurationFileName)
+		fs := afero.NewMemMapFs()
+		_ = configureFirstRun(fs, path)
 
-		config, err := loadConfig(fs)
+		config, err := loadConfig(fs, path)
 		assert.Nil(t, err)
 		assert.Equal(t, ":8080", config.Addr)
 		assert.Equal(t, 1, len(config.Responses))

main.go

@@ -2,42 +2,54 @@ package main
 
 import (
 	"context"
+	"flag"
 	"fmt"
-	"github.com/gorilla/handlers"
-	"github.com/gorilla/mux"
-	log "github.com/sirupsen/logrus"
-	"github.com/spf13/afero"
 	"net/http"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"syscall"
 	"time"
+
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/afero"
 )
 
 const ShutdownTimeout = "30s"
 
 func main() {
+	var cfgPath string
+	flag.StringVar(&cfgPath, "config", "", "location of config file (default: .)")
+	flag.Parse()
+
 	logger := log.New()
 	var appFs = afero.NewOsFs()
-	if err := run(appFs, logger); err != nil {
+	if cfgPath == "" {
+		cfgPath = DefaultConfigurationFileName
+	} else {
+		cfgPath = filepath.Join(cfgPath, DefaultConfigurationFileName)
+	}
+	if err := run(appFs, cfgPath, logger); err != nil {
 		log.WithField("fn", "main").Error(err)
 		os.Exit(1)
 	}
 }
 
-func run(fs afero.Fs, log *log.Logger) error {
-	firstRun, err := isFirstRun(fs)
+func run(fs afero.Fs, path string, log *log.Logger) error {
+	firstRun, err := isFirstRun(fs, path)
 	if err != nil {
 		return err
 	}
 	if firstRun {
-		err = configureFirstRun(fs)
+		err = configureFirstRun(fs, path)
 		if err != nil {
 			return err
 		}
 	}
 
-	configFile, err := loadConfig(fs)
+	configFile, err := loadConfig(fs, path)
 	if err != nil {
 		return err
 	}