PLT-6076 Adding viper libs for config file changes (#5871)

* Adding viper libs for config file changes

* Removing the old fsnotify lib

* updating some missing libs

1 files changed, 450 insertions, 0 deletions

diff --git a/vendor/github.com/spf13/afero/util_test.go b/vendor/github.com/spf13/afero/util_test.go
new file mode 100644
index 000000000..b5852f184
--- /dev/null
+++ b/vendor/github.com/spf13/afero/util_test.go
@@ -0,0 +1,450 @@
+// Copyright ©2015 Steve Francia <spf@spf13.com>
+// Portions Copyright ©2015 The Hugo Authors
+//
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package afero
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+var testFS = new(MemMapFs)
+
+func TestDirExists(t *testing.T) {
+	type test struct {
+		input    string
+		expected bool
+	}
+
+	// First create a couple directories so there is something in the filesystem
+	//testFS := new(MemMapFs)
+	testFS.MkdirAll("/foo/bar", 0777)
+
+	data := []test{
+		{".", true},
+		{"./", true},
+		{"..", true},
+		{"../", true},
+		{"./..", true},
+		{"./../", true},
+		{"/foo/", true},
+		{"/foo", true},
+		{"/foo/bar", true},
+		{"/foo/bar/", true},
+		{"/", true},
+		{"/some-really-random-directory-name", false},
+		{"/some/really/random/directory/name", false},
+		{"./some-really-random-local-directory-name", false},
+		{"./some/really/random/local/directory/name", false},
+	}
+
+	for i, d := range data {
+		exists, _ := DirExists(testFS, filepath.FromSlash(d.input))
+		if d.expected != exists {
+			t.Errorf("Test %d %q failed. Expected %t got %t", i, d.input, d.expected, exists)
+		}
+	}
+}
+
+func TestIsDir(t *testing.T) {
+	testFS = new(MemMapFs)
+
+	type test struct {
+		input    string
+		expected bool
+	}
+	data := []test{
+		{"./", true},
+		{"/", true},
+		{"./this-directory-does-not-existi", false},
+		{"/this-absolute-directory/does-not-exist", false},
+	}
+
+	for i, d := range data {
+
+		exists, _ := IsDir(testFS, d.input)
+		if d.expected != exists {
+			t.Errorf("Test %d failed. Expected %t got %t", i, d.expected, exists)
+		}
+	}
+}
+
+func TestIsEmpty(t *testing.T) {
+	testFS = new(MemMapFs)
+
+	zeroSizedFile, _ := createZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(zeroSizedFile)
+	nonZeroSizedFile, _ := createNonZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(nonZeroSizedFile)
+	emptyDirectory, _ := createEmptyTempDir()
+	defer deleteTempDir(emptyDirectory)
+	nonEmptyZeroLengthFilesDirectory, _ := createTempDirWithZeroLengthFiles()
+	defer deleteTempDir(nonEmptyZeroLengthFilesDirectory)
+	nonEmptyNonZeroLengthFilesDirectory, _ := createTempDirWithNonZeroLengthFiles()
+	defer deleteTempDir(nonEmptyNonZeroLengthFilesDirectory)
+	nonExistentFile := os.TempDir() + "/this-file-does-not-exist.txt"
+	nonExistentDir := os.TempDir() + "/this/direcotry/does/not/exist/"
+
+	fileDoesNotExist := fmt.Errorf("%q path does not exist", nonExistentFile)
+	dirDoesNotExist := fmt.Errorf("%q path does not exist", nonExistentDir)
+
+	type test struct {
+		input          string
+		expectedResult bool
+		expectedErr    error
+	}
+
+	data := []test{
+		{zeroSizedFile.Name(), true, nil},
+		{nonZeroSizedFile.Name(), false, nil},
+		{emptyDirectory, true, nil},
+		{nonEmptyZeroLengthFilesDirectory, false, nil},
+		{nonEmptyNonZeroLengthFilesDirectory, false, nil},
+		{nonExistentFile, false, fileDoesNotExist},
+		{nonExistentDir, false, dirDoesNotExist},
+	}
+	for i, d := range data {
+		exists, err := IsEmpty(testFS, d.input)
+		if d.expectedResult != exists {
+			t.Errorf("Test %d %q failed exists. Expected result %t got %t", i, d.input, d.expectedResult, exists)
+		}
+		if d.expectedErr != nil {
+			if d.expectedErr.Error() != err.Error() {
+				t.Errorf("Test %d failed with err. Expected %q(%#v) got %q(%#v)", i, d.expectedErr, d.expectedErr, err, err)
+			}
+		} else {
+			if d.expectedErr != err {
+				t.Errorf("Test %d failed. Expected error %q(%#v) got %q(%#v)", i, d.expectedErr, d.expectedErr, err, err)
+			}
+		}
+	}
+}
+
+func TestReaderContains(t *testing.T) {
+	for i, this := range []struct {
+		v1     string
+		v2     [][]byte
+		expect bool
+	}{
+		{"abc", [][]byte{[]byte("a")}, true},
+		{"abc", [][]byte{[]byte("b")}, true},
+		{"abcdefg", [][]byte{[]byte("efg")}, true},
+		{"abc", [][]byte{[]byte("d")}, false},
+		{"abc", [][]byte{[]byte("d"), []byte("e")}, false},
+		{"abc", [][]byte{[]byte("d"), []byte("a")}, true},
+		{"abc", [][]byte{[]byte("b"), []byte("e")}, true},
+		{"", nil, false},
+		{"", [][]byte{[]byte("a")}, false},
+		{"a", [][]byte{[]byte("")}, false},
+		{"", [][]byte{[]byte("")}, false}} {
+		result := readerContainsAny(strings.NewReader(this.v1), this.v2...)
+		if result != this.expect {
+			t.Errorf("[%d] readerContains: got %t but expected %t", i, result, this.expect)
+		}
+	}
+
+	if readerContainsAny(nil, []byte("a")) {
+		t.Error("readerContains with nil reader")
+	}
+
+	if readerContainsAny(nil, nil) {
+		t.Error("readerContains with nil arguments")
+	}
+}
+
+func createZeroSizedFileInTempDir() (File, error) {
+	filePrefix := "_path_test_"
+	f, e := TempFile(testFS, "", filePrefix) // dir is os.TempDir()
+	if e != nil {
+		// if there was an error no file was created.
+		// => no requirement to delete the file
+		return nil, e
+	}
+	return f, nil
+}
+
+func createNonZeroSizedFileInTempDir() (File, error) {
+	f, err := createZeroSizedFileInTempDir()
+	if err != nil {
+		// no file ??
+	}
+	byteString := []byte("byteString")
+	err = WriteFile(testFS, f.Name(), byteString, 0644)
+	if err != nil {
+		// delete the file
+		deleteFileInTempDir(f)
+		return nil, err
+	}
+	return f, nil
+}
+
+func deleteFileInTempDir(f File) {
+	err := testFS.Remove(f.Name())
+	if err != nil {
+		// now what?
+	}
+}
+
+func createEmptyTempDir() (string, error) {
+	dirPrefix := "_dir_prefix_"
+	d, e := TempDir(testFS, "", dirPrefix) // will be in os.TempDir()
+	if e != nil {
+		// no directory to delete - it was never created
+		return "", e
+	}
+	return d, nil
+}
+
+func createTempDirWithZeroLengthFiles() (string, error) {
+	d, dirErr := createEmptyTempDir()
+	if dirErr != nil {
+		//now what?
+	}
+	filePrefix := "_path_test_"
+	_, fileErr := TempFile(testFS, d, filePrefix) // dir is os.TempDir()
+	if fileErr != nil {
+		// if there was an error no file was created.
+		// but we need to remove the directory to clean-up
+		deleteTempDir(d)
+		return "", fileErr
+	}
+	// the dir now has one, zero length file in it
+	return d, nil
+
+}
+
+func createTempDirWithNonZeroLengthFiles() (string, error) {
+	d, dirErr := createEmptyTempDir()
+	if dirErr != nil {
+		//now what?
+	}
+	filePrefix := "_path_test_"
+	f, fileErr := TempFile(testFS, d, filePrefix) // dir is os.TempDir()
+	if fileErr != nil {
+		// if there was an error no file was created.
+		// but we need to remove the directory to clean-up
+		deleteTempDir(d)
+		return "", fileErr
+	}
+	byteString := []byte("byteString")
+	fileErr = WriteFile(testFS, f.Name(), byteString, 0644)
+	if fileErr != nil {
+		// delete the file
+		deleteFileInTempDir(f)
+		// also delete the directory
+		deleteTempDir(d)
+		return "", fileErr
+	}
+
+	// the dir now has one, zero length file in it
+	return d, nil
+
+}
+
+func TestExists(t *testing.T) {
+	zeroSizedFile, _ := createZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(zeroSizedFile)
+	nonZeroSizedFile, _ := createNonZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(nonZeroSizedFile)
+	emptyDirectory, _ := createEmptyTempDir()
+	defer deleteTempDir(emptyDirectory)
+	nonExistentFile := os.TempDir() + "/this-file-does-not-exist.txt"
+	nonExistentDir := os.TempDir() + "/this/direcotry/does/not/exist/"
+
+	type test struct {
+		input          string
+		expectedResult bool
+		expectedErr    error
+	}
+
+	data := []test{
+		{zeroSizedFile.Name(), true, nil},
+		{nonZeroSizedFile.Name(), true, nil},
+		{emptyDirectory, true, nil},
+		{nonExistentFile, false, nil},
+		{nonExistentDir, false, nil},
+	}
+	for i, d := range data {
+		exists, err := Exists(testFS, d.input)
+		if d.expectedResult != exists {
+			t.Errorf("Test %d failed. Expected result %t got %t", i, d.expectedResult, exists)
+		}
+		if d.expectedErr != err {
+			t.Errorf("Test %d failed. Expected %q got %q", i, d.expectedErr, err)
+		}
+	}
+
+}
+
+func TestSafeWriteToDisk(t *testing.T) {
+	emptyFile, _ := createZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(emptyFile)
+	tmpDir, _ := createEmptyTempDir()
+	defer deleteTempDir(tmpDir)
+
+	randomString := "This is a random string!"
+	reader := strings.NewReader(randomString)
+
+	fileExists := fmt.Errorf("%v already exists", emptyFile.Name())
+
+	type test struct {
+		filename    string
+		expectedErr error
+	}
+
+	now := time.Now().Unix()
+	nowStr := strconv.FormatInt(now, 10)
+	data := []test{
+		{emptyFile.Name(), fileExists},
+		{tmpDir + "/" + nowStr, nil},
+	}
+
+	for i, d := range data {
+		e := SafeWriteReader(testFS, d.filename, reader)
+		if d.expectedErr != nil {
+			if d.expectedErr.Error() != e.Error() {
+				t.Errorf("Test %d failed. Expected error %q but got %q", i, d.expectedErr.Error(), e.Error())
+			}
+		} else {
+			if d.expectedErr != e {
+				t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, e)
+			}
+			contents, _ := ReadFile(testFS, d.filename)
+			if randomString != string(contents) {
+				t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
+			}
+		}
+		reader.Seek(0, 0)
+	}
+}
+
+func TestWriteToDisk(t *testing.T) {
+	emptyFile, _ := createZeroSizedFileInTempDir()
+	defer deleteFileInTempDir(emptyFile)
+	tmpDir, _ := createEmptyTempDir()
+	defer deleteTempDir(tmpDir)
+
+	randomString := "This is a random string!"
+	reader := strings.NewReader(randomString)
+
+	type test struct {
+		filename    string
+		expectedErr error
+	}
+
+	now := time.Now().Unix()
+	nowStr := strconv.FormatInt(now, 10)
+	data := []test{
+		{emptyFile.Name(), nil},
+		{tmpDir + "/" + nowStr, nil},
+	}
+
+	for i, d := range data {
+		e := WriteReader(testFS, d.filename, reader)
+		if d.expectedErr != e {
+			t.Errorf("Test %d failed. WriteToDisk Error Expected %q but got %q", i, d.expectedErr, e)
+		}
+		contents, e := ReadFile(testFS, d.filename)
+		if e != nil {
+			t.Errorf("Test %d failed. Could not read file %s. Reason: %s\n", i, d.filename, e)
+		}
+		if randomString != string(contents) {
+			t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
+		}
+		reader.Seek(0, 0)
+	}
+}
+
+func TestGetTempDir(t *testing.T) {
+	dir := os.TempDir()
+	if FilePathSeparator != dir[len(dir)-1:] {
+		dir = dir + FilePathSeparator
+	}
+	testDir := "hugoTestFolder" + FilePathSeparator
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"", dir},
+		{testDir + "  Foo bar  ", dir + testDir + "  Foo bar  " + FilePathSeparator},
+		{testDir + "Foo.Bar/foo_Bar-Foo", dir + testDir + "Foo.Bar/foo_Bar-Foo" + FilePathSeparator},
+		{testDir + "fOO,bar:foo%bAR", dir + testDir + "fOObarfoo%bAR" + FilePathSeparator},
+		{testDir + "FOo/BaR.html", dir + testDir + "FOo/BaR.html" + FilePathSeparator},
+		{testDir + "трям/трям", dir + testDir + "трям/трям" + FilePathSeparator},
+		{testDir + "은행", dir + testDir + "은행" + FilePathSeparator},
+		{testDir + "Банковский кассир", dir + testDir + "Банковский кассир" + FilePathSeparator},
+	}
+
+	for _, test := range tests {
+		output := GetTempDir(new(MemMapFs), test.input)
+		if output != test.expected {
+			t.Errorf("Expected %#v, got %#v\n", test.expected, output)
+		}
+	}
+}
+
+// This function is very dangerous. Don't use it.
+func deleteTempDir(d string) {
+	err := os.RemoveAll(d)
+	if err != nil {
+		// now what?
+	}
+}
+
+func TestFullBaseFsPath(t *testing.T) {
+	type dirSpec struct {
+		Dir1, Dir2, Dir3 string
+	}
+	dirSpecs := []dirSpec{
+		dirSpec{Dir1: "/", Dir2: "/", Dir3: "/"},
+		dirSpec{Dir1: "/", Dir2: "/path2", Dir3: "/"},
+		dirSpec{Dir1: "/path1/dir", Dir2: "/path2/dir/", Dir3: "/path3/dir"},
+		dirSpec{Dir1: "C:/path1", Dir2: "path2/dir", Dir3: "/path3/dir/"},
+	}
+
+	for _, ds := range dirSpecs {
+		memFs := NewMemMapFs()
+		level1Fs := NewBasePathFs(memFs, ds.Dir1)
+		level2Fs := NewBasePathFs(level1Fs, ds.Dir2)
+		level3Fs := NewBasePathFs(level2Fs, ds.Dir3)
+
+		type spec struct {
+			BaseFs       Fs
+			FileName     string
+			ExpectedPath string
+		}
+		specs := []spec{
+			spec{BaseFs: level3Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, ds.Dir3, "f.txt")},
+			spec{BaseFs: level3Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, ds.Dir3, "")},
+			spec{BaseFs: level2Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, "f.txt")},
+			spec{BaseFs: level2Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, "")},
+			spec{BaseFs: level1Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, "f.txt")},
+			spec{BaseFs: level1Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, "")},
+		}
+
+		for _, s := range specs {
+			if actualPath := FullBaseFsPath(s.BaseFs.(*BasePathFs), s.FileName); actualPath != s.ExpectedPath {
+				t.Errorf("Expected \n%s got \n%s", s.ExpectedPath, actualPath)
+			}
+		}
+	}
+}