fork/gdu

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

ShivamB25feat: stop scanning and keep partial results (#606)99a7f2a

ignore
16.0 KiB634 linesraw
1package tui
2
3import (
4	"bytes"
5	"errors"
6	"os"
7	"slices"
8	"sync"
9	"testing"
10
11	"github.com/dundee/gdu/v5/internal/common"
12	"github.com/dundee/gdu/v5/internal/testanalyze"
13	"github.com/dundee/gdu/v5/internal/testapp"
14	"github.com/dundee/gdu/v5/internal/testdir"
15	"github.com/dundee/gdu/v5/pkg/analyze"
16	"github.com/dundee/gdu/v5/pkg/fs"
17	"github.com/gdamore/tcell/v2"
18	"github.com/stretchr/testify/assert"
19)
20
21func TestShowDevices(t *testing.T) {
22	app, simScreen := testapp.CreateTestAppWithSimScreen(50, 50)
23	defer simScreen.Fini()
24
25	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
26	err := ui.ListDevices(getDevicesInfoMock())
27
28	assert.Nil(t, err)
29
30	ui.table.Draw(simScreen)
31	simScreen.Show()
32
33	b, _, _ := simScreen.GetContents()
34
35	text := []byte("Device name")
36	for i, r := range b[0:11] {
37		assert.Equal(t, text[i], r.Bytes[0])
38	}
39}
40
41func TestShowDevicesBW(t *testing.T) {
42	app, simScreen := testapp.CreateTestAppWithSimScreen(50, 50)
43	defer simScreen.Fini()
44
45	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
46	err := ui.ListDevices(getDevicesInfoMock())
47
48	assert.Nil(t, err)
49
50	ui.table.Draw(simScreen)
51	simScreen.Show()
52
53	b, _, _ := simScreen.GetContents()
54
55	text := []byte("Device name")
56	for i, r := range b[0:11] {
57		assert.Equal(t, text[i], r.Bytes[0])
58	}
59}
60
61func TestDeviceSelected(t *testing.T) {
62	simScreen := testapp.CreateSimScreen()
63	defer simScreen.Fini()
64
65	app := testapp.CreateMockedApp(false)
66	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, true, false)
67	ui.Analyzer = &testanalyze.MockedAnalyzer{}
68	ui.done = make(chan struct{})
69	ui.UseOldSizeBar()
70	ui.SetIgnoreDirPaths([]string{"/xxx"})
71	err := ui.ListDevices(getDevicesInfoMock())
72
73	assert.Nil(t, err)
74	assert.Equal(t, 3, ui.table.GetRowCount())
75
76	ui.deviceItemSelected(1, 0)
77
78	<-ui.done // wait for analyzer
79
80	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
81		f()
82	}
83
84	assert.Equal(t, "test_dir", ui.currentDir.GetName())
85
86	assert.Equal(t, 4, ui.table.GetRowCount())
87	assert.Contains(t, ui.table.GetCell(0, 0).Text, "ddd")
88	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ccc")
89}
90
91func TestNilDeviceSelected(t *testing.T) {
92	simScreen := testapp.CreateSimScreen()
93	defer simScreen.Fini()
94
95	app := testapp.CreateMockedApp(false)
96	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, true, false)
97	ui.Analyzer = &testanalyze.MockedAnalyzer{}
98	ui.done = make(chan struct{})
99	ui.UseOldSizeBar()
100	ui.SetIgnoreDirPaths([]string{"/xxx"})
101
102	ui.deviceItemSelected(1, 0)
103
104	assert.Equal(t, 0, ui.table.GetRowCount())
105}
106
107func TestAnalyzePath(t *testing.T) {
108	ui := getAnalyzedPathMockedApp(t, true, true, true)
109
110	assert.Equal(t, 4, ui.table.GetRowCount())
111	assert.Contains(t, ui.table.GetCell(0, 0).Text, "ddd")
112}
113
114func TestAnalyzePathBW(t *testing.T) {
115	ui := getAnalyzedPathMockedApp(t, false, true, true)
116
117	assert.Equal(t, 4, ui.table.GetRowCount())
118	assert.Contains(t, ui.table.GetCell(0, 0).Text, "ddd")
119}
120
121func TestCtrlCDuringScanShowsPartialResults(t *testing.T) {
122	simScreen := testapp.CreateSimScreen()
123	defer simScreen.Fini()
124
125	app := testapp.CreateMockedApp(false)
126	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
127	analyzer := &blockingAnalyzer{
128		started:   make(chan struct{}),
129		cancelled: make(chan struct{}),
130		done:      make(common.SignalGroup),
131	}
132	ui.Analyzer = analyzer
133	ui.done = make(chan struct{})
134
135	assert.NoError(t, ui.AnalyzePath("test_dir", nil))
136
137	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyCtrlC, 0, 0))
138	assert.Nil(t, key)
139	assert.True(t, ui.scanCancelled)
140	<-ui.done
141	for _, draw := range app.(*testapp.MockedApp).GetUpdateDraws() {
142		draw()
143	}
144
145	assert.False(t, ui.scanCancelled)
146	assert.False(t, ui.pages.HasPage("progress"))
147	assert.Equal(t, "test_dir", ui.currentDir.GetName())
148	assert.Equal(t, 4, ui.table.GetRowCount())
149}
150
151type blockingAnalyzer struct {
152	testanalyze.MockedAnalyzer
153	started   chan struct{}
154	cancelled chan struct{}
155	done      common.SignalGroup
156	once      sync.Once
157}
158
159func (a *blockingAnalyzer) AnalyzeDir(
160	path string, ignore common.ShouldDirBeIgnored, fileTypeFilter common.ShouldFileBeIgnored,
161) fs.Item {
162	close(a.started)
163	<-a.cancelled
164	defer a.done.Broadcast()
165	return a.MockedAnalyzer.AnalyzeDir(path, ignore, fileTypeFilter)
166}
167
168func (a *blockingAnalyzer) Cancel() {
169	a.once.Do(func() {
170		close(a.cancelled)
171	})
172}
173
174func (a *blockingAnalyzer) GetDone() common.SignalGroup {
175	return a.done
176}
177
178func TestAnalyzePathWithParentDir(t *testing.T) {
179	parentDir := &analyze.Dir{
180		File: &analyze.File{
181			Name: "parent",
182		},
183		Files: make([]fs.Item, 0, 1),
184	}
185
186	simScreen := testapp.CreateSimScreen()
187	defer simScreen.Fini()
188
189	app := testapp.CreateMockedApp(true)
190	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, true, true)
191	ui.Analyzer = &testanalyze.MockedAnalyzer{}
192	ui.topDir = parentDir
193	ui.done = make(chan struct{})
194	err := ui.AnalyzePath("test_dir", parentDir)
195	assert.Nil(t, err)
196
197	<-ui.done // wait for analyzer
198
199	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
200		f()
201	}
202
203	assert.Equal(t, "test_dir", ui.currentDir.GetName())
204	assert.Equal(t, parentDir, ui.currentDir.GetParent())
205
206	assert.Equal(t, 5, ui.table.GetRowCount())
207	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
208	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ddd")
209}
210
211func TestReadAnalysis(t *testing.T) {
212	simScreen := testapp.CreateSimScreen()
213	defer simScreen.Fini()
214
215	input, err := os.OpenFile("../internal/testdata/test.json", os.O_RDONLY, 0o644)
216	assert.Nil(t, err)
217
218	app := testapp.CreateMockedApp(true)
219	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, true, false)
220	ui.done = make(chan struct{})
221
222	err = ui.ReadAnalysis(input)
223	assert.Nil(t, err)
224
225	<-ui.done // wait for reading
226
227	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
228		f()
229	}
230
231	assert.Equal(t, "gdu", ui.currentDir.GetName())
232}
233
234func TestReadAnalysisWithWrongFile(t *testing.T) {
235	simScreen := testapp.CreateSimScreen()
236	defer simScreen.Fini()
237
238	input, err := os.OpenFile("../internal/testdata/wrong.json", os.O_RDONLY, 0o644)
239	assert.Nil(t, err)
240
241	app := testapp.CreateMockedApp(true)
242	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
243	ui.done = make(chan struct{})
244
245	err = ui.ReadAnalysis(input)
246	assert.Nil(t, err)
247
248	<-ui.done // wait for reading
249
250	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
251		f()
252	}
253
254	assert.True(t, ui.pages.HasPage("error"))
255}
256
257func TestViewDirContents(t *testing.T) {
258	simScreen := testapp.CreateSimScreen()
259	defer simScreen.Fini()
260
261	app := testapp.CreateMockedApp(true)
262	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
263	ui.Analyzer = &testanalyze.MockedAnalyzer{}
264	ui.done = make(chan struct{})
265	err := ui.AnalyzePath("test_dir", nil)
266	assert.Nil(t, err)
267
268	<-ui.done // wait for analyzer
269
270	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
271		f()
272	}
273
274	assert.Equal(t, "test_dir", ui.currentDir.GetName())
275
276	res := ui.showFile() // selected item is dir, do nothing
277	assert.Nil(t, res)
278}
279
280func TestViewFileWithoutCurrentDir(t *testing.T) {
281	simScreen := testapp.CreateSimScreen()
282	defer simScreen.Fini()
283
284	app := testapp.CreateMockedApp(true)
285	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
286	ui.Analyzer = &testanalyze.MockedAnalyzer{}
287	ui.done = make(chan struct{})
288
289	res := ui.showFile() // no current directory
290	assert.Nil(t, res)
291}
292
293func TestViewContentsOfNotExistingFile(t *testing.T) {
294	simScreen := testapp.CreateSimScreen()
295	defer simScreen.Fini()
296
297	app := testapp.CreateMockedApp(true)
298	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
299	ui.Analyzer = &testanalyze.MockedAnalyzer{}
300	ui.done = make(chan struct{})
301	err := ui.AnalyzePath("test_dir", nil)
302	assert.Nil(t, err)
303
304	<-ui.done // wait for analyzer
305
306	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
307		f()
308	}
309
310	assert.Equal(t, "test_dir", ui.currentDir.GetName())
311
312	ui.table.Select(3, 0)
313
314	selectedFile := ui.table.GetCell(3, 0).GetReference().(fs.Item)
315	assert.Equal(t, "aaa", selectedFile.GetName())
316
317	res := ui.showFile()
318	assert.Nil(t, res)
319}
320
321func TestViewFile(t *testing.T) {
322	fin := testdir.CreateTestDir()
323	defer fin()
324	simScreen := testapp.CreateSimScreen()
325	defer simScreen.Fini()
326
327	app := testapp.CreateMockedApp(true)
328	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
329	ui.done = make(chan struct{})
330	err := ui.AnalyzePath("test_dir", nil)
331	assert.Nil(t, err)
332
333	<-ui.done // wait for analyzer
334
335	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
336		f()
337	}
338
339	assert.Equal(t, "test_dir", ui.currentDir.GetName())
340
341	ui.table.Select(0, 0)
342	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
343	ui.table.Select(2, 0)
344
345	file := ui.showFile()
346	assert.True(t, ui.pages.HasPage("file"))
347
348	event := file.GetInputCapture()(tcell.NewEventKey(tcell.KeyRune, 'j', 0))
349	assert.Equal(t, 'j', event.Rune())
350}
351
352func TestChangeCwd(t *testing.T) {
353	fin := testdir.CreateTestDir()
354	defer fin()
355	simScreen := testapp.CreateSimScreen()
356	defer simScreen.Fini()
357	cwd := ""
358
359	opt := func(ui *UI) {
360		ui.SetChangeCwdFn(func(p string) error {
361			cwd = p
362			return nil
363		})
364	}
365	app := testapp.CreateMockedApp(true)
366	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false, opt)
367	ui.done = make(chan struct{})
368	err := ui.AnalyzePath("test_dir", nil)
369	assert.Nil(t, err)
370
371	<-ui.done // wait for analyzer
372
373	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
374		f()
375	}
376
377	assert.Equal(t, "test_dir", ui.currentDir.GetName())
378
379	ui.table.Select(0, 0)
380	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
381	ui.table.Select(1, 0)
382	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
383
384	assert.Equal(t, cwd, "test_dir/nested/subnested")
385}
386
387func TestChangeCwdWithErr(t *testing.T) {
388	fin := testdir.CreateTestDir()
389	defer fin()
390	simScreen := testapp.CreateSimScreen()
391	defer simScreen.Fini()
392	cwd := ""
393
394	opt := func(ui *UI) {
395		ui.SetChangeCwdFn(func(p string) error {
396			cwd = p
397			return errors.New("failed")
398		})
399	}
400	app := testapp.CreateMockedApp(true)
401	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false, opt)
402	ui.done = make(chan struct{})
403	err := ui.AnalyzePath("test_dir", nil)
404	assert.Nil(t, err)
405
406	<-ui.done // wait for analyzer
407
408	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
409		f()
410	}
411
412	assert.Equal(t, "test_dir", ui.currentDir.GetName())
413
414	ui.table.Select(0, 0)
415	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
416	ui.table.Select(1, 0)
417	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
418
419	assert.Equal(t, cwd, "test_dir/nested/subnested")
420}
421
422func TestShowInfo(t *testing.T) {
423	fin := testdir.CreateTestDir()
424	defer fin()
425	simScreen := testapp.CreateSimScreen()
426	defer simScreen.Fini()
427
428	app := testapp.CreateMockedApp(true)
429	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
430	ui.done = make(chan struct{})
431	err := ui.AnalyzePath("test_dir", nil)
432	assert.Nil(t, err)
433
434	<-ui.done // wait for analyzer
435
436	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
437		f()
438	}
439
440	assert.Equal(t, "test_dir", ui.currentDir.GetName())
441
442	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
443	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
444
445	assert.True(t, ui.pages.HasPage("info"))
446
447	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
448
449	assert.False(t, ui.pages.HasPage("info"))
450}
451
452func TestShowInfoBW(t *testing.T) {
453	fin := testdir.CreateTestDir()
454	defer fin()
455	simScreen := testapp.CreateSimScreen()
456	defer simScreen.Fini()
457
458	app := testapp.CreateMockedApp(true)
459	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
460	ui.done = make(chan struct{})
461	err := ui.AnalyzePath("test_dir", nil)
462	assert.Nil(t, err)
463
464	<-ui.done // wait for analyzer
465
466	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
467		f()
468	}
469
470	assert.Equal(t, "test_dir", ui.currentDir.GetName())
471
472	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
473	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
474
475	assert.True(t, ui.pages.HasPage("info"))
476
477	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
478
479	assert.False(t, ui.pages.HasPage("info"))
480}
481
482func TestShowInfoWithHardlinks(t *testing.T) {
483	fin := testdir.CreateTestDir()
484	defer fin()
485	simScreen := testapp.CreateSimScreen()
486	defer simScreen.Fini()
487
488	app := testapp.CreateMockedApp(true)
489	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
490	ui.done = make(chan struct{})
491	err := ui.AnalyzePath("test_dir", nil)
492	assert.Nil(t, err)
493
494	<-ui.done // wait for analyzer
495
496	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
497		f()
498	}
499
500	files := slices.Collect(ui.currentDir.GetFiles(fs.SortByName, fs.SortAsc))
501	nested := files[0].(*analyze.Dir)
502	subnested := nested.Files[1].(*analyze.Dir)
503	file := subnested.Files[0].(*analyze.File)
504	file2 := nested.Files[0].(*analyze.File)
505	file.Mli = 1
506	file2.Mli = 1
507
508	ui.currentDir.UpdateStats(ui.linkedItems)
509
510	assert.Equal(t, "test_dir", ui.currentDir.GetName())
511
512	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
513	ui.table.Select(1, 0)
514	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
515	ui.table.Select(1, 0)
516	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
517
518	assert.True(t, ui.pages.HasPage("info"))
519
520	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
521
522	assert.False(t, ui.pages.HasPage("info"))
523}
524
525func TestShowInfoWithoutCurrentDir(t *testing.T) {
526	fin := testdir.CreateTestDir()
527	defer fin()
528	simScreen := testapp.CreateSimScreen()
529	defer simScreen.Fini()
530
531	app := testapp.CreateMockedApp(true)
532	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
533	ui.done = make(chan struct{})
534
535	// pressing `i` will do nothing
536	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
537	assert.False(t, ui.pages.HasPage("info"))
538}
539
540func TestExitViewFile(t *testing.T) {
541	fin := testdir.CreateTestDir()
542	defer fin()
543	simScreen := testapp.CreateSimScreen()
544	defer simScreen.Fini()
545
546	app := testapp.CreateMockedApp(true)
547	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
548	ui.done = make(chan struct{})
549	err := ui.AnalyzePath("test_dir", nil)
550	assert.Nil(t, err)
551
552	<-ui.done // wait for analyzer
553
554	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
555		f()
556	}
557
558	assert.Equal(t, "test_dir", ui.currentDir.GetName())
559
560	ui.table.Select(0, 0)
561	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
562	ui.table.Select(2, 0)
563
564	file := ui.showFile()
565
566	assert.True(t, ui.pages.HasPage("file"))
567
568	file.GetInputCapture()(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
569
570	assert.False(t, ui.pages.HasPage("file"))
571}
572
573func TestAnalyzePathCreatesProgressBar(t *testing.T) {
574	simScreen := testapp.CreateSimScreen()
575	defer simScreen.Fini()
576
577	app := testapp.CreateMockedApp(true)
578	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
579	ui.Analyzer = &testanalyze.MockedAnalyzer{}
580	ui.done = make(chan struct{})
581	ui.currentDeviceSize = 1e6
582	ui.showDiskProgressBar = true
583
584	err := ui.AnalyzePath("test_dir", nil)
585	assert.Nil(t, err)
586	assert.NotNil(t, ui.progressBar)
587
588	<-ui.done
589	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
590		f()
591	}
592}
593
594func TestAnalyzePathNoProgressBarWhenDisabled(t *testing.T) {
595	simScreen := testapp.CreateSimScreen()
596	defer simScreen.Fini()
597
598	app := testapp.CreateMockedApp(true)
599	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
600	ui.Analyzer = &testanalyze.MockedAnalyzer{}
601	ui.done = make(chan struct{})
602	ui.currentDeviceSize = 1e6
603	ui.showDiskProgressBar = false
604
605	err := ui.AnalyzePath("test_dir", nil)
606	assert.Nil(t, err)
607	assert.Nil(t, ui.progressBar)
608
609	<-ui.done
610	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
611		f()
612	}
613}
614
615func TestAnalyzePathNoProgressBarWhenNoDeviceSize(t *testing.T) {
616	simScreen := testapp.CreateSimScreen()
617	defer simScreen.Fini()
618
619	app := testapp.CreateMockedApp(true)
620	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
621	ui.Analyzer = &testanalyze.MockedAnalyzer{}
622	ui.done = make(chan struct{})
623	ui.currentDeviceSize = 0
624	ui.showDiskProgressBar = true
625
626	err := ui.AnalyzePath("test_dir", nil)
627	assert.Nil(t, err)
628	assert.Nil(t, ui.progressBar)
629
630	<-ui.done
631	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
632		f()
633	}
634}