fork/gdu

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

Daniel Mildefeat: show bar for item count (#649)daaae96

master
28.8 KiB1233 linesraw
1package tui
2
3import (
4	"bytes"
5	"errors"
6	"fmt"
7	"os"
8	"testing"
9	"time"
10
11	log "github.com/sirupsen/logrus"
12
13	"github.com/dundee/gdu/v5/internal/common"
14	"github.com/dundee/gdu/v5/internal/testanalyze"
15	"github.com/dundee/gdu/v5/internal/testapp"
16	"github.com/dundee/gdu/v5/internal/testdev"
17	"github.com/dundee/gdu/v5/internal/testdir"
18	"github.com/dundee/gdu/v5/pkg/analyze"
19	"github.com/dundee/gdu/v5/pkg/device"
20	"github.com/dundee/gdu/v5/pkg/fs"
21	"github.com/gdamore/tcell/v2"
22	"github.com/rivo/tview"
23	"github.com/stretchr/testify/assert"
24)
25
26func init() {
27	log.SetLevel(log.WarnLevel)
28}
29
30func TestFooter(t *testing.T) {
31	app, simScreen := testapp.CreateTestAppWithSimScreen(15, 15)
32	defer simScreen.Fini()
33
34	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
35
36	dir := &analyze.Dir{
37		File: &analyze.File{
38			Name:  "xxx",
39			Size:  5,
40			Usage: 4096,
41		},
42		BasePath:  ".",
43		ItemCount: 2,
44	}
45
46	file := &analyze.File{
47		Name:   "yyy",
48		Size:   2,
49		Usage:  4096,
50		Parent: dir,
51	}
52	dir.Files = fs.Files{file}
53
54	ui.currentDir = dir
55	ui.showDir()
56	ui.pages.HidePage("progress")
57
58	ui.footerLabel.Draw(simScreen)
59	simScreen.Show()
60
61	b, _, _ := simScreen.GetContents()
62
63	// printScreen(simScreen)
64
65	text := []byte(" Total disk    usage: 4.0 KiB Apparent size: 2 B Items: 1")
66	for i, r := range b {
67		if i >= len(text) {
68			break
69		}
70		assert.Equal(t, string(text[i]), string(r.Bytes[0]), fmt.Sprintf("Index: %d", i))
71	}
72}
73
74func TestUpdateProgress(t *testing.T) {
75	simScreen := testapp.CreateSimScreen()
76	defer simScreen.Fini()
77
78	app := testapp.CreateMockedApp(true)
79	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
80	done := ui.Analyzer.GetDone()
81	done.Broadcast()
82	ui.updateProgress(ui.Analyzer, done)
83}
84
85func TestUpdateProgressShowsCancellationHint(t *testing.T) {
86	simScreen := testapp.CreateSimScreen()
87	defer simScreen.Fini()
88
89	app := testapp.CreateMockedApp(false).(*testapp.MockedApp)
90	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
91	ui.progress = ui.header
92	done := make(common.SignalGroup)
93	finished := make(chan struct{})
94	go func() {
95		defer close(finished)
96		ui.updateProgress(ui.Analyzer, done)
97	}()
98
99	if !assert.Eventually(t, func() bool {
100		return len(app.GetUpdateDraws()) > 0
101	}, time.Second, 10*time.Millisecond) {
102		done.Broadcast()
103		<-finished
104		return
105	}
106	done.Broadcast()
107	<-finished
108
109	draws := app.GetUpdateDraws()
110	draws[0]()
111	assert.Contains(t, ui.progress.GetText(false), "Press Ctrl+C to stop scanning and keep results")
112}
113
114func TestSetShowDiskProgressBar(t *testing.T) {
115	simScreen := testapp.CreateSimScreen()
116	defer simScreen.Fini()
117
118	app := testapp.CreateMockedApp(true)
119	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
120
121	ui.SetShowDiskProgressBar(true)
122	assert.True(t, ui.showDiskProgressBar)
123
124	ui.SetShowDiskProgressBar(false)
125	assert.False(t, ui.showDiskProgressBar)
126}
127
128func TestDeviceSelectedSetsCurrentDeviceSize(t *testing.T) {
129	simScreen := testapp.CreateSimScreen()
130	defer simScreen.Fini()
131
132	app := testapp.CreateMockedApp(false)
133	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, true, false)
134	ui.Analyzer = &testanalyze.MockedAnalyzer{}
135	ui.done = make(chan struct{})
136	ui.SetIgnoreDirPaths([]string{"/xxx"})
137	err := ui.ListDevices(getDevicesInfoMock())
138	assert.Nil(t, err)
139
140	ui.deviceItemSelected(1, 0)
141
142	// currentDeviceSize must be set to the selected device's Size before analysis starts.
143	assert.Equal(t, int64(1e12), ui.currentDeviceSize)
144
145	<-ui.done
146	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
147		f()
148	}
149}
150
151func TestHelp(t *testing.T) {
152	app, simScreen := testapp.CreateTestAppWithSimScreen(50, 50)
153	defer simScreen.Fini()
154
155	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
156	ui.showHelp()
157
158	assert.True(t, ui.pages.HasPage("help"))
159
160	ui.help.Draw(simScreen)
161	simScreen.Show()
162
163	// printScreen(simScreen)
164
165	b, _, _ := simScreen.GetContents()
166
167	cells := b[607 : 607+9]
168
169	text := []byte("directory")
170	for i, r := range cells {
171		assert.Equal(t, text[i], r.Bytes[0])
172	}
173}
174
175func TestHelpBw(t *testing.T) {
176	app, simScreen := testapp.CreateTestAppWithSimScreen(50, 50)
177	defer simScreen.Fini()
178
179	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
180	ui.showHelp()
181	ui.help.Draw(simScreen)
182	simScreen.Show()
183
184	// printScreen(simScreen)
185
186	b, _, _ := simScreen.GetContents()
187
188	cells := b[607 : 607+9]
189
190	text := []byte("directory")
191	for i, r := range cells {
192		assert.Equal(t, text[i], r.Bytes[0])
193	}
194}
195
196func TestAppRun(t *testing.T) {
197	simScreen := testapp.CreateSimScreen()
198	defer simScreen.Fini()
199
200	app := testapp.CreateMockedApp(false)
201	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
202
203	err := ui.StartUILoop()
204
205	assert.Nil(t, err)
206}
207
208func TestUILoopReturnsWithPendingSignal(t *testing.T) {
209	simScreen := testapp.CreateSimScreen()
210	assert.NoError(t, simScreen.Init())
211	defer simScreen.Fini()
212	screen := &failOnceSignalScreen{
213		Screen:    simScreen,
214		attempted: make(chan struct{}),
215		fail:      true,
216	}
217	app := &signalLifecycleApp{
218		MockedApp:       testapp.CreateMockedApp(false).(*testapp.MockedApp),
219		signalAttempted: screen.attempted,
220	}
221	ui := CreateUI(app, screen, &bytes.Buffer{}, false, true, false, false)
222	signals := make(chan os.Signal, 1)
223	signals <- os.Interrupt
224
225	result := make(chan error, 1)
226	go func() {
227		result <- ui.runUILoop(signals)
228	}()
229
230	select {
231	case err := <-result:
232		assert.NoError(t, err)
233	case <-time.After(time.Second):
234		t.Fatal("UI loop did not stop its signal listener")
235	}
236}
237
238func TestAppRunWithErr(t *testing.T) {
239	simScreen := testapp.CreateSimScreen()
240	defer simScreen.Fini()
241
242	app := testapp.CreateMockedApp(true)
243	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
244
245	err := ui.StartUILoop()
246
247	assert.Equal(t, "Fail", err.Error())
248}
249
250func TestRescanDir(t *testing.T) {
251	parentDir := &analyze.Dir{
252		File: &analyze.File{
253			Name: "parent",
254		},
255		Files: make([]fs.Item, 0, 1),
256	}
257	currentDir := &analyze.Dir{
258		File: &analyze.File{
259			Name:   "sub",
260			Parent: parentDir,
261		},
262	}
263
264	simScreen := testapp.CreateSimScreen()
265	defer simScreen.Fini()
266	app := testapp.CreateMockedApp(true)
267	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
268	ui.done = make(chan struct{})
269	ui.Analyzer = &testanalyze.MockedAnalyzer{}
270	ui.currentDir = currentDir
271	ui.topDir = parentDir
272	ui.rescanDir()
273
274	<-ui.done // wait for analyzer
275
276	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
277		f()
278	}
279
280	assert.Equal(t, "test_dir", ui.currentDir.GetName())
281	assert.Equal(t, parentDir, ui.currentDir.GetParent())
282
283	assert.Equal(t, 5, ui.table.GetRowCount())
284	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
285	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ddd")
286}
287
288func TestDirSelected(t *testing.T) {
289	fin := testdir.CreateTestDir()
290	defer fin()
291
292	ui := getAnalyzedPathMockedApp(t, true, false, false)
293	ui.done = make(chan struct{})
294
295	ui.fileItemSelected(0, 0)
296
297	assert.Equal(t, 3, ui.table.GetRowCount())
298	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
299	assert.Contains(t, ui.table.GetCell(1, 0).Text, "subnested")
300}
301
302func TestFileSelected(t *testing.T) {
303	ui := getAnalyzedPathMockedApp(t, true, true, true)
304
305	ui.fileItemSelected(0, 0) // does nothing, since it's a file
306
307	assert.Equal(t, 4, ui.table.GetRowCount())
308	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ccc")
309}
310
311func TestSelectedWithoutCurrentDir(t *testing.T) {
312	simScreen := testapp.CreateSimScreen()
313	defer simScreen.Fini()
314
315	app := testapp.CreateMockedApp(true)
316	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
317
318	ui.fileItemSelected(1, 0)
319
320	assert.Nil(t, ui.currentDir)
321}
322
323func TestBeforeDraw(t *testing.T) {
324	screen := tcell.NewSimulationScreen("UTF-8")
325	err := screen.Init()
326
327	assert.Nil(t, err)
328
329	app := testapp.CreateMockedApp(true)
330	ui := CreateUI(app, screen, &bytes.Buffer{}, false, true, false, false)
331
332	for _, f := range ui.app.(*testapp.MockedApp).BeforeDraws {
333		assert.False(t, f(screen))
334	}
335}
336
337func TestIgnorePaths(t *testing.T) {
338	simScreen := testapp.CreateSimScreen()
339	defer simScreen.Fini()
340
341	app := testapp.CreateMockedApp(true)
342	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
343
344	ui.SetIgnoreDirPaths([]string{"/aaa", "/bbb"})
345
346	assert.True(t, ui.ShouldDirBeIgnored("aaa", "/aaa"))
347	assert.True(t, ui.ShouldDirBeIgnored("bbb", "/bbb"))
348	assert.False(t, ui.ShouldDirBeIgnored("ccc", "/ccc"))
349}
350
351func TestConfirmDeletion(t *testing.T) {
352	ui := getAnalyzedPathMockedApp(t, true, true, true)
353
354	ui.table.Select(1, 0)
355	ui.confirmDeletion(ActionDelete)
356
357	assert.True(t, ui.pages.HasPage("confirm"))
358}
359
360func TestConfirmDeletionBW(t *testing.T) {
361	ui := getAnalyzedPathMockedApp(t, false, true, true)
362
363	ui.table.Select(1, 0)
364	ui.confirmDeletion(ActionDelete)
365
366	assert.True(t, ui.pages.HasPage("confirm"))
367}
368
369func TestConfirmEmpty(t *testing.T) {
370	ui := getAnalyzedPathMockedApp(t, false, true, true)
371
372	ui.table.Select(1, 0)
373	ui.confirmDeletion(ActionEmpty)
374
375	assert.True(t, ui.pages.HasPage("confirm"))
376}
377
378func TestConfirmEmptyMarked(t *testing.T) {
379	ui := getAnalyzedPathMockedApp(t, false, true, true)
380
381	ui.table.Select(1, 0)
382	ui.markedRows[1] = struct{}{}
383	ui.confirmDeletion(ActionEmpty)
384
385	assert.True(t, ui.pages.HasPage("confirm"))
386}
387
388func TestConfirmDeletionMarked(t *testing.T) {
389	ui := getAnalyzedPathMockedApp(t, true, true, true)
390
391	ui.table.Select(1, 0)
392	ui.markedRows[1] = struct{}{}
393	ui.confirmDeletion(ActionDelete)
394
395	assert.True(t, ui.pages.HasPage("confirm"))
396}
397
398func TestConfirmDeletionMarkedBW(t *testing.T) {
399	ui := getAnalyzedPathMockedApp(t, false, true, true)
400
401	ui.table.Select(1, 0)
402	ui.markedRows[1] = struct{}{}
403	ui.confirmDeletion(ActionDelete)
404
405	assert.True(t, ui.pages.HasPage("confirm"))
406}
407
408func TestDeleteSelected(t *testing.T) {
409	fin := testdir.CreateTestDir()
410	defer fin()
411
412	ui := getAnalyzedPathMockedApp(t, false, true, false)
413	ui.done = make(chan struct{})
414
415	assert.Equal(t, 1, ui.table.GetRowCount())
416
417	ui.table.Select(0, 0)
418
419	ui.deleteSelected(ActionDelete)
420
421	<-ui.done
422
423	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
424		f()
425	}
426
427	assert.NoDirExists(t, "test_dir/nested")
428}
429
430func TestDeleteSelectedInParallel(t *testing.T) {
431	fin := testdir.CreateTestDir()
432	defer fin()
433
434	ui := getAnalyzedPathMockedApp(t, false, true, false)
435	ui.done = make(chan struct{})
436	ui.SetDeleteInParallel()
437
438	assert.Equal(t, 1, ui.table.GetRowCount())
439
440	ui.table.Select(0, 0)
441
442	ui.deleteSelected(ActionDelete)
443
444	<-ui.done
445
446	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
447		f()
448	}
449
450	assert.NoDirExists(t, "test_dir/nested")
451}
452
453func TestDeleteSelectedInBackground(t *testing.T) {
454	fin := testdir.CreateTestDir()
455	defer fin()
456
457	ui := getAnalyzedPathMockedApp(t, true, true, false)
458	ui.remover = testanalyze.ItemFromDirWithSleep
459	ui.done = make(chan struct{})
460	ui.SetDeleteInBackground()
461
462	assert.Equal(t, 1, ui.table.GetRowCount())
463
464	ui.table.Select(0, 0)
465
466	ui.deleteSelected(ActionDelete)
467
468	<-ui.done
469
470	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
471		f()
472	}
473
474	assert.NoDirExists(t, "test_dir/nested")
475}
476
477func TestMoveToTrashSelectedInBackground(t *testing.T) {
478	fin := testdir.CreateTestDir()
479	defer fin()
480
481	ui := getAnalyzedPathMockedApp(t, true, true, false)
482	ui.done = make(chan struct{})
483	ui.SetDeleteInBackground()
484	var trashed string
485	ui.trasher = func(dir, item fs.Item) error {
486		trashed = item.GetName()
487		dir.RemoveFile(item)
488		return nil
489	}
490
491	assert.Equal(t, 1, ui.table.GetRowCount())
492	ui.table.Select(0, 0)
493	ui.deleteSelected(ActionMoveToTrash)
494
495	<-ui.done
496
497	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
498		f()
499	}
500
501	assert.Equal(t, "nested", trashed)
502	assert.Equal(t, 0, ui.table.GetRowCount())
503}
504
505func TestDeleteSelectedInBackgroundAndParallel(t *testing.T) {
506	fin := testdir.CreateTestDir()
507	defer fin()
508
509	ui := getAnalyzedPathMockedApp(t, true, true, false)
510	ui.remover = testanalyze.ItemFromDirWithSleep
511	ui.done = make(chan struct{})
512	ui.SetDeleteInBackground()
513	ui.SetDeleteInParallel()
514
515	assert.Equal(t, 1, ui.table.GetRowCount())
516
517	ui.table.Select(0, 0)
518
519	ui.deleteSelected(ActionDelete)
520
521	<-ui.done
522
523	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
524		f()
525	}
526
527	assert.NoDirExists(t, "test_dir/nested")
528}
529
530func TestDeleteSelectedInBackgroundBW(t *testing.T) {
531	fin := testdir.CreateTestDir()
532	defer fin()
533
534	ui := getAnalyzedPathMockedApp(t, false, true, false)
535	ui.done = make(chan struct{})
536	ui.SetDeleteInBackground()
537
538	assert.Equal(t, 1, ui.table.GetRowCount())
539
540	ui.table.Select(0, 0)
541
542	ui.deleteSelected(ActionDelete)
543
544	<-ui.done
545
546	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
547		f()
548	}
549
550	assert.NoDirExists(t, "test_dir/nested")
551}
552
553func TestEmptyDirInBackground(t *testing.T) {
554	fin := testdir.CreateTestDir()
555	defer fin()
556
557	ui := getAnalyzedPathMockedApp(t, true, true, false)
558	ui.done = make(chan struct{})
559	ui.SetDeleteInBackground()
560
561	assert.Equal(t, 1, ui.table.GetRowCount())
562
563	ui.table.Select(0, 0)
564
565	ui.deleteSelected(ActionEmpty)
566
567	<-ui.done
568
569	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
570		f()
571	}
572
573	assert.DirExists(t, "test_dir/nested")
574	assert.NoDirExists(t, "test_dir/nested/subnested")
575}
576
577func TestEmptyFileInBackground(t *testing.T) {
578	fin := testdir.CreateTestDir()
579	defer fin()
580
581	ui := getAnalyzedPathMockedApp(t, true, true, false)
582	ui.done = make(chan struct{})
583	ui.SetDeleteInBackground()
584
585	assert.Equal(t, 1, ui.table.GetRowCount())
586
587	ui.fileItemSelected(0, 0) // nested
588	ui.table.Select(2, 0)
589
590	ui.deleteSelected(ActionEmpty)
591
592	<-ui.done
593
594	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
595		f()
596	}
597
598	assert.DirExists(t, "test_dir/nested")
599	assert.FileExists(t, "test_dir/nested/file2")
600
601	f, err := os.Open("test_dir/nested/file2")
602	assert.Nil(t, err)
603	info, err := f.Stat()
604	assert.Nil(t, err)
605	assert.Equal(t, int64(0), info.Size())
606}
607
608func TestDeleteSelectedWithErr(t *testing.T) {
609	fin := testdir.CreateTestDir()
610	defer fin()
611
612	ui := getAnalyzedPathMockedApp(t, false, true, false)
613	ui.remover = testanalyze.ItemFromDirWithErr
614
615	assert.Equal(t, 1, ui.table.GetRowCount())
616
617	ui.table.Select(0, 0)
618
619	ui.delete(ActionDelete)
620
621	<-ui.done
622
623	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
624		f()
625	}
626
627	assert.True(t, ui.pages.HasPage("error"))
628	assert.DirExists(t, "test_dir/nested")
629}
630
631func TestDeleteSelectedInBackgroundWithErr(t *testing.T) {
632	fin := testdir.CreateTestDir()
633	defer fin()
634
635	ui := getAnalyzedPathMockedApp(t, false, true, false)
636	ui.SetDeleteInBackground()
637	ui.remover = testanalyze.ItemFromDirWithSleepAndErr
638
639	assert.Equal(t, 1, ui.table.GetRowCount())
640
641	ui.table.Select(0, 0)
642
643	ui.delete(ActionDelete)
644
645	<-ui.done
646
647	// change the status
648	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
649		f()
650	}
651
652	// wait for status to be removed
653	time.Sleep(500 * time.Millisecond)
654
655	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
656		f()
657	}
658
659	assert.True(t, ui.pages.HasPage("error"))
660	assert.DirExists(t, "test_dir/nested")
661}
662
663func TestDeleteMarkedWithErr(t *testing.T) {
664	fin := testdir.CreateTestDir()
665	defer fin()
666
667	ui := getAnalyzedPathMockedApp(t, false, true, false)
668	ui.remover = testanalyze.ItemFromDirWithErr
669
670	assert.Equal(t, 1, ui.table.GetRowCount())
671
672	ui.table.Select(0, 0)
673	ui.markedRows[0] = struct{}{}
674
675	ui.deleteMarked(ActionDelete)
676
677	<-ui.done
678
679	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
680		f()
681	}
682
683	assert.True(t, ui.pages.HasPage("error"))
684	assert.DirExists(t, "test_dir/nested")
685}
686
687func TestDeleteMarkedInBackground(t *testing.T) {
688	fin := testdir.CreateTestDir()
689	defer fin()
690
691	ui := getAnalyzedPathMockedApp(t, false, true, false)
692	ui.SetDeleteInBackground()
693
694	assert.Equal(t, 1, ui.table.GetRowCount())
695
696	ui.fileItemSelected(0, 0) // nested
697
698	ui.markedRows[1] = struct{}{} // subnested
699	ui.markedRows[2] = struct{}{} // file2
700
701	ui.deleteMarked(ActionDelete)
702
703	<-ui.done // wait for deletion of subnested
704	<-ui.done // wait for deletion of file2
705
706	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
707		f()
708	}
709
710	assert.DirExists(t, "test_dir/nested")
711	assert.NoDirExists(t, "test_dir/nested/subnested")
712	assert.NoFileExists(t, "test_dir/nested/file2")
713}
714
715func TestDeleteMarkedInBackgroundWithStorage(t *testing.T) {
716	fin := testdir.CreateTestDir()
717	defer fin()
718
719	ui := getAnalyzedPathMockedApp(t, false, true, false)
720	ui.SetAnalyzer(analyze.CreateStoredAnalyzer("/tmp/badger"))
721	ui.SetDeleteInBackground()
722
723	assert.Equal(t, 1, ui.table.GetRowCount())
724
725	ui.fileItemSelected(0, 0) // nested
726
727	ui.markedRows[1] = struct{}{} // subnested
728	ui.markedRows[2] = struct{}{} // file2
729
730	ui.deleteMarked(ActionDelete)
731
732	<-ui.done // wait for deletion of subnested
733	<-ui.done // wait for deletion of file2
734
735	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
736		f()
737	}
738
739	assert.DirExists(t, "test_dir/nested")
740	assert.NoDirExists(t, "test_dir/nested/subnested")
741	assert.NoFileExists(t, "test_dir/nested/file2")
742}
743
744func TestDeleteMarkedInBackgroundWithStorageAndParallel(t *testing.T) {
745	fin := testdir.CreateTestDir()
746	defer fin()
747
748	ui := getAnalyzedPathMockedApp(t, false, true, false)
749	ui.SetAnalyzer(analyze.CreateStoredAnalyzer("/tmp/badger"))
750	ui.SetDeleteInBackground()
751	ui.SetDeleteInParallel()
752
753	assert.Equal(t, 1, ui.table.GetRowCount())
754
755	ui.fileItemSelected(0, 0) // nested
756
757	ui.markedRows[1] = struct{}{} // subnested
758	ui.markedRows[2] = struct{}{} // file2
759
760	ui.deleteMarked(ActionDelete)
761
762	<-ui.done // wait for deletion of subnested
763	<-ui.done // wait for deletion of file2
764
765	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
766		f()
767	}
768
769	assert.DirExists(t, "test_dir/nested")
770	assert.NoDirExists(t, "test_dir/nested/subnested")
771	assert.NoFileExists(t, "test_dir/nested/file2")
772}
773
774func TestDeleteMarkedInBackgroundWithErr(t *testing.T) {
775	fin := testdir.CreateTestDir()
776	defer fin()
777
778	ui := getAnalyzedPathMockedApp(t, false, true, false)
779	ui.SetDeleteInBackground()
780	ui.remover = testanalyze.ItemFromDirWithErr
781
782	assert.Equal(t, 1, ui.table.GetRowCount())
783
784	ui.table.Select(0, 0)
785	ui.markedRows[0] = struct{}{}
786
787	ui.deleteMarked(ActionDelete)
788
789	<-ui.done
790
791	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
792		f()
793	}
794
795	assert.True(t, ui.pages.HasPage("error"))
796	assert.DirExists(t, "test_dir/nested")
797}
798
799func TestShowErr(t *testing.T) {
800	simScreen := testapp.CreateSimScreen()
801	defer simScreen.Fini()
802
803	app := testapp.CreateMockedApp(true)
804	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
805
806	ui.showErr("Something went wrong", errors.New("error"))
807
808	assert.True(t, ui.pages.HasPage("error"))
809}
810
811func TestShowErrBW(t *testing.T) {
812	simScreen := testapp.CreateSimScreen()
813	defer simScreen.Fini()
814
815	app := testapp.CreateMockedApp(true)
816	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
817
818	ui.showErr("Something went wrong", errors.New("error"))
819
820	assert.True(t, ui.pages.HasPage("error"))
821}
822
823func TestMin(t *testing.T) {
824	assert.Equal(t, 2, min(2, 5))
825	assert.Equal(t, 3, min(4, 3))
826}
827
828func TestSetStyles(t *testing.T) {
829	simScreen := testapp.CreateSimScreen()
830	defer simScreen.Fini()
831
832	opts := []Option{}
833	opts = append(opts, func(ui *UI) {
834		ui.SetHeaderHidden()
835	})
836
837	app := testapp.CreateMockedApp(true)
838	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false, opts...)
839
840	ui.SetSelectedBackgroundColor(tcell.ColorRed)
841	ui.SetSelectedTextColor(tcell.ColorRed)
842	ui.SetMarkedTextColor(tcell.ColorRed)
843	ui.SetMarkedBackgroundColor(tcell.ColorRed)
844	ui.SetFooterTextColor("red")
845	ui.SetFooterBackgroundColor("red")
846	ui.SetFooterNumberColor("red")
847	ui.SetHeaderTextColor("red")
848	ui.SetHeaderBackgroundColor("red")
849	ui.SetResultRowDirectoryColor("red")
850	ui.SetResultRowNumberColor("red")
851
852	assert.Equal(t, ui.selectedBackgroundColor, tcell.ColorRed)
853	assert.Equal(t, ui.selectedTextColor, tcell.ColorRed)
854	assert.Equal(t, ui.markedTextColor, tcell.ColorRed)
855	assert.Equal(t, ui.markedBackgroundColor, tcell.ColorRed)
856	assert.Equal(t, ui.footerTextColor, "red")
857	assert.Equal(t, ui.footerBackgroundColor, "red")
858	assert.Equal(t, ui.footerNumberColor, "red")
859	assert.Equal(t, ui.headerTextColor, "red")
860	assert.Equal(t, ui.headerBackgroundColor, "red")
861	assert.Equal(t, ui.headerHidden, true)
862	assert.Equal(t, ui.resultRow.DirectoryColor, "red")
863	assert.Equal(t, ui.resultRow.NumberColor, "red")
864}
865
866func TestSetCurrentItemNameMaxLen(t *testing.T) {
867	simScreen := testapp.CreateSimScreen()
868	defer simScreen.Fini()
869
870	app := testapp.CreateMockedApp(true)
871	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
872
873	ui.SetCurrentItemNameMaxLen(5)
874
875	assert.Equal(t, ui.currentItemNameMaxLen, 5)
876}
877
878func TestUseOldSizeBar(t *testing.T) {
879	simScreen := testapp.CreateSimScreen()
880	defer simScreen.Fini()
881
882	app := testapp.CreateMockedApp(true)
883	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
884
885	ui.UseOldSizeBar()
886
887	assert.Equal(t, ui.useOldSizeBar, true)
888}
889
890func TestSetShowBarPercentage(t *testing.T) {
891	simScreen := testapp.CreateSimScreen()
892	defer simScreen.Fini()
893
894	app := testapp.CreateMockedApp(true)
895	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
896
897	ui.SetShowBarPercentage()
898
899	assert.Equal(t, ui.showBarPercentage, true)
900}
901
902func TestSetShowItemCount(t *testing.T) {
903	simScreen := testapp.CreateSimScreen()
904	defer simScreen.Fini()
905
906	app := testapp.CreateMockedApp(true)
907	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
908
909	ui.SetShowItemCount()
910
911	assert.Equal(t, ui.showItemCount, true)
912}
913
914func TestSetShowItemCountBar(t *testing.T) {
915	simScreen := testapp.CreateSimScreen()
916	defer simScreen.Fini()
917
918	app := testapp.CreateMockedApp(true)
919	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
920
921	assert.Equal(t, ui.showItemCountBar, false)
922
923	ui.SetShowItemCountBar()
924
925	assert.Equal(t, ui.showItemCountBar, true)
926}
927
928func TestSetShowMTime(t *testing.T) {
929	simScreen := testapp.CreateSimScreen()
930	defer simScreen.Fini()
931
932	app := testapp.CreateMockedApp(true)
933	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
934
935	ui.SetShowMTime()
936
937	assert.Equal(t, ui.showMtime, true)
938}
939
940func TestNoDelete(t *testing.T) {
941	simScreen := testapp.CreateSimScreen()
942	defer simScreen.Fini()
943
944	app := testapp.CreateMockedApp(true)
945	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
946
947	ui.SetNoDelete()
948
949	assert.Equal(t, ui.noDelete, true)
950}
951
952func TestNoSpawnShell(t *testing.T) {
953	simScreen := testapp.CreateSimScreen()
954	defer simScreen.Fini()
955
956	app := testapp.CreateMockedApp(true)
957	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
958
959	ui.SetNoSpawnShell()
960
961	assert.Equal(t, ui.noSpawnShell, true)
962}
963
964func TestNoViewFile(t *testing.T) {
965	simScreen := testapp.CreateSimScreen()
966	defer simScreen.Fini()
967
968	app := testapp.CreateMockedApp(true)
969	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
970
971	ui.SetNoViewFile()
972
973	assert.Equal(t, ui.noViewFile, true)
974}
975
976// nolint: unused // Why: for debugging
977func printScreen(simScreen tcell.SimulationScreen) {
978	b, _, _ := simScreen.GetContents()
979
980	for i, r := range b {
981		if string(r.Bytes) != " " {
982			println(i, string(r.Bytes))
983		}
984	}
985}
986
987func getDevicesInfoMock() device.DevicesInfoGetter {
988	item := &device.Device{
989		Name:       "/dev/root",
990		MountPoint: "test_dir",
991		Size:       1e12,
992		Free:       1e6,
993	}
994	item2 := &device.Device{
995		Name:       "/dev/boot",
996		MountPoint: "/boot",
997		Size:       1e6,
998		Free:       1e3,
999	}
1000
1001	mock := testdev.DevicesInfoGetterMock{}
1002	mock.Devices = []*device.Device{item, item2}
1003	return mock
1004}
1005
1006func getAnalyzedPathMockedApp(t *testing.T, useColors, apparentSize, mockedAnalyzer bool) *UI {
1007	simScreen := testapp.CreateSimScreen()
1008	defer simScreen.Fini()
1009
1010	app := testapp.CreateMockedApp(true)
1011	ui := CreateUI(app, simScreen, &bytes.Buffer{}, useColors, apparentSize, false, false)
1012
1013	if mockedAnalyzer {
1014		ui.Analyzer = &testanalyze.MockedAnalyzer{}
1015	}
1016	ui.done = make(chan struct{})
1017	err := ui.AnalyzePath("test_dir", nil)
1018	assert.Nil(t, err)
1019
1020	<-ui.done // wait for analyzer
1021
1022	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1023		f()
1024	}
1025
1026	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1027
1028	return ui
1029}
1030
1031func TestConfirmDeletionSelectedButtonOrder(t *testing.T) {
1032	ui := getAnalyzedPathMockedApp(t, true, true, true)
1033
1034	ui.table.Select(1, 0)
1035	ui.confirmDeletionSelected(ActionDelete)
1036
1037	// Verify confirmation page is created
1038	assert.True(t, ui.pages.HasPage("confirm"))
1039}
1040
1041func selectConfirmationYes(t *testing.T, ui *UI) {
1042	t.Helper()
1043	_, primitive := ui.pages.GetFrontPage()
1044	modal, ok := primitive.(*tview.Modal)
1045	if !assert.True(t, ok) {
1046		return
1047	}
1048	var setFocus func(tview.Primitive)
1049	setFocus = func(p tview.Primitive) {
1050		p.Focus(setFocus)
1051	}
1052	modal.SetFocus(1)
1053	modal.Focus(setFocus)
1054	modal.InputHandler()(tcell.NewEventKey(tcell.KeyEnter, 0, 0), setFocus)
1055}
1056
1057func TestConfirmMoveToTrashSelectedYes(t *testing.T) {
1058	fin := testdir.CreateTestDir()
1059	defer fin()
1060
1061	ui := getAnalyzedPathMockedApp(t, true, true, false)
1062	ui.done = make(chan struct{})
1063	var trashed string
1064	ui.trasher = func(dir, item fs.Item) error {
1065		trashed = item.GetName()
1066		dir.RemoveFile(item)
1067		return nil
1068	}
1069	ui.table.Select(0, 0)
1070	selected := ui.table.GetCell(0, 0).GetReference().(fs.Item).GetName()
1071
1072	ui.confirmDeletionSelected(ActionMoveToTrash)
1073	selectConfirmationYes(t, ui)
1074	<-ui.done
1075
1076	assert.Equal(t, selected, trashed)
1077}
1078
1079func TestConfirmMoveToTrashMarkedYes(t *testing.T) {
1080	fin := testdir.CreateTestDir()
1081	defer fin()
1082
1083	ui := getAnalyzedPathMockedApp(t, true, true, false)
1084	ui.done = make(chan struct{})
1085	var trashed string
1086	ui.trasher = func(dir, item fs.Item) error {
1087		trashed = item.GetName()
1088		dir.RemoveFile(item)
1089		return nil
1090	}
1091	ui.markedRows[0] = struct{}{}
1092
1093	ui.confirmDeletionMarked(ActionMoveToTrash)
1094	selectConfirmationYes(t, ui)
1095	<-ui.done
1096
1097	assert.Equal(t, "nested", trashed)
1098}
1099
1100func TestConfirmDeletionSelectedSafeDefault(t *testing.T) {
1101	fin := testdir.CreateTestDir()
1102	defer fin()
1103
1104	ui := getAnalyzedPathMockedApp(t, false, true, false)
1105	ui.done = make(chan struct{})
1106
1107	assert.Equal(t, 1, ui.table.GetRowCount())
1108	ui.table.Select(0, 0)
1109
1110	// Create confirmation dialog
1111	ui.confirmDeletionSelected(ActionDelete)
1112
1113	// Verify that the confirmation dialog exists with safer defaults
1114	assert.DirExists(t, "test_dir/nested")
1115	assert.True(t, ui.pages.HasPage("confirm"))
1116}
1117
1118func TestConfirmDeletionButtonIndexMapping(t *testing.T) {
1119	fin := testdir.CreateTestDir()
1120	defer fin()
1121
1122	ui := getAnalyzedPathMockedApp(t, false, true, false)
1123	ui.done = make(chan struct{})
1124	ui.askBeforeDelete = false // Skip confirmation for direct testing
1125
1126	assert.Equal(t, 1, ui.table.GetRowCount())
1127	ui.table.Select(0, 0)
1128
1129	// Test that deletion still works when explicitly called
1130	ui.deleteSelected(ActionDelete)
1131
1132	<-ui.done
1133
1134	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1135		f()
1136	}
1137
1138	assert.NoDirExists(t, "test_dir/nested")
1139}
1140
1141func TestConfirmEmptySelectedSafeDefault(t *testing.T) {
1142	ui := getAnalyzedPathMockedApp(t, true, true, true)
1143
1144	ui.table.Select(1, 0)
1145	ui.confirmDeletionSelected(ActionEmpty)
1146
1147	// Verify empty confirmation dialog is created safely
1148	assert.True(t, ui.pages.HasPage("confirm"))
1149}
1150
1151func TestConfirmDeletionMarkedSafeDefault(t *testing.T) {
1152	ui := getAnalyzedPathMockedApp(t, true, true, true)
1153
1154	ui.table.Select(1, 0)
1155	ui.markedRows[1] = struct{}{}
1156	ui.confirmDeletionMarked(ActionDelete)
1157
1158	// Verify marked deletion confirmation dialog is created safely
1159	assert.True(t, ui.pages.HasPage("confirm"))
1160}
1161
1162func TestConfirmEmptyMarkedSafeDefault(t *testing.T) {
1163	ui := getAnalyzedPathMockedApp(t, false, true, true)
1164
1165	ui.table.Select(1, 0)
1166	ui.markedRows[1] = struct{}{}
1167	ui.confirmDeletionMarked(ActionEmpty)
1168
1169	// Verify marked empty confirmation dialog is created safely
1170	assert.True(t, ui.pages.HasPage("confirm"))
1171}
1172
1173func TestSaferConfirmationPreventDataLoss(t *testing.T) {
1174	fin := testdir.CreateTestDir()
1175	defer fin()
1176
1177	ui := getAnalyzedPathMockedApp(t, false, true, false)
1178
1179	assert.Equal(t, 1, ui.table.GetRowCount())
1180	ui.table.Select(0, 0)
1181
1182	// Test that creating confirmation dialog doesn't accidentally trigger deletion
1183	ui.confirmDeletionSelected(ActionDelete)
1184	ui.confirmDeletionSelected(ActionEmpty) // empty
1185
1186	// Directory should still exist - no accidental deletion
1187	assert.DirExists(t, "test_dir/nested")
1188	assert.True(t, ui.pages.HasPage("confirm"))
1189}
1190
1191func TestConfirmDeletionSelectedCase1(t *testing.T) {
1192	fin := testdir.CreateTestDir()
1193	defer fin()
1194
1195	ui := getAnalyzedPathMockedApp(t, false, true, false)
1196	ui.done = make(chan struct{})
1197
1198	assert.Equal(t, 1, ui.table.GetRowCount())
1199	ui.table.Select(0, 0)
1200
1201	// Test case 1 branch (yes button at index 1) by directly calling deleteSelected
1202	ui.deleteSelected(ActionDelete)
1203
1204	<-ui.done
1205
1206	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1207		f()
1208	}
1209
1210	assert.NoDirExists(t, "test_dir/nested")
1211}
1212
1213func TestConfirmDeletionMarkedCase1(t *testing.T) {
1214	fin := testdir.CreateTestDir()
1215	defer fin()
1216
1217	ui := getAnalyzedPathMockedApp(t, false, true, false)
1218	ui.done = make(chan struct{})
1219
1220	ui.fileItemSelected(0, 0)     // nested
1221	ui.markedRows[1] = struct{}{} // subnested
1222
1223	// Test case 1 branch (yes button at index 1) by directly calling deleteMarked
1224	ui.deleteMarked(ActionDelete)
1225
1226	<-ui.done
1227
1228	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1229		f()
1230	}
1231
1232	assert.NoDirExists(t, "test_dir/nested/subnested")
1233}