| package fsys |
| |
| import ( |
| "cmd/go/internal/txtar" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "internal/testenv" |
| "io" |
| "io/fs" |
| "os" |
| "path/filepath" |
| "reflect" |
| "testing" |
| ) |
| |
| // initOverlay resets the overlay state to reflect the config. |
| // config should be a text archive string. The comment is the overlay config |
| // json, and the files, in the archive are laid out in a temp directory |
| // that cwd is set to. |
| func initOverlay(t *testing.T, config string) { |
| t.Helper() |
| |
| // Create a temporary directory and chdir to it. |
| prevwd, err := os.Getwd() |
| if err != nil { |
| t.Fatal(err) |
| } |
| cwd = filepath.Join(t.TempDir(), "root") |
| if err := os.Mkdir(cwd, 0777); err != nil { |
| t.Fatal(err) |
| } |
| if err := os.Chdir(cwd); err != nil { |
| t.Fatal(err) |
| } |
| t.Cleanup(func() { |
| overlay = nil |
| if err := os.Chdir(prevwd); err != nil { |
| t.Fatal(err) |
| } |
| }) |
| |
| a := txtar.Parse([]byte(config)) |
| for _, f := range a.Files { |
| name := filepath.Join(cwd, f.Name) |
| if err := os.MkdirAll(filepath.Dir(name), 0777); err != nil { |
| t.Fatal(err) |
| } |
| if err := os.WriteFile(name, f.Data, 0666); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| var overlayJSON OverlayJSON |
| if err := json.Unmarshal(a.Comment, &overlayJSON); err != nil { |
| t.Fatal(fmt.Errorf("parsing overlay JSON: %v", err)) |
| } |
| |
| initFromJSON(overlayJSON) |
| } |
| |
| func TestIsDir(t *testing.T) { |
| initOverlay(t, ` |
| { |
| "Replace": { |
| "subdir2/file2.txt": "overlayfiles/subdir2_file2.txt", |
| "subdir4": "overlayfiles/subdir4", |
| "subdir3/file3b.txt": "overlayfiles/subdir3_file3b.txt", |
| "subdir5": "", |
| "subdir6": "" |
| } |
| } |
| -- subdir1/file1.txt -- |
| |
| -- subdir3/file3a.txt -- |
| 33 |
| -- subdir4/file4.txt -- |
| 444 |
| -- overlayfiles/subdir2_file2.txt -- |
| 2 |
| -- overlayfiles/subdir3_file3b.txt -- |
| 66666 |
| -- overlayfiles/subdir4 -- |
| x |
| -- subdir6/file6.txt -- |
| six |
| `) |
| |
| testCases := []struct { |
| path string |
| want, wantErr bool |
| }{ |
| {"", true, true}, |
| {".", true, false}, |
| {cwd, true, false}, |
| {cwd + string(filepath.Separator), true, false}, |
| // subdir1 is only on disk |
| {filepath.Join(cwd, "subdir1"), true, false}, |
| {"subdir1", true, false}, |
| {"subdir1" + string(filepath.Separator), true, false}, |
| {"subdir1/file1.txt", false, false}, |
| {"subdir1/doesntexist.txt", false, true}, |
| {"doesntexist", false, true}, |
| // subdir2 is only in overlay |
| {filepath.Join(cwd, "subdir2"), true, false}, |
| {"subdir2", true, false}, |
| {"subdir2" + string(filepath.Separator), true, false}, |
| {"subdir2/file2.txt", false, false}, |
| {"subdir2/doesntexist.txt", false, true}, |
| // subdir3 has files on disk and in overlay |
| {filepath.Join(cwd, "subdir3"), true, false}, |
| {"subdir3", true, false}, |
| {"subdir3" + string(filepath.Separator), true, false}, |
| {"subdir3/file3a.txt", false, false}, |
| {"subdir3/file3b.txt", false, false}, |
| {"subdir3/doesntexist.txt", false, true}, |
| // subdir4 is overlaid with a file |
| {filepath.Join(cwd, "subdir4"), false, false}, |
| {"subdir4", false, false}, |
| {"subdir4" + string(filepath.Separator), false, false}, |
| {"subdir4/file4.txt", false, false}, |
| {"subdir4/doesntexist.txt", false, false}, |
| // subdir5 doesn't exist, and is overlaid with a "delete" entry |
| {filepath.Join(cwd, "subdir5"), false, false}, |
| {"subdir5", false, false}, |
| {"subdir5" + string(filepath.Separator), false, false}, |
| {"subdir5/file5.txt", false, false}, |
| {"subdir5/doesntexist.txt", false, false}, |
| // subdir6 does exist, and is overlaid with a "delete" entry |
| {filepath.Join(cwd, "subdir6"), false, false}, |
| {"subdir6", false, false}, |
| {"subdir6" + string(filepath.Separator), false, false}, |
| {"subdir6/file6.txt", false, false}, |
| {"subdir6/doesntexist.txt", false, false}, |
| } |
| |
| for _, tc := range testCases { |
| got, err := IsDir(tc.path) |
| if err != nil { |
| if !tc.wantErr { |
| t.Errorf("IsDir(%q): got error with string %q, want no error", tc.path, err.Error()) |
| } |
| continue |
| } |
| if tc.wantErr { |
| t.Errorf("IsDir(%q): got no error, want error", tc.path) |
| } |
| if tc.want != got { |
| t.Errorf("IsDir(%q) = %v, want %v", tc.path, got, tc.want) |
| } |
| } |
| } |
| |
| const readDirOverlay = ` |
| { |
| "Replace": { |
| "subdir2/file2.txt": "overlayfiles/subdir2_file2.txt", |
| "subdir4": "overlayfiles/subdir4", |
| "subdir3/file3b.txt": "overlayfiles/subdir3_file3b.txt", |
| "subdir5": "", |
| "subdir6/asubsubdir/afile.txt": "overlayfiles/subdir6_asubsubdir_afile.txt", |
| "subdir6/asubsubdir/zfile.txt": "overlayfiles/subdir6_asubsubdir_zfile.txt", |
| "subdir6/zsubsubdir/file.txt": "overlayfiles/subdir6_zsubsubdir_file.txt", |
| "subdir7/asubsubdir/file.txt": "overlayfiles/subdir7_asubsubdir_file.txt", |
| "subdir7/zsubsubdir/file.txt": "overlayfiles/subdir7_zsubsubdir_file.txt", |
| "subdir8/doesntexist": "this_file_doesnt_exist_anywhere", |
| "other/pointstodir": "overlayfiles/this_is_a_directory", |
| "parentoverwritten/subdir1": "overlayfiles/parentoverwritten_subdir1", |
| "subdir9/this_file_is_overlaid.txt": "overlayfiles/subdir9_this_file_is_overlaid.txt", |
| "subdir10/only_deleted_file.txt": "", |
| "subdir11/deleted.txt": "", |
| "subdir11": "overlayfiles/subdir11", |
| "textfile.txt/file.go": "overlayfiles/textfile_txt_file.go" |
| } |
| } |
| -- subdir1/file1.txt -- |
| |
| -- subdir3/file3a.txt -- |
| 33 |
| -- subdir4/file4.txt -- |
| 444 |
| -- subdir6/file.txt -- |
| -- subdir6/asubsubdir/file.txt -- |
| -- subdir6/anothersubsubdir/file.txt -- |
| -- subdir9/this_file_is_overlaid.txt -- |
| -- subdir10/only_deleted_file.txt -- |
| this will be deleted in overlay |
| -- subdir11/deleted.txt -- |
| -- parentoverwritten/subdir1/subdir2/subdir3/file.txt -- |
| -- textfile.txt -- |
| this will be overridden by textfile.txt/file.go |
| -- overlayfiles/subdir2_file2.txt -- |
| 2 |
| -- overlayfiles/subdir3_file3b.txt -- |
| 66666 |
| -- overlayfiles/subdir4 -- |
| x |
| -- overlayfiles/subdir6_asubsubdir_afile.txt -- |
| -- overlayfiles/subdir6_asubsubdir_zfile.txt -- |
| -- overlayfiles/subdir6_zsubsubdir_file.txt -- |
| -- overlayfiles/subdir7_asubsubdir_file.txt -- |
| -- overlayfiles/subdir7_zsubsubdir_file.txt -- |
| -- overlayfiles/parentoverwritten_subdir1 -- |
| x |
| -- overlayfiles/subdir9_this_file_is_overlaid.txt -- |
| 99999999 |
| -- overlayfiles/subdir11 -- |
| -- overlayfiles/this_is_a_directory/file.txt -- |
| -- overlayfiles/textfile_txt_file.go -- |
| x |
| ` |
| |
| func TestReadDir(t *testing.T) { |
| initOverlay(t, readDirOverlay) |
| |
| type entry struct { |
| name string |
| size int64 |
| isDir bool |
| } |
| |
| testCases := []struct { |
| dir string |
| want []entry |
| }{ |
| { |
| ".", []entry{ |
| {"other", 0, true}, |
| {"overlayfiles", 0, true}, |
| {"parentoverwritten", 0, true}, |
| {"subdir1", 0, true}, |
| {"subdir10", 0, true}, |
| {"subdir11", 0, false}, |
| {"subdir2", 0, true}, |
| {"subdir3", 0, true}, |
| {"subdir4", 2, false}, |
| // no subdir5. |
| {"subdir6", 0, true}, |
| {"subdir7", 0, true}, |
| {"subdir8", 0, true}, |
| {"subdir9", 0, true}, |
| {"textfile.txt", 0, true}, |
| }, |
| }, |
| { |
| "subdir1", []entry{ |
| {"file1.txt", 1, false}, |
| }, |
| }, |
| { |
| "subdir2", []entry{ |
| {"file2.txt", 2, false}, |
| }, |
| }, |
| { |
| "subdir3", []entry{ |
| {"file3a.txt", 3, false}, |
| {"file3b.txt", 6, false}, |
| }, |
| }, |
| { |
| "subdir6", []entry{ |
| {"anothersubsubdir", 0, true}, |
| {"asubsubdir", 0, true}, |
| {"file.txt", 0, false}, |
| {"zsubsubdir", 0, true}, |
| }, |
| }, |
| { |
| "subdir6/asubsubdir", []entry{ |
| {"afile.txt", 0, false}, |
| {"file.txt", 0, false}, |
| {"zfile.txt", 0, false}, |
| }, |
| }, |
| { |
| "subdir8", []entry{ |
| {"doesntexist", 0, false}, // entry is returned even if destination file doesn't exist |
| }, |
| }, |
| { |
| // check that read dir actually redirects files that already exist |
| // the original this_file_is_overlaid.txt is empty |
| "subdir9", []entry{ |
| {"this_file_is_overlaid.txt", 9, false}, |
| }, |
| }, |
| { |
| "subdir10", []entry{}, |
| }, |
| { |
| "parentoverwritten", []entry{ |
| {"subdir1", 2, false}, |
| }, |
| }, |
| { |
| "textfile.txt", []entry{ |
| {"file.go", 2, false}, |
| }, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| dir, want := tc.dir, tc.want |
| infos, err := ReadDir(dir) |
| if err != nil { |
| t.Errorf("ReadDir(%q): %v", dir, err) |
| continue |
| } |
| // Sorted diff of want and infos. |
| for len(infos) > 0 || len(want) > 0 { |
| switch { |
| case len(want) == 0 || len(infos) > 0 && infos[0].Name() < want[0].name: |
| t.Errorf("ReadDir(%q): unexpected entry: %s IsDir=%v Size=%v", dir, infos[0].Name(), infos[0].IsDir(), infos[0].Size()) |
| infos = infos[1:] |
| case len(infos) == 0 || len(want) > 0 && want[0].name < infos[0].Name(): |
| t.Errorf("ReadDir(%q): missing entry: %s IsDir=%v Size=%v", dir, want[0].name, want[0].isDir, want[0].size) |
| want = want[1:] |
| default: |
| infoSize := infos[0].Size() |
| if want[0].isDir { |
| infoSize = 0 |
| } |
| if infos[0].IsDir() != want[0].isDir || want[0].isDir && infoSize != want[0].size { |
| t.Errorf("ReadDir(%q): %s: IsDir=%v Size=%v, want IsDir=%v Size=%v", dir, want[0].name, infos[0].IsDir(), infoSize, want[0].isDir, want[0].size) |
| } |
| infos = infos[1:] |
| want = want[1:] |
| } |
| } |
| } |
| |
| errCases := []string{ |
| "subdir1/file1.txt", // regular file on disk |
| "subdir2/file2.txt", // regular file in overlay |
| "subdir4", // directory overlaid with regular file |
| "subdir5", // directory deleted in overlay |
| "parentoverwritten/subdir1/subdir2/subdir3", // parentoverwritten/subdir1 overlaid with regular file |
| "parentoverwritten/subdir1/subdir2", // parentoverwritten/subdir1 overlaid with regular file |
| "subdir11", // directory with deleted child, overlaid with regular file |
| "other/pointstodir", |
| } |
| |
| for _, dir := range errCases { |
| _, err := ReadDir(dir) |
| if _, ok := err.(*fs.PathError); !ok { |
| t.Errorf("ReadDir(%q): err = %T (%v), want fs.PathError", dir, err, err) |
| } |
| } |
| } |
| |
| func TestGlob(t *testing.T) { |
| initOverlay(t, readDirOverlay) |
| |
| testCases := []struct { |
| pattern string |
| match []string |
| }{ |
| { |
| "*o*", |
| []string{ |
| "other", |
| "overlayfiles", |
| "parentoverwritten", |
| }, |
| }, |
| { |
| "subdir2/file2.txt", |
| []string{ |
| "subdir2/file2.txt", |
| }, |
| }, |
| { |
| "*/*.txt", |
| []string{ |
| "overlayfiles/subdir2_file2.txt", |
| "overlayfiles/subdir3_file3b.txt", |
| "overlayfiles/subdir6_asubsubdir_afile.txt", |
| "overlayfiles/subdir6_asubsubdir_zfile.txt", |
| "overlayfiles/subdir6_zsubsubdir_file.txt", |
| "overlayfiles/subdir7_asubsubdir_file.txt", |
| "overlayfiles/subdir7_zsubsubdir_file.txt", |
| "overlayfiles/subdir9_this_file_is_overlaid.txt", |
| "subdir1/file1.txt", |
| "subdir2/file2.txt", |
| "subdir3/file3a.txt", |
| "subdir3/file3b.txt", |
| "subdir6/file.txt", |
| "subdir9/this_file_is_overlaid.txt", |
| }, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| pattern := tc.pattern |
| match, err := Glob(pattern) |
| if err != nil { |
| t.Errorf("Glob(%q): %v", pattern, err) |
| continue |
| } |
| want := tc.match |
| for i, name := range want { |
| if name != tc.pattern { |
| want[i] = filepath.FromSlash(name) |
| } |
| } |
| for len(match) > 0 || len(want) > 0 { |
| switch { |
| case len(match) == 0 || len(want) > 0 && want[0] < match[0]: |
| t.Errorf("Glob(%q): missing match: %s", pattern, want[0]) |
| want = want[1:] |
| case len(want) == 0 || len(match) > 0 && match[0] < want[0]: |
| t.Errorf("Glob(%q): extra match: %s", pattern, match[0]) |
| match = match[1:] |
| default: |
| want = want[1:] |
| match = match[1:] |
| } |
| } |
| } |
| } |
| |
| func TestOverlayPath(t *testing.T) { |
| initOverlay(t, ` |
| { |
| "Replace": { |
| "subdir2/file2.txt": "overlayfiles/subdir2_file2.txt", |
| "subdir3/doesntexist": "this_file_doesnt_exist_anywhere", |
| "subdir4/this_file_is_overlaid.txt": "overlayfiles/subdir4_this_file_is_overlaid.txt", |
| "subdir5/deleted.txt": "", |
| "parentoverwritten/subdir1": "" |
| } |
| } |
| -- subdir1/file1.txt -- |
| file 1 |
| -- subdir4/this_file_is_overlaid.txt -- |
| these contents are replaced by the overlay |
| -- parentoverwritten/subdir1/subdir2/subdir3/file.txt -- |
| -- subdir5/deleted.txt -- |
| deleted |
| -- overlayfiles/subdir2_file2.txt -- |
| file 2 |
| -- overlayfiles/subdir4_this_file_is_overlaid.txt -- |
| 99999999 |
| `) |
| |
| testCases := []struct { |
| path string |
| wantPath string |
| wantOK bool |
| }{ |
| {"subdir1/file1.txt", "subdir1/file1.txt", false}, |
| // OverlayPath returns false for directories |
| {"subdir2", "subdir2", false}, |
| {"subdir2/file2.txt", filepath.Join(cwd, "overlayfiles/subdir2_file2.txt"), true}, |
| // OverlayPath doesn't stat a file to see if it exists, so it happily returns |
| // the 'to' path and true even if the 'to' path doesn't exist on disk. |
| {"subdir3/doesntexist", filepath.Join(cwd, "this_file_doesnt_exist_anywhere"), true}, |
| // Like the subdir2/file2.txt case above, but subdir4 exists on disk, but subdir2 does not. |
| {"subdir4/this_file_is_overlaid.txt", filepath.Join(cwd, "overlayfiles/subdir4_this_file_is_overlaid.txt"), true}, |
| {"subdir5", "subdir5", false}, |
| {"subdir5/deleted.txt", "", true}, |
| } |
| |
| for _, tc := range testCases { |
| gotPath, gotOK := OverlayPath(tc.path) |
| if gotPath != tc.wantPath || gotOK != tc.wantOK { |
| t.Errorf("OverlayPath(%q): got %v, %v; want %v, %v", |
| tc.path, gotPath, gotOK, tc.wantPath, tc.wantOK) |
| } |
| } |
| } |
| |
| func TestOpen(t *testing.T) { |
| initOverlay(t, ` |
| { |
| "Replace": { |
| "subdir2/file2.txt": "overlayfiles/subdir2_file2.txt", |
| "subdir3/doesntexist": "this_file_doesnt_exist_anywhere", |
| "subdir4/this_file_is_overlaid.txt": "overlayfiles/subdir4_this_file_is_overlaid.txt", |
| "subdir5/deleted.txt": "", |
| "parentoverwritten/subdir1": "", |
| "childoverlay/subdir1.txt/child.txt": "overlayfiles/child.txt", |
| "subdir11/deleted.txt": "", |
| "subdir11": "overlayfiles/subdir11", |
| "parentdeleted": "", |
| "parentdeleted/file.txt": "overlayfiles/parentdeleted_file.txt" |
| } |
| } |
| -- subdir11/deleted.txt -- |
| -- subdir1/file1.txt -- |
| file 1 |
| -- subdir4/this_file_is_overlaid.txt -- |
| these contents are replaced by the overlay |
| -- parentoverwritten/subdir1/subdir2/subdir3/file.txt -- |
| -- childoverlay/subdir1.txt -- |
| this file doesn't exist because the path |
| childoverlay/subdir1.txt/child.txt is in the overlay |
| -- subdir5/deleted.txt -- |
| deleted |
| -- parentdeleted -- |
| this will be deleted so that parentdeleted/file.txt can exist |
| -- overlayfiles/subdir2_file2.txt -- |
| file 2 |
| -- overlayfiles/subdir4_this_file_is_overlaid.txt -- |
| 99999999 |
| -- overlayfiles/child.txt -- |
| -- overlayfiles/subdir11 -- |
| 11 |
| -- overlayfiles/parentdeleted_file.txt -- |
| this can exist because the parent directory is deleted |
| `) |
| |
| testCases := []struct { |
| path string |
| wantContents string |
| isErr bool |
| }{ |
| {"subdir1/file1.txt", "file 1\n", false}, |
| {"subdir2/file2.txt", "file 2\n", false}, |
| {"subdir3/doesntexist", "", true}, |
| {"subdir4/this_file_is_overlaid.txt", "99999999\n", false}, |
| {"subdir5/deleted.txt", "", true}, |
| {"parentoverwritten/subdir1/subdir2/subdir3/file.txt", "", true}, |
| {"childoverlay/subdir1.txt", "", true}, |
| {"subdir11", "11\n", false}, |
| {"parentdeleted/file.txt", "this can exist because the parent directory is deleted\n", false}, |
| } |
| |
| for _, tc := range testCases { |
| f, err := Open(tc.path) |
| if tc.isErr { |
| if err == nil { |
| f.Close() |
| t.Errorf("Open(%q): got no error, but want error", tc.path) |
| } |
| continue |
| } |
| if err != nil { |
| t.Errorf("Open(%q): got error %v, want nil", tc.path, err) |
| continue |
| } |
| contents, err := io.ReadAll(f) |
| if err != nil { |
| t.Errorf("unexpected error reading contents of file: %v", err) |
| } |
| if string(contents) != tc.wantContents { |
| t.Errorf("contents of file opened with Open(%q): got %q, want %q", |
| tc.path, contents, tc.wantContents) |
| } |
| f.Close() |
| } |
| } |
| |
| func TestIsDirWithGoFiles(t *testing.T) { |
| initOverlay(t, ` |
| { |
| "Replace": { |
| "goinoverlay/file.go": "dummy", |
| "directory/removed/by/file": "dummy", |
| "directory_with_go_dir/dir.go/file.txt": "dummy", |
| "otherdirectory/deleted.go": "", |
| "nonexistentdirectory/deleted.go": "", |
| "textfile.txt/file.go": "dummy" |
| } |
| } |
| -- dummy -- |
| a destination file for the overlay entries to point to |
| contents don't matter for this test |
| -- nogo/file.txt -- |
| -- goondisk/file.go -- |
| -- goinoverlay/file.txt -- |
| -- directory/removed/by/file/in/overlay/file.go -- |
| -- otherdirectory/deleted.go -- |
| -- textfile.txt -- |
| `) |
| |
| testCases := []struct { |
| dir string |
| want bool |
| wantErr bool |
| }{ |
| {"nogo", false, false}, |
| {"goondisk", true, false}, |
| {"goinoverlay", true, false}, |
| {"directory/removed/by/file/in/overlay", false, false}, |
| {"directory_with_go_dir", false, false}, |
| {"otherdirectory", false, false}, |
| {"nonexistentdirectory", false, false}, |
| {"textfile.txt", true, false}, |
| } |
| |
| for _, tc := range testCases { |
| got, gotErr := IsDirWithGoFiles(tc.dir) |
| if tc.wantErr { |
| if gotErr == nil { |
| t.Errorf("IsDirWithGoFiles(%q): got %v, %v; want non-nil error", tc.dir, got, gotErr) |
| } |
| continue |
| } |
| if gotErr != nil { |
| t.Errorf("IsDirWithGoFiles(%q): got %v, %v; want nil error", tc.dir, got, gotErr) |
| } |
| if got != tc.want { |
| t.Errorf("IsDirWithGoFiles(%q) = %v; want %v", tc.dir, got, tc.want) |
| } |
| } |
| } |
| |
| func TestWalk(t *testing.T) { |
| // The root of the walk must be a name with an actual basename, not just ".". |
| // Walk uses Lstat to obtain the name of the root, and Lstat on platforms |
| // other than Plan 9 reports the name "." instead of the actual base name of |
| // the directory. (See https://golang.org/issue/42115.) |
| |
| type file struct { |
| path string |
| name string |
| size int64 |
| mode fs.FileMode |
| isDir bool |
| } |
| testCases := []struct { |
| name string |
| overlay string |
| root string |
| wantFiles []file |
| }{ |
| {"no overlay", ` |
| {} |
| -- dir/file.txt -- |
| `, |
| "dir", |
| []file{ |
| {"dir", "dir", 0, fs.ModeDir | 0700, true}, |
| {"dir/file.txt", "file.txt", 0, 0600, false}, |
| }, |
| }, |
| {"overlay with different file", ` |
| { |
| "Replace": { |
| "dir/file.txt": "dir/other.txt" |
| } |
| } |
| -- dir/file.txt -- |
| -- dir/other.txt -- |
| contents of other file |
| `, |
| "dir", |
| []file{ |
| {"dir", "dir", 0, fs.ModeDir | 0500, true}, |
| {"dir/file.txt", "file.txt", 23, 0600, false}, |
| {"dir/other.txt", "other.txt", 23, 0600, false}, |
| }, |
| }, |
| {"overlay with new file", ` |
| { |
| "Replace": { |
| "dir/file.txt": "dir/other.txt" |
| } |
| } |
| -- dir/other.txt -- |
| contents of other file |
| `, |
| "dir", |
| []file{ |
| {"dir", "dir", 0, fs.ModeDir | 0500, true}, |
| {"dir/file.txt", "file.txt", 23, 0600, false}, |
| {"dir/other.txt", "other.txt", 23, 0600, false}, |
| }, |
| }, |
| {"overlay with new directory", ` |
| { |
| "Replace": { |
| "dir/subdir/file.txt": "dir/other.txt" |
| } |
| } |
| -- dir/other.txt -- |
| contents of other file |
| `, |
| "dir", |
| []file{ |
| {"dir", "dir", 0, fs.ModeDir | 0500, true}, |
| {"dir/other.txt", "other.txt", 23, 0600, false}, |
| {"dir/subdir", "subdir", 0, fs.ModeDir | 0500, true}, |
| {"dir/subdir/file.txt", "file.txt", 23, 0600, false}, |
| }, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| initOverlay(t, tc.overlay) |
| |
| var got []file |
| Walk(tc.root, func(path string, info fs.FileInfo, err error) error { |
| got = append(got, file{path, info.Name(), info.Size(), info.Mode(), info.IsDir()}) |
| return nil |
| }) |
| |
| if len(got) != len(tc.wantFiles) { |
| t.Errorf("Walk: saw %#v in walk; want %#v", got, tc.wantFiles) |
| } |
| for i := 0; i < len(got) && i < len(tc.wantFiles); i++ { |
| wantPath := filepath.FromSlash(tc.wantFiles[i].path) |
| if got[i].path != wantPath { |
| t.Errorf("path of file #%v in walk, got %q, want %q", i, got[i].path, wantPath) |
| } |
| if got[i].name != tc.wantFiles[i].name { |
| t.Errorf("name of file #%v in walk, got %q, want %q", i, got[i].name, tc.wantFiles[i].name) |
| } |
| if got[i].mode&(fs.ModeDir|0700) != tc.wantFiles[i].mode { |
| t.Errorf("mode&(fs.ModeDir|0700) for mode of file #%v in walk, got %v, want %v", i, got[i].mode&(fs.ModeDir|0700), tc.wantFiles[i].mode) |
| } |
| if got[i].isDir != tc.wantFiles[i].isDir { |
| t.Errorf("isDir for file #%v in walk, got %v, want %v", i, got[i].isDir, tc.wantFiles[i].isDir) |
| } |
| if tc.wantFiles[i].isDir { |
| continue // don't check size for directories |
| } |
| if got[i].size != tc.wantFiles[i].size { |
| t.Errorf("size of file #%v in walk, got %v, want %v", i, got[i].size, tc.wantFiles[i].size) |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestWalkSkipDir(t *testing.T) { |
| initOverlay(t, ` |
| { |
| "Replace": { |
| "dir/skip/file.go": "dummy.txt", |
| "dir/dontskip/file.go": "dummy.txt", |
| "dir/dontskip/skip/file.go": "dummy.txt" |
| } |
| } |
| -- dummy.txt -- |
| `) |
| |
| var seen []string |
| Walk("dir", func(path string, info fs.FileInfo, err error) error { |
| seen = append(seen, filepath.ToSlash(path)) |
| if info.Name() == "skip" { |
| return filepath.SkipDir |
| } |
| return nil |
| }) |
| |
| wantSeen := []string{"dir", "dir/dontskip", "dir/dontskip/file.go", "dir/dontskip/skip", "dir/skip"} |
| |
| if len(seen) != len(wantSeen) { |
| t.Errorf("paths seen in walk: got %v entries; want %v entries", len(seen), len(wantSeen)) |
| } |
| |
| for i := 0; i < len(seen) && i < len(wantSeen); i++ { |
| if seen[i] != wantSeen[i] { |
| t.Errorf("path #%v seen walking tree: want %q, got %q", i, seen[i], wantSeen[i]) |
| } |
| } |
| } |
| |
| func TestWalkError(t *testing.T) { |
| initOverlay(t, "{}") |
| |
| alreadyCalled := false |
| err := Walk("foo", func(path string, info fs.FileInfo, err error) error { |
| if alreadyCalled { |
| t.Fatal("expected walk function to be called exactly once, but it was called more than once") |
| } |
| alreadyCalled = true |
| return errors.New("returned from function") |
| }) |
| if !alreadyCalled { |
| t.Fatal("expected walk function to be called exactly once, but it was never called") |
| |
| } |
| if err == nil { |
| t.Fatalf("Walk: got no error, want error") |
| } |
| if err.Error() != "returned from function" { |
| t.Fatalf("Walk: got error %v, want \"returned from function\" error", err) |
| } |
| } |
| |
| func TestWalkSymlink(t *testing.T) { |
| testenv.MustHaveSymlink(t) |
| |
| initOverlay(t, `{ |
| "Replace": {"overlay_symlink": "symlink"} |
| } |
| -- dir/file --`) |
| |
| // Create symlink |
| if err := os.Symlink("dir", "symlink"); err != nil { |
| t.Error(err) |
| } |
| |
| testCases := []struct { |
| name string |
| dir string |
| wantFiles []string |
| }{ |
| {"control", "dir", []string{"dir", "dir" + string(filepath.Separator) + "file"}}, |
| // ensure Walk doesn't walk into the directory pointed to by the symlink |
| // (because it's supposed to use Lstat instead of Stat). |
| {"symlink_to_dir", "symlink", []string{"symlink"}}, |
| {"overlay_to_symlink_to_dir", "overlay_symlink", []string{"overlay_symlink"}}, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| var got []string |
| |
| err := Walk(tc.dir, func(path string, info fs.FileInfo, err error) error { |
| got = append(got, path) |
| if err != nil { |
| t.Errorf("walkfn: got non nil err argument: %v, want nil err argument", err) |
| } |
| return nil |
| }) |
| if err != nil { |
| t.Errorf("Walk: got error %q, want nil", err) |
| } |
| |
| if !reflect.DeepEqual(got, tc.wantFiles) { |
| t.Errorf("files examined by walk: got %v, want %v", got, tc.wantFiles) |
| } |
| }) |
| } |
| |
| } |
| |
| func TestLstat(t *testing.T) { |
| type file struct { |
| name string |
| size int64 |
| mode fs.FileMode // mode & (fs.ModeDir|0x700): only check 'user' permissions |
| isDir bool |
| } |
| |
| testCases := []struct { |
| name string |
| overlay string |
| path string |
| |
| want file |
| wantErr bool |
| }{ |
| { |
| "regular_file", |
| `{} |
| -- file.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "new_file_in_overlay", |
| `{"Replace": {"file.txt": "dummy.txt"}} |
| -- dummy.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "file_replaced_in_overlay", |
| `{"Replace": {"file.txt": "dummy.txt"}} |
| -- file.txt -- |
| -- dummy.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "file_cant_exist", |
| `{"Replace": {"deleted": "dummy.txt"}} |
| -- deleted/file.txt -- |
| -- dummy.txt -- |
| `, |
| "deleted/file.txt", |
| file{}, |
| true, |
| }, |
| { |
| "deleted", |
| `{"Replace": {"deleted": ""}} |
| -- deleted -- |
| `, |
| "deleted", |
| file{}, |
| true, |
| }, |
| { |
| "dir_on_disk", |
| `{} |
| -- dir/foo.txt -- |
| `, |
| "dir", |
| file{"dir", 0, 0700 | fs.ModeDir, true}, |
| false, |
| }, |
| { |
| "dir_in_overlay", |
| `{"Replace": {"dir/file.txt": "dummy.txt"}} |
| -- dummy.txt -- |
| `, |
| "dir", |
| file{"dir", 0, 0500 | fs.ModeDir, true}, |
| false, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| initOverlay(t, tc.overlay) |
| got, err := Lstat(tc.path) |
| if tc.wantErr { |
| if err == nil { |
| t.Errorf("lstat(%q): got no error, want error", tc.path) |
| } |
| return |
| } |
| if err != nil { |
| t.Fatalf("lstat(%q): got error %v, want no error", tc.path, err) |
| } |
| if got.Name() != tc.want.name { |
| t.Errorf("lstat(%q).Name(): got %q, want %q", tc.path, got.Name(), tc.want.name) |
| } |
| if got.Mode()&(fs.ModeDir|0700) != tc.want.mode { |
| t.Errorf("lstat(%q).Mode()&(fs.ModeDir|0700): got %v, want %v", tc.path, got.Mode()&(fs.ModeDir|0700), tc.want.mode) |
| } |
| if got.IsDir() != tc.want.isDir { |
| t.Errorf("lstat(%q).IsDir(): got %v, want %v", tc.path, got.IsDir(), tc.want.isDir) |
| } |
| if tc.want.isDir { |
| return // don't check size for directories |
| } |
| if got.Size() != tc.want.size { |
| t.Errorf("lstat(%q).Size(): got %v, want %v", tc.path, got.Size(), tc.want.size) |
| } |
| }) |
| } |
| } |
| |
| func TestStat(t *testing.T) { |
| testenv.MustHaveSymlink(t) |
| |
| type file struct { |
| name string |
| size int64 |
| mode os.FileMode // mode & (os.ModeDir|0x700): only check 'user' permissions |
| isDir bool |
| } |
| |
| testCases := []struct { |
| name string |
| overlay string |
| path string |
| |
| want file |
| wantErr bool |
| }{ |
| { |
| "regular_file", |
| `{} |
| -- file.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "new_file_in_overlay", |
| `{"Replace": {"file.txt": "dummy.txt"}} |
| -- dummy.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "file_replaced_in_overlay", |
| `{"Replace": {"file.txt": "dummy.txt"}} |
| -- file.txt -- |
| -- dummy.txt -- |
| contents`, |
| "file.txt", |
| file{"file.txt", 9, 0600, false}, |
| false, |
| }, |
| { |
| "file_cant_exist", |
| `{"Replace": {"deleted": "dummy.txt"}} |
| -- deleted/file.txt -- |
| -- dummy.txt -- |
| `, |
| "deleted/file.txt", |
| file{}, |
| true, |
| }, |
| { |
| "deleted", |
| `{"Replace": {"deleted": ""}} |
| -- deleted -- |
| `, |
| "deleted", |
| file{}, |
| true, |
| }, |
| { |
| "dir_on_disk", |
| `{} |
| -- dir/foo.txt -- |
| `, |
| "dir", |
| file{"dir", 0, 0700 | os.ModeDir, true}, |
| false, |
| }, |
| { |
| "dir_in_overlay", |
| `{"Replace": {"dir/file.txt": "dummy.txt"}} |
| -- dummy.txt -- |
| `, |
| "dir", |
| file{"dir", 0, 0500 | os.ModeDir, true}, |
| false, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| initOverlay(t, tc.overlay) |
| got, err := Stat(tc.path) |
| if tc.wantErr { |
| if err == nil { |
| t.Errorf("Stat(%q): got no error, want error", tc.path) |
| } |
| return |
| } |
| if err != nil { |
| t.Fatalf("Stat(%q): got error %v, want no error", tc.path, err) |
| } |
| if got.Name() != tc.want.name { |
| t.Errorf("Stat(%q).Name(): got %q, want %q", tc.path, got.Name(), tc.want.name) |
| } |
| if got.Mode()&(os.ModeDir|0700) != tc.want.mode { |
| t.Errorf("Stat(%q).Mode()&(os.ModeDir|0700): got %v, want %v", tc.path, got.Mode()&(os.ModeDir|0700), tc.want.mode) |
| } |
| if got.IsDir() != tc.want.isDir { |
| t.Errorf("Stat(%q).IsDir(): got %v, want %v", tc.path, got.IsDir(), tc.want.isDir) |
| } |
| if tc.want.isDir { |
| return // don't check size for directories |
| } |
| if got.Size() != tc.want.size { |
| t.Errorf("Stat(%q).Size(): got %v, want %v", tc.path, got.Size(), tc.want.size) |
| } |
| }) |
| } |
| } |
| |
| func TestStatSymlink(t *testing.T) { |
| testenv.MustHaveSymlink(t) |
| |
| initOverlay(t, `{ |
| "Replace": {"file.go": "symlink"} |
| } |
| -- to.go -- |
| 0123456789 |
| `) |
| |
| // Create symlink |
| if err := os.Symlink("to.go", "symlink"); err != nil { |
| t.Error(err) |
| } |
| |
| f := "file.go" |
| fi, err := Stat(f) |
| if err != nil { |
| t.Errorf("Stat(%q): got error %q, want nil error", f, err) |
| } |
| |
| if !fi.Mode().IsRegular() { |
| t.Errorf("Stat(%q).Mode(): got %v, want regular mode", f, fi.Mode()) |
| } |
| |
| if fi.Size() != 11 { |
| t.Errorf("Stat(%q).Size(): got %v, want 11", f, fi.Size()) |
| } |
| } |
