1
2
3
4 package filesys
5
6 import (
7 "os"
8 "path/filepath"
9 "reflect"
10 "sort"
11 "testing"
12
13 "github.com/stretchr/testify/require"
14 )
15
16 const dirMsg = "expected '%s' to be a dir"
17
18 func makeTestDir(t *testing.T) (FileSystem, string) {
19 t.Helper()
20 req := require.New(t)
21
22 fSys := MakeFsOnDisk()
23 td := t.TempDir()
24
25 testDir, err := filepath.EvalSymlinks(td)
26 req.NoError(err)
27 req.Truef(fSys.Exists(testDir), existMsg, testDir)
28 req.Truef(fSys.IsDir(testDir), dirMsg, testDir)
29
30 return fSys, testDir
31 }
32
33 func cleanWd(t *testing.T) string {
34 t.Helper()
35
36 wd, err := os.Getwd()
37 require.NoError(t, err)
38
39 cleanedWd, err := filepath.EvalSymlinks(wd)
40 require.NoError(t, err)
41
42 return cleanedWd
43 }
44
45 func TestCleanedAbs_1(t *testing.T) {
46 req := require.New(t)
47 fSys, _ := makeTestDir(t)
48
49 d, f, err := fSys.CleanedAbs("")
50 req.NoError(err)
51
52 wd := cleanWd(t)
53 req.Equal(wd, d.String())
54 req.Empty(f)
55 }
56
57 func TestCleanedAbs_2(t *testing.T) {
58 req := require.New(t)
59 fSys, _ := makeTestDir(t)
60
61 root, err := getOSRoot()
62 req.NoError(err)
63 d, f, err := fSys.CleanedAbs(root)
64 req.NoError(err)
65 req.Equal(root, d.String())
66 req.Empty(f)
67 }
68
69 func TestCleanedAbs_3(t *testing.T) {
70 req := require.New(t)
71 fSys, testDir := makeTestDir(t)
72
73 err := fSys.WriteFile(
74 filepath.Join(testDir, "foo"), []byte(`foo`))
75 req.NoError(err)
76
77 d, f, err := fSys.CleanedAbs(filepath.Join(testDir, "foo"))
78 req.NoError(err)
79 req.Equal(testDir, d.String())
80 req.Equal("foo", f)
81 }
82
83 func TestCleanedAbs_4(t *testing.T) {
84 req := require.New(t)
85 fSys, testDir := makeTestDir(t)
86
87 err := fSys.MkdirAll(filepath.Join(testDir, "d1", "d2"))
88 req.NoError(err)
89
90 err = fSys.WriteFile(
91 filepath.Join(testDir, "d1", "d2", "bar"),
92 []byte(`bar`))
93 req.NoError(err)
94
95 d, f, err := fSys.CleanedAbs(
96 filepath.Join(testDir, "d1", "d2"))
97 req.NoError(err)
98 req.Equal(filepath.Join(testDir, "d1", "d2"), d.String())
99 req.Empty(f)
100
101 d, f, err = fSys.CleanedAbs(
102 filepath.Join(testDir, "d1", "d2", "bar"))
103 req.NoError(err)
104 req.Equal(filepath.Join(testDir, "d1", "d2"), d.String())
105 req.Equal("bar", f)
106 }
107
108 func TestConfirmDirDisk(t *testing.T) {
109 req := require.New(t)
110 fSys, testDir := makeTestDir(t)
111 wd := cleanWd(t)
112
113 relDir := "actual_foo_431432"
114 err := fSys.Mkdir(relDir)
115 t.Cleanup(func() {
116 err := fSys.RemoveAll(relDir)
117 req.NoError(err)
118 })
119 req.NoError(err)
120 req.Truef(fSys.Exists(relDir), existMsg, relDir)
121
122 linkDir := filepath.Join(testDir, "pointer")
123 err = os.Symlink(filepath.Join(wd, relDir), linkDir)
124 req.NoError(err)
125
126 root, err := getOSRoot()
127 req.NoError(err)
128 tests := map[string]*struct {
129 path string
130 expected string
131 }{
132 "root": {
133 root,
134 root,
135 },
136 "non-selfdir relative path": {
137 relDir,
138 filepath.Join(wd, relDir),
139 },
140 "symlink": {
141 linkDir,
142 filepath.Join(wd, relDir),
143 },
144 }
145
146 for name, test := range tests {
147 test := test
148 t.Run(name, func(t *testing.T) {
149 actualPath, err := ConfirmDir(fSys, test.path)
150 require.NoError(t, err)
151 require.Equal(t, test.expected, actualPath.String())
152 })
153 }
154 }
155
156 func TestReadFilesRealFS(t *testing.T) {
157 req := require.New(t)
158
159 fSys, testDir := makeTestDir(t)
160
161 dir := filepath.Join(testDir, "dir")
162 nestedDir := filepath.Join(dir, "nestedDir")
163 hiddenDir := filepath.Join(testDir, ".hiddenDir")
164 dirs := []string{
165 testDir,
166 dir,
167 nestedDir,
168 hiddenDir,
169 }
170
171 files := []string{
172 "bar",
173 "foo",
174 "file-1.xtn",
175 ".file-2.xtn",
176 ".some-file-3.xtn",
177 ".some-file-4.xtn",
178 }
179
180 err := fSys.MkdirAll(nestedDir)
181 req.NoError(err)
182
183 err = fSys.MkdirAll(hiddenDir)
184 req.NoError(err)
185
186
187 for _, d := range dirs {
188 req.Truef(fSys.IsDir(d), dirMsg, d)
189 for _, f := range files {
190 fPath := filepath.Join(d, f)
191 err = fSys.WriteFile(fPath, []byte(f))
192 req.NoError(err)
193 req.Truef(fSys.Exists(fPath), existMsg, fPath)
194 }
195 }
196
197 tests := map[string]struct {
198 globPattern string
199 expectedFiles []string
200 expectedDirs map[string][]string
201 }{
202 "AllVisibleFiles": {
203 globPattern: "*",
204 expectedFiles: []string{
205 "bar",
206 "foo",
207 "file-1.xtn",
208 },
209 expectedDirs: map[string][]string{
210 testDir: {dir},
211 dir: {nestedDir},
212 },
213 },
214 "AllHiddenFiles": {
215 globPattern: ".*",
216 expectedFiles: []string{
217 ".file-2.xtn",
218 ".some-file-3.xtn",
219 ".some-file-4.xtn",
220 },
221 expectedDirs: map[string][]string{
222 testDir: {hiddenDir},
223 },
224 },
225 "foo_File": {
226 globPattern: "foo",
227 expectedFiles: []string{
228 "foo",
229 },
230 },
231 "dotsome-file_PrefixedFiles": {
232 globPattern: ".some-file*",
233 expectedFiles: []string{
234 ".some-file-3.xtn",
235 ".some-file-4.xtn",
236 },
237 },
238 }
239
240 for n, c := range tests {
241 t.Run(n, func(t *testing.T) {
242 for _, d := range dirs {
243 var expectedPaths []string
244 for _, f := range c.expectedFiles {
245 expectedPaths = append(expectedPaths, filepath.Join(d, f))
246 }
247 if c.expectedDirs != nil {
248 expectedPaths = append(expectedPaths, c.expectedDirs[d]...)
249 }
250 actualPaths, globErr := fSys.Glob(filepath.Join(d, c.globPattern))
251 require.NoError(t, globErr)
252
253 sort.Strings(actualPaths)
254 sort.Strings(expectedPaths)
255 if !reflect.DeepEqual(actualPaths, expectedPaths) {
256 t.Fatalf("incorrect files found by glob: expected=%v, actual=%v", expectedPaths, actualPaths)
257 }
258 }
259 })
260 }
261 }
262
View as plain text