github.com/jomix/afero@v1.1.1/basepath_test.go (about) 1 package afero 2 3 import ( 4 "os" 5 "path/filepath" 6 "runtime" 7 "testing" 8 ) 9 10 func TestBasePath(t *testing.T) { 11 baseFs := &MemMapFs{} 12 baseFs.MkdirAll("/base/path/tmp", 0777) 13 bp := NewBasePathFs(baseFs, "/base/path") 14 15 if _, err := bp.Create("/tmp/foo"); err != nil { 16 t.Errorf("Failed to set real path") 17 } 18 19 if fh, err := bp.Create("../tmp/bar"); err == nil { 20 t.Errorf("succeeded in creating %s ...", fh.Name()) 21 } 22 } 23 24 func TestBasePathRoot(t *testing.T) { 25 baseFs := &MemMapFs{} 26 baseFs.MkdirAll("/base/path/foo/baz", 0777) 27 baseFs.MkdirAll("/base/path/boo/", 0777) 28 bp := NewBasePathFs(baseFs, "/base/path") 29 30 rd, err := ReadDir(bp, string(os.PathSeparator)) 31 32 if len(rd) != 2 { 33 t.Errorf("base path doesn't respect root") 34 } 35 36 if err != nil { 37 t.Error(err) 38 } 39 } 40 41 func TestRealPath(t *testing.T) { 42 fs := NewOsFs() 43 baseDir, err := TempDir(fs, "", "base") 44 if err != nil { 45 t.Fatal("error creating tempDir", err) 46 } 47 defer fs.RemoveAll(baseDir) 48 anotherDir, err := TempDir(fs, "", "another") 49 if err != nil { 50 t.Fatal("error creating tempDir", err) 51 } 52 defer fs.RemoveAll(anotherDir) 53 54 bp := NewBasePathFs(fs, baseDir).(*BasePathFs) 55 56 subDir := filepath.Join(baseDir, "s1") 57 58 realPath, err := bp.RealPath("/s1") 59 60 if err != nil { 61 t.Errorf("Got error %s", err) 62 } 63 64 if realPath != subDir { 65 t.Errorf("Expected \n%s got \n%s", subDir, realPath) 66 } 67 68 if runtime.GOOS == "windows" { 69 _, err = bp.RealPath(anotherDir) 70 71 if err != os.ErrNotExist { 72 t.Errorf("Expected os.ErrNotExist") 73 } 74 75 } else { 76 // on *nix we have no way of just looking at the path and tell that anotherDir 77 // is not inside the base file system. 78 // The user will receive an os.ErrNotExist later. 79 surrealPath, err := bp.RealPath(anotherDir) 80 81 if err != nil { 82 t.Errorf("Got error %s", err) 83 } 84 85 excpected := filepath.Join(baseDir, anotherDir) 86 87 if surrealPath != excpected { 88 t.Errorf("Expected \n%s got \n%s", excpected, surrealPath) 89 } 90 } 91 92 } 93 94 func TestNestedBasePaths(t *testing.T) { 95 type dirSpec struct { 96 Dir1, Dir2, Dir3 string 97 } 98 dirSpecs := []dirSpec{ 99 dirSpec{Dir1: "/", Dir2: "/", Dir3: "/"}, 100 dirSpec{Dir1: "/", Dir2: "/path2", Dir3: "/"}, 101 dirSpec{Dir1: "/path1/dir", Dir2: "/path2/dir/", Dir3: "/path3/dir"}, 102 dirSpec{Dir1: "C:/path1", Dir2: "path2/dir", Dir3: "/path3/dir/"}, 103 } 104 105 for _, ds := range dirSpecs { 106 memFs := NewMemMapFs() 107 level1Fs := NewBasePathFs(memFs, ds.Dir1) 108 level2Fs := NewBasePathFs(level1Fs, ds.Dir2) 109 level3Fs := NewBasePathFs(level2Fs, ds.Dir3) 110 111 type spec struct { 112 BaseFs Fs 113 FileName string 114 } 115 specs := []spec{ 116 spec{BaseFs: level3Fs, FileName: "f.txt"}, 117 spec{BaseFs: level2Fs, FileName: "f.txt"}, 118 spec{BaseFs: level1Fs, FileName: "f.txt"}, 119 } 120 121 for _, s := range specs { 122 if err := s.BaseFs.MkdirAll(s.FileName, 0755); err != nil { 123 t.Errorf("Got error %s", err.Error()) 124 } 125 if _, err := s.BaseFs.Stat(s.FileName); err != nil { 126 t.Errorf("Got error %s", err.Error()) 127 } 128 129 if s.BaseFs == level3Fs { 130 pathToExist := filepath.Join(ds.Dir3, s.FileName) 131 if _, err := level2Fs.Stat(pathToExist); err != nil { 132 t.Errorf("Got error %s (path %s)", err.Error(), pathToExist) 133 } 134 } else if s.BaseFs == level2Fs { 135 pathToExist := filepath.Join(ds.Dir2, ds.Dir3, s.FileName) 136 if _, err := level1Fs.Stat(pathToExist); err != nil { 137 t.Errorf("Got error %s (path %s)", err.Error(), pathToExist) 138 } 139 } 140 } 141 } 142 } 143 144 func TestBasePathOpenFile(t *testing.T) { 145 baseFs := &MemMapFs{} 146 baseFs.MkdirAll("/base/path/tmp", 0777) 147 bp := NewBasePathFs(baseFs, "/base/path") 148 f, err := bp.OpenFile("/tmp/file.txt", os.O_CREATE, 0600) 149 if err != nil { 150 t.Fatalf("failed to open file: %v", err) 151 } 152 if filepath.Dir(f.Name()) != filepath.Clean("/tmp") { 153 t.Fatalf("realpath leaked: %s", f.Name()) 154 } 155 } 156 157 func TestBasePathCreate(t *testing.T) { 158 baseFs := &MemMapFs{} 159 baseFs.MkdirAll("/base/path/tmp", 0777) 160 bp := NewBasePathFs(baseFs, "/base/path") 161 f, err := bp.Create("/tmp/file.txt") 162 if err != nil { 163 t.Fatalf("failed to create file: %v", err) 164 } 165 if filepath.Dir(f.Name()) != filepath.Clean("/tmp") { 166 t.Fatalf("realpath leaked: %s", f.Name()) 167 } 168 } 169 170 func TestBasePathTempFile(t *testing.T) { 171 baseFs := &MemMapFs{} 172 baseFs.MkdirAll("/base/path/tmp", 0777) 173 bp := NewBasePathFs(baseFs, "/base/path") 174 175 tDir, err := TempDir(bp, "/tmp", "") 176 if err != nil { 177 t.Fatalf("Failed to TempDir: %v", err) 178 } 179 if filepath.Dir(tDir) != filepath.Clean("/tmp") { 180 t.Fatalf("Tempdir realpath leaked: %s", tDir) 181 } 182 tempFile, err := TempFile(bp, tDir, "") 183 if err != nil { 184 t.Fatalf("Failed to TempFile: %v", err) 185 } 186 defer tempFile.Close() 187 if expected, actual := tDir, filepath.Dir(tempFile.Name()); expected != actual { 188 t.Fatalf("TempFile realpath leaked: expected %s, got %s", expected, actual) 189 } 190 }