fork/gdu

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

Quet Zalfeat(analyze): add SQLite analyzer and some assorted changes (#484)da638da

subvolume
6.7 KiB303 linesraw
1package tui
2
3import (
4	"bytes"
5	"testing"
6
7	"github.com/dundee/gdu/v5/internal/testapp"
8	"github.com/dundee/gdu/v5/pkg/analyze"
9	"github.com/dundee/gdu/v5/pkg/fs"
10	"github.com/stretchr/testify/assert"
11)
12
13func TestFindCollapsiblePath(t *testing.T) {
14	// Test case 1: Non-directory item should return nil
15	file := &analyze.File{
16		Name: "test.txt",
17	}
18	result := findCollapsiblePath(file)
19	assert.Nil(t, result)
20
21	// Test case 2: Directory with files and subdirectories should not collapse
22	dirWithFiles := &analyze.Dir{
23		File: &analyze.File{
24			Name: "mixed",
25		},
26		Files: []fs.Item{
27			&analyze.Dir{
28				File: &analyze.File{
29					Name: "subdir",
30				},
31				Files: []fs.Item{},
32			},
33			&analyze.File{
34				Name: "file.txt",
35			},
36		},
37	}
38	result = findCollapsiblePath(dirWithFiles)
39	assert.Nil(t, result)
40
41	// Test case 3: Directory with multiple subdirectories should not collapse
42	dirWithMultiSubs := &analyze.Dir{
43		File: &analyze.File{
44			Name: "multi",
45		},
46		Files: []fs.Item{
47			&analyze.Dir{
48				File: &analyze.File{
49					Name: "subdir1",
50				},
51				Files: []fs.Item{},
52			},
53			&analyze.Dir{
54				File: &analyze.File{
55					Name: "subdir2",
56				},
57				Files: []fs.Item{},
58			},
59		},
60	}
61	result = findCollapsiblePath(dirWithMultiSubs)
62	assert.Nil(t, result)
63
64	// Test case 4: Single subdirectory chain should collapse
65	deepestDir := &analyze.Dir{
66		File: &analyze.File{
67			Name: "deep",
68		},
69		Files: []fs.Item{
70			&analyze.File{
71				Name: "finalfile.txt",
72			},
73		},
74	}
75
76	middleDir := &analyze.Dir{
77		File: &analyze.File{
78			Name: "middle",
79		},
80		Files: []fs.Item{deepestDir},
81	}
82
83	rootDir := &analyze.Dir{
84		File: &analyze.File{
85			Name: "root",
86		},
87		Files: []fs.Item{middleDir},
88	}
89
90	result = findCollapsiblePath(rootDir)
91	assert.NotNil(t, result)
92	assert.Equal(t, "root/middle/deep", result.DisplayName)
93	assert.Equal(t, deepestDir, result.DeepestDir)
94	assert.Equal(t, []string{"middle", "deep"}, result.Segments)
95
96	// Test case 5: Directory with no subdirectories should not collapse
97	emptyDir := &analyze.Dir{
98		File: &analyze.File{
99			Name: "empty",
100		},
101		Files: []fs.Item{},
102	}
103	result = findCollapsiblePath(emptyDir)
104	assert.Nil(t, result)
105}
106
107func TestFindCollapsedParent(t *testing.T) {
108	// Test case 1: Nil current directory
109	result := findCollapsedParent(nil)
110	assert.Nil(t, result)
111
112	// Test case 2: Directory without parent
113	rootDir := &analyze.Dir{
114		File: &analyze.File{
115			Name: "root",
116		},
117		Files: []fs.Item{},
118	}
119	result = findCollapsedParent(rootDir)
120	assert.Nil(t, result)
121
122	// Test case 3: Directory in a collapsed chain
123	otherDir := &analyze.Dir{
124		File: &analyze.File{
125			Name: "other",
126		},
127		Files: []fs.Item{},
128	}
129
130	grandParent := &analyze.Dir{
131		File: &analyze.File{
132			Name: "grandparent",
133		},
134		Files: []fs.Item{otherDir},
135	}
136	otherDir.SetParent(grandParent)
137
138	parent := &analyze.Dir{
139		File: &analyze.File{
140			Name: "parent",
141		},
142		Files: []fs.Item{},
143	}
144	parent.SetParent(grandParent)
145	grandParent.AddFile(parent)
146
147	child := &analyze.Dir{
148		File: &analyze.File{
149			Name: "child",
150		},
151		Files: []fs.Item{},
152	}
153	child.SetParent(parent)
154	parent.AddFile(child)
155
156	result = findCollapsedParent(child)
157	assert.Equal(t, grandParent, result)
158
159	// Test case 4: Directory not in a collapsed chain
160	normalParent := &analyze.Dir{
161		File: &analyze.File{
162			Name: "normalparent",
163		},
164		Files: []fs.Item{
165			&analyze.File{
166				Name: "file.txt",
167			},
168		},
169	}
170
171	normalChild := &analyze.Dir{
172		File: &analyze.File{
173			Name: "normalchild",
174		},
175		Files: []fs.Item{},
176	}
177	normalChild.SetParent(normalParent)
178	normalParent.AddFile(normalChild)
179
180	result = findCollapsedParent(normalChild)
181	assert.Equal(t, normalParent, result)
182}
183
184func TestFormatCollapsedRow(t *testing.T) {
185	simScreen := testapp.CreateSimScreen()
186	defer simScreen.Fini()
187
188	app := testapp.CreateMockedApp(true)
189	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
190
191	// Create a test collapsed path
192	deepDir := &analyze.Dir{
193		File: &analyze.File{
194			Name:  "deep",
195			Size:  1000,
196			Usage: 800,
197		},
198		Files: []fs.Item{},
199	}
200
201	collapsedPath := &CollapsedPath{
202		DisplayName: "level1/level2/deep",
203		DeepestDir:  deepDir,
204		Segments:    []string{"level1", "level2", "deep"},
205	}
206
207	// Test normal formatting
208	result := ui.formatCollapsedRow(collapsedPath, 1000, 1000, false, false)
209	assert.Contains(t, result, "level1/level2/deep")
210	assert.Contains(t, result, "/") // Should have directory indicator
211
212	// Test with marked flag
213	ui.markedRows = map[int]struct{}{0: {}}
214	result = ui.formatCollapsedRow(collapsedPath, 1000, 1000, true, false)
215	assert.Contains(t, result, "✓") // Should have marked indicator
216
217	// Test with ignored flag
218	result = ui.formatCollapsedRow(collapsedPath, 1000, 1000, false, true)
219	assert.Contains(t, result, "level1/level2/deep")
220
221	// Test with ShowApparentSize
222	ui.ShowApparentSize = true
223	result = ui.formatCollapsedRow(collapsedPath, 1000, 1000, false, false)
224	assert.Contains(t, result, "level1/level2/deep")
225
226	// Test with showItemCount
227	ui.showItemCount = true
228	result = ui.formatCollapsedRow(collapsedPath, 1000, 1000, false, false)
229	assert.Contains(t, result, "level1/level2/deep")
230
231	// Test with showMtime
232	ui.showMtime = true
233	result = ui.formatCollapsedRow(collapsedPath, 1000, 1000, false, false)
234	assert.Contains(t, result, "level1/level2/deep")
235
236	// Test without colors
237	ui2 := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
238	result = ui2.formatCollapsedRow(collapsedPath, 1000, 1000, false, false)
239	assert.Contains(t, result, "level1/level2/deep")
240}
241
242func TestCollapsedPathIntegration(t *testing.T) {
243	simScreen := testapp.CreateSimScreen()
244	defer simScreen.Fini()
245
246	app := testapp.CreateMockedApp(true)
247	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
248
249	// Create a directory structure that should be collapsed
250	deepestDir := &analyze.Dir{
251		File: &analyze.File{
252			Name:  "deepest",
253			Size:  100,
254			Usage: 80,
255		},
256		Files: []fs.Item{
257			&analyze.File{
258				Name:  "file.txt",
259				Size:  50,
260				Usage: 40,
261			},
262		},
263	}
264
265	middleDir := &analyze.Dir{
266		File: &analyze.File{
267			Name:  "middle",
268			Size:  100,
269			Usage: 80,
270		},
271		Files: []fs.Item{deepestDir},
272	}
273
274	topDir := &analyze.Dir{
275		File: &analyze.File{
276			Name:  "top",
277			Size:  100,
278			Usage: 80,
279		},
280		Files: []fs.Item{middleDir},
281	}
282
283	deepestDir.SetParent(middleDir)
284	middleDir.SetParent(topDir)
285
286	ui.currentDir = topDir
287	ui.topDir = topDir
288	ui.topDirPath = "/test"
289	ui.currentDirPath = "/test"
290	ui.SetCollapsePath(true)
291
292	// Test that showDir properly handles collapsed paths
293	ui.showDir()
294
295	// Test navigation into collapsed path
296	ui.table.Select(1, 0) // Select the collapsed entry
297	cell := ui.table.GetCell(1, 0)
298	assert.NotNil(t, cell)
299
300	ref := cell.GetReference()
301	assert.NotNil(t, ref)
302	assert.Equal(t, deepestDir, ref) // Should reference the deepest directory
303}