basepath_test.go - afero - [fork] go afero port for 9front
(HTM) git clone https://git.drkhsh.at/afero.git
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
basepath_test.go (4749B)
---
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", 0o777)
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", 0o777)
27 baseFs.MkdirAll("/base/path/boo/", 0o777)
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 if err != nil {
60 t.Errorf("Got error %s", err)
61 }
62
63 if realPath != subDir {
64 t.Errorf("Expected \n%s got \n%s", subDir, realPath)
65 }
66
67 if runtime.GOOS == "windows" {
68 _, err = bp.RealPath(anotherDir)
69
70 if err != os.ErrNotExist {
71 t.Errorf("Expected os.ErrNotExist")
72 }
73
74 } else {
75 // on *nix we have no way of just looking at the path and tell that anotherDir
76 // is not inside the base file system.
77 // The user will receive an os.ErrNotExist later.
78 surrealPath, err := bp.RealPath(anotherDir)
79 if err != nil {
80 t.Errorf("Got error %s", err)
81 }
82
83 excpected := filepath.Join(baseDir, anotherDir)
84
85 if surrealPath != excpected {
86 t.Errorf("Expected \n%s got \n%s", excpected, surrealPath)
87 }
88 }
89 }
90
91 func TestNestedBasePaths(t *testing.T) {
92 type dirSpec struct {
93 Dir1, Dir2, Dir3 string
94 }
95 dirSpecs := []dirSpec{
96 {Dir1: "/", Dir2: "/", Dir3: "/"},
97 {Dir1: "/", Dir2: "/path2", Dir3: "/"},
98 {Dir1: "/path1/dir", Dir2: "/path2/dir/", Dir3: "/path3/dir"},
99 {Dir1: "C:/path1", Dir2: "path2/dir", Dir3: "/path3/dir/"},
100 }
101
102 for _, ds := range dirSpecs {
103 memFs := NewMemMapFs()
104 level1Fs := NewBasePathFs(memFs, ds.Dir1)
105 level2Fs := NewBasePathFs(level1Fs, ds.Dir2)
106 level3Fs := NewBasePathFs(level2Fs, ds.Dir3)
107
108 type spec struct {
109 BaseFs Fs
110 FileName string
111 }
112 specs := []spec{
113 {BaseFs: level3Fs, FileName: "f.txt"},
114 {BaseFs: level2Fs, FileName: "f.txt"},
115 {BaseFs: level1Fs, FileName: "f.txt"},
116 }
117
118 for _, s := range specs {
119 if err := s.BaseFs.MkdirAll(s.FileName, 0o755); err != nil {
120 t.Errorf("Got error %s", err.Error())
121 }
122 if _, err := s.BaseFs.Stat(s.FileName); err != nil {
123 t.Errorf("Got error %s", err.Error())
124 }
125
126 if s.BaseFs == level3Fs {
127 pathToExist := filepath.Join(ds.Dir3, s.FileName)
128 if _, err := level2Fs.Stat(pathToExist); err != nil {
129 t.Errorf("Got error %s (path %s)", err.Error(), pathToExist)
130 }
131 } else if s.BaseFs == level2Fs {
132 pathToExist := filepath.Join(ds.Dir2, ds.Dir3, s.FileName)
133 if _, err := level1Fs.Stat(pathToExist); err != nil {
134 t.Errorf("Got error %s (path %s)", err.Error(), pathToExist)
135 }
136 }
137 }
138 }
139 }
140
141 func TestBasePathOpenFile(t *testing.T) {
142 baseFs := &MemMapFs{}
143 baseFs.MkdirAll("/base/path/tmp", 0o777)
144 bp := NewBasePathFs(baseFs, "/base/path")
145 f, err := bp.OpenFile("/tmp/file.txt", os.O_CREATE, 0o600)
146 if err != nil {
147 t.Fatalf("failed to open file: %v", err)
148 }
149 if filepath.Dir(f.Name()) != filepath.Clean("/tmp") {
150 t.Fatalf("realpath leaked: %s", f.Name())
151 }
152 }
153
154 func TestBasePathCreate(t *testing.T) {
155 baseFs := &MemMapFs{}
156 baseFs.MkdirAll("/base/path/tmp", 0o777)
157 bp := NewBasePathFs(baseFs, "/base/path")
158 f, err := bp.Create("/tmp/file.txt")
159 if err != nil {
160 t.Fatalf("failed to create file: %v", err)
161 }
162 if filepath.Dir(f.Name()) != filepath.Clean("/tmp") {
163 t.Fatalf("realpath leaked: %s", f.Name())
164 }
165 }
166
167 func TestBasePathTempFile(t *testing.T) {
168 baseFs := &MemMapFs{}
169 baseFs.MkdirAll("/base/path/tmp", 0o777)
170 bp := NewBasePathFs(baseFs, "/base/path")
171
172 tDir, err := TempDir(bp, "/tmp", "")
173 if err != nil {
174 t.Fatalf("Failed to TempDir: %v", err)
175 }
176 if filepath.Dir(tDir) != filepath.Clean("/tmp") {
177 t.Fatalf("Tempdir realpath leaked: %s", tDir)
178 }
179 tempFile, err := TempFile(bp, tDir, "")
180 if err != nil {
181 t.Fatalf("Failed to TempFile: %v", err)
182 }
183 defer tempFile.Close()
184 if expected, actual := tDir, filepath.Dir(tempFile.Name()); expected != actual {
185 t.Fatalf("TempFile realpath leaked: expected %s, got %s", expected, actual)
186 }
187 }