| // 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) |
| } |
| } |
| } |
| } |
