fork/gdu

git clone https://git.julia.blue/fork/gdu

Daniel Mildefix: correct item count and size for empty dirs (#574)272c209

subvolume
8.1 KiB311 linesraw
1package analyze
2
3import (
4	"os"
5	"testing"
6
7	"github.com/dundee/gdu/v5/internal/testdir"
8	"github.com/dundee/gdu/v5/pkg/fs"
9	"github.com/stretchr/testify/assert"
10)
11
12func TestTopDirAnalyzeDir(t *testing.T) {
13	fin := testdir.CreateTestDir()
14	defer fin()
15
16	analyzer := CreateTopDirAnalyzer()
17	dir := analyzer.AnalyzeDir(
18		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
19	)
20
21	analyzer.GetDone().Wait()
22
23	assert.Equal(t, "test_dir", dir.GetName())
24
25	simpleDir := dir.(*SimpleDir)
26	simpleDir.UpdateStats(make(fs.HardLinkedItems))
27
28	// Should have one top-level entry: "nested" directory
29	assert.Equal(t, 1, len(simpleDir.Files))
30	assert.True(t, simpleDir.Files[0].IsDir)
31	assert.Equal(t, "nested", simpleDir.Files[0].Name)
32	// nested dir contains: file2 (2 bytes) + subnested/file (5 bytes) + dir overhead
33	assert.Greater(t, simpleDir.Files[0].Size, int64(0))
34	assert.Greater(t, simpleDir.Files[0].ItemCount, int64(0))
35}
36
37func TestTopDirAnalyzeDirWithFiles(t *testing.T) {
38	tmpDir := t.TempDir()
39
40	err := os.WriteFile(tmpDir+"/file_a", []byte("hello"), 0o644)
41	assert.Nil(t, err)
42	err = os.Mkdir(tmpDir+"/subdir", 0o755)
43	assert.Nil(t, err)
44	err = os.WriteFile(tmpDir+"/subdir/file_b", []byte("world!"), 0o644)
45	assert.Nil(t, err)
46
47	analyzer := CreateTopDirAnalyzer()
48	dir := analyzer.AnalyzeDir(
49		tmpDir, func(_, _ string) bool { return false }, func(_ string) bool { return false },
50	)
51
52	analyzer.GetDone().Wait()
53
54	simpleDir := dir.(*SimpleDir)
55	simpleDir.UpdateStats(make(fs.HardLinkedItems))
56
57	// Should have 2 entries: file_a and subdir
58	assert.Equal(t, 2, len(simpleDir.Files))
59
60	// Verify total size includes both
61	assert.Greater(t, simpleDir.GetSize(), int64(0))
62}
63
64func TestTopDirAnalyzeDirIgnoreDir(t *testing.T) {
65	fin := testdir.CreateTestDir()
66	defer fin()
67
68	analyzer := CreateTopDirAnalyzer()
69	dir := analyzer.AnalyzeDir(
70		"test_dir",
71		func(name, _ string) bool { return name == "nested" },
72		func(_ string) bool { return false },
73	)
74
75	analyzer.GetDone().Wait()
76
77	simpleDir := dir.(*SimpleDir)
78	// "nested" directory should be ignored, no entries
79	assert.Equal(t, 0, len(simpleDir.Files))
80}
81
82func TestTopDirAnalyzeDirIgnoreFileType(t *testing.T) {
83	tmpDir := t.TempDir()
84
85	err := os.WriteFile(tmpDir+"/keep.txt", []byte("keep"), 0o644)
86	assert.Nil(t, err)
87	err = os.WriteFile(tmpDir+"/skip.log", []byte("skip"), 0o644)
88	assert.Nil(t, err)
89
90	analyzer := CreateTopDirAnalyzer()
91	dir := analyzer.AnalyzeDir(
92		tmpDir,
93		func(_, _ string) bool { return false },
94		func(name string) bool {
95			return len(name) > 4 && name[len(name)-4:] == ".log"
96		},
97	)
98
99	analyzer.GetDone().Wait()
100
101	simpleDir := dir.(*SimpleDir)
102	assert.Equal(t, 1, len(simpleDir.Files))
103	assert.Equal(t, "keep.txt", simpleDir.Files[0].Name)
104}
105
106func TestTopDirAnalyzeDirIgnoreFileTypeInSubDir(t *testing.T) {
107	tmpDir := t.TempDir()
108
109	err := os.Mkdir(tmpDir+"/sub", 0o755)
110	assert.Nil(t, err)
111	err = os.WriteFile(tmpDir+"/sub/keep.txt", []byte("keep"), 0o644)
112	assert.Nil(t, err)
113	err = os.WriteFile(tmpDir+"/sub/skip.log", []byte("skip"), 0o644)
114	assert.Nil(t, err)
115
116	analyzer := CreateTopDirAnalyzer()
117	dir := analyzer.AnalyzeDir(
118		tmpDir,
119		func(_, _ string) bool { return false },
120		func(name string) bool {
121			return len(name) > 4 && name[len(name)-4:] == ".log"
122		},
123	)
124
125	analyzer.GetDone().Wait()
126
127	simpleDir := dir.(*SimpleDir)
128	// sub directory should exist but only count keep.txt
129	assert.Equal(t, 1, len(simpleDir.Files))
130	assert.Equal(t, "sub", simpleDir.Files[0].Name)
131	// ItemCount should reflect only the kept file
132	assert.Equal(t, int64(1), simpleDir.Files[0].ItemCount)
133}
134
135func TestTopDirAnalyzeDirProgress(t *testing.T) {
136	fin := testdir.CreateTestDir()
137	defer fin()
138
139	analyzer := CreateTopDirAnalyzer()
140	_ = analyzer.AnalyzeDir(
141		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
142	)
143
144	analyzer.GetDone().Wait()
145
146	// Just verify the progress channel is accessible and was used
147	assert.NotNil(t, analyzer.GetProgress())
148}
149
150func TestTopDirAnalyzeDirResetProgress(t *testing.T) {
151	fin := testdir.CreateTestDir()
152	defer fin()
153
154	analyzer := CreateTopDirAnalyzer()
155	_ = analyzer.AnalyzeDir(
156		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
157	)
158
159	progress := analyzer.GetProgress()
160	assert.GreaterOrEqual(t, progress.TotalUsage, int64(0))
161
162	analyzer.GetDone().Wait()
163	analyzer.ResetProgress()
164
165	// Analyze again after reset
166	dir := analyzer.AnalyzeDir(
167		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
168	)
169
170	analyzer.GetDone().Wait()
171
172	assert.Equal(t, "test_dir", dir.GetName())
173}
174
175func TestTopDirAnalyzeDirNonExistent(t *testing.T) {
176	analyzer := CreateTopDirAnalyzer()
177	dir := analyzer.AnalyzeDir(
178		"/nonexistent_path_xyz", func(_, _ string) bool { return false }, func(_ string) bool { return false },
179	)
180
181	analyzer.GetDone().Wait()
182
183	simpleDir := dir.(*SimpleDir)
184	assert.Equal(t, "nonexistent_path_xyz", simpleDir.Name)
185	assert.Equal(t, 0, len(simpleDir.Files))
186}
187
188func TestTopDirAnalyzerSetters(t *testing.T) {
189	analyzer := CreateTopDirAnalyzer()
190
191	analyzer.SetFollowSymlinks(true)
192	assert.True(t, analyzer.followSymlinks)
193
194	analyzer.SetShowAnnexedSize(true)
195	assert.True(t, analyzer.gitAnnexedSize)
196
197	analyzer.SetArchiveBrowsing(true)
198	assert.True(t, analyzer.archiveBrowsing)
199
200	called := false
201	filter := func(name string) bool { called = true; return false }
202	analyzer.SetFileTypeFilter(filter)
203	analyzer.ignoreFileType("test")
204	assert.True(t, called)
205}
206
207func TestTopDirAnalyzeDirIgnoreSubDir(t *testing.T) {
208	tmpDir := t.TempDir()
209
210	err := os.MkdirAll(tmpDir+"/top/ignored", 0o755)
211	assert.Nil(t, err)
212	err = os.MkdirAll(tmpDir+"/top/kept", 0o755)
213	assert.Nil(t, err)
214	err = os.WriteFile(tmpDir+"/top/ignored/file", []byte("data"), 0o644)
215	assert.Nil(t, err)
216	err = os.WriteFile(tmpDir+"/top/kept/file", []byte("data"), 0o644)
217	assert.Nil(t, err)
218
219	analyzer := CreateTopDirAnalyzer()
220	dir := analyzer.AnalyzeDir(
221		tmpDir,
222		func(name, _ string) bool { return name == "ignored" },
223		func(_ string) bool { return false },
224	)
225
226	analyzer.GetDone().Wait()
227
228	simpleDir := dir.(*SimpleDir)
229	assert.Equal(t, 1, len(simpleDir.Files))
230	assert.Equal(t, "top", simpleDir.Files[0].Name)
231}
232
233func TestTopDirGetFiles(t *testing.T) {
234	fin := testdir.CreateTestDir()
235	defer fin()
236
237	analyzer := CreateTopDirAnalyzer()
238	dir := analyzer.AnalyzeDir(
239		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
240	)
241
242	analyzer.GetDone().Wait()
243
244	simpleDir := dir.(*SimpleDir)
245	simpleDir.UpdateStats(make(fs.HardLinkedItems))
246
247	count := 0
248	for range simpleDir.GetFiles(fs.SortBySize, fs.SortAsc) {
249		count++
250	}
251	assert.Equal(t, len(simpleDir.Files), count)
252}
253
254func TestTopDirFollowSymlink(t *testing.T) {
255	fin := testdir.CreateTestDir()
256	defer fin()
257
258	err := os.Mkdir("test_dir/empty", 0o644)
259	assert.Nil(t, err)
260
261	err = os.Symlink("nested/subnested/file", "./test_dir/file2")
262	assert.Nil(t, err)
263
264	analyzer := CreateTopDirAnalyzer()
265	analyzer.SetFollowSymlinks(true)
266	dir := analyzer.AnalyzeDir(
267		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
268	).(*SimpleDir)
269	analyzer.GetDone().Wait()
270	dir.UpdateStats(make(fs.HardLinkedItems))
271
272	var files []fs.Item
273	for file := range dir.GetFiles(fs.SortBySize, fs.SortDesc) {
274		files = append(files, file)
275	}
276
277	assert.Equal(t, int64(12+512), dir.Size)
278	assert.Equal(t, int64(4), dir.ItemCount)
279
280	// test file3
281	assert.Equal(t, "file2", files[1].GetName())
282	assert.Equal(t, int64(5), files[1].GetSize())
283	assert.Equal(t, ' ', files[1].GetFlag())
284}
285
286func TestTopDirFollowNestedSymlink(t *testing.T) {
287	fin := testdir.CreateTestDir()
288	defer fin()
289
290	err := os.Mkdir("test_dir/empty", 0o644)
291	assert.Nil(t, err)
292
293	err = os.Symlink("subnested/file", "./test_dir/nested/file3")
294	assert.Nil(t, err)
295
296	analyzer := CreateTopDirAnalyzer()
297	analyzer.SetFollowSymlinks(true)
298	dir := analyzer.AnalyzeDir(
299		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
300	).(*SimpleDir)
301	analyzer.GetDone().Wait()
302	dir.UpdateStats(make(fs.HardLinkedItems))
303
304	var files []fs.Item
305	for file := range dir.GetFiles(fs.SortBySize, fs.SortDesc) {
306		files = append(files, file)
307	}
308
309	assert.Equal(t, int64(12+512), dir.Size)
310	assert.Equal(t, int64(5), dir.ItemCount)
311}