fork/gdu

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

cosmolifeat: move items to XDG trash with D key (#12) (#608)9ca5c60

subvolume
28.5 KiB1219 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 TestSetShowMTime(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	ui.SetShowMTime()
922
923	assert.Equal(t, ui.showMtime, true)
924}
925
926func TestNoDelete(t *testing.T) {
927	simScreen := testapp.CreateSimScreen()
928	defer simScreen.Fini()
929
930	app := testapp.CreateMockedApp(true)
931	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
932
933	ui.SetNoDelete()
934
935	assert.Equal(t, ui.noDelete, true)
936}
937
938func TestNoSpawnShell(t *testing.T) {
939	simScreen := testapp.CreateSimScreen()
940	defer simScreen.Fini()
941
942	app := testapp.CreateMockedApp(true)
943	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
944
945	ui.SetNoSpawnShell()
946
947	assert.Equal(t, ui.noSpawnShell, true)
948}
949
950func TestNoViewFile(t *testing.T) {
951	simScreen := testapp.CreateSimScreen()
952	defer simScreen.Fini()
953
954	app := testapp.CreateMockedApp(true)
955	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
956
957	ui.SetNoViewFile()
958
959	assert.Equal(t, ui.noViewFile, true)
960}
961
962// nolint: unused // Why: for debugging
963func printScreen(simScreen tcell.SimulationScreen) {
964	b, _, _ := simScreen.GetContents()
965
966	for i, r := range b {
967		if string(r.Bytes) != " " {
968			println(i, string(r.Bytes))
969		}
970	}
971}
972
973func getDevicesInfoMock() device.DevicesInfoGetter {
974	item := &device.Device{
975		Name:       "/dev/root",
976		MountPoint: "test_dir",
977		Size:       1e12,
978		Free:       1e6,
979	}
980	item2 := &device.Device{
981		Name:       "/dev/boot",
982		MountPoint: "/boot",
983		Size:       1e6,
984		Free:       1e3,
985	}
986
987	mock := testdev.DevicesInfoGetterMock{}
988	mock.Devices = []*device.Device{item, item2}
989	return mock
990}
991
992func getAnalyzedPathMockedApp(t *testing.T, useColors, apparentSize, mockedAnalyzer bool) *UI {
993	simScreen := testapp.CreateSimScreen()
994	defer simScreen.Fini()
995
996	app := testapp.CreateMockedApp(true)
997	ui := CreateUI(app, simScreen, &bytes.Buffer{}, useColors, apparentSize, false, false)
998
999	if mockedAnalyzer {
1000		ui.Analyzer = &testanalyze.MockedAnalyzer{}
1001	}
1002	ui.done = make(chan struct{})
1003	err := ui.AnalyzePath("test_dir", nil)
1004	assert.Nil(t, err)
1005
1006	<-ui.done // wait for analyzer
1007
1008	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1009		f()
1010	}
1011
1012	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1013
1014	return ui
1015}
1016
1017func TestConfirmDeletionSelectedButtonOrder(t *testing.T) {
1018	ui := getAnalyzedPathMockedApp(t, true, true, true)
1019
1020	ui.table.Select(1, 0)
1021	ui.confirmDeletionSelected(ActionDelete)
1022
1023	// Verify confirmation page is created
1024	assert.True(t, ui.pages.HasPage("confirm"))
1025}
1026
1027func selectConfirmationYes(t *testing.T, ui *UI) {
1028	t.Helper()
1029	_, primitive := ui.pages.GetFrontPage()
1030	modal, ok := primitive.(*tview.Modal)
1031	if !assert.True(t, ok) {
1032		return
1033	}
1034	var setFocus func(tview.Primitive)
1035	setFocus = func(p tview.Primitive) {
1036		p.Focus(setFocus)
1037	}
1038	modal.SetFocus(1)
1039	modal.Focus(setFocus)
1040	modal.InputHandler()(tcell.NewEventKey(tcell.KeyEnter, 0, 0), setFocus)
1041}
1042
1043func TestConfirmMoveToTrashSelectedYes(t *testing.T) {
1044	fin := testdir.CreateTestDir()
1045	defer fin()
1046
1047	ui := getAnalyzedPathMockedApp(t, true, true, false)
1048	ui.done = make(chan struct{})
1049	var trashed string
1050	ui.trasher = func(dir, item fs.Item) error {
1051		trashed = item.GetName()
1052		dir.RemoveFile(item)
1053		return nil
1054	}
1055	ui.table.Select(0, 0)
1056	selected := ui.table.GetCell(0, 0).GetReference().(fs.Item).GetName()
1057
1058	ui.confirmDeletionSelected(ActionMoveToTrash)
1059	selectConfirmationYes(t, ui)
1060	<-ui.done
1061
1062	assert.Equal(t, selected, trashed)
1063}
1064
1065func TestConfirmMoveToTrashMarkedYes(t *testing.T) {
1066	fin := testdir.CreateTestDir()
1067	defer fin()
1068
1069	ui := getAnalyzedPathMockedApp(t, true, true, false)
1070	ui.done = make(chan struct{})
1071	var trashed string
1072	ui.trasher = func(dir, item fs.Item) error {
1073		trashed = item.GetName()
1074		dir.RemoveFile(item)
1075		return nil
1076	}
1077	ui.markedRows[0] = struct{}{}
1078
1079	ui.confirmDeletionMarked(ActionMoveToTrash)
1080	selectConfirmationYes(t, ui)
1081	<-ui.done
1082
1083	assert.Equal(t, "nested", trashed)
1084}
1085
1086func TestConfirmDeletionSelectedSafeDefault(t *testing.T) {
1087	fin := testdir.CreateTestDir()
1088	defer fin()
1089
1090	ui := getAnalyzedPathMockedApp(t, false, true, false)
1091	ui.done = make(chan struct{})
1092
1093	assert.Equal(t, 1, ui.table.GetRowCount())
1094	ui.table.Select(0, 0)
1095
1096	// Create confirmation dialog
1097	ui.confirmDeletionSelected(ActionDelete)
1098
1099	// Verify that the confirmation dialog exists with safer defaults
1100	assert.DirExists(t, "test_dir/nested")
1101	assert.True(t, ui.pages.HasPage("confirm"))
1102}
1103
1104func TestConfirmDeletionButtonIndexMapping(t *testing.T) {
1105	fin := testdir.CreateTestDir()
1106	defer fin()
1107
1108	ui := getAnalyzedPathMockedApp(t, false, true, false)
1109	ui.done = make(chan struct{})
1110	ui.askBeforeDelete = false // Skip confirmation for direct testing
1111
1112	assert.Equal(t, 1, ui.table.GetRowCount())
1113	ui.table.Select(0, 0)
1114
1115	// Test that deletion still works when explicitly called
1116	ui.deleteSelected(ActionDelete)
1117
1118	<-ui.done
1119
1120	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1121		f()
1122	}
1123
1124	assert.NoDirExists(t, "test_dir/nested")
1125}
1126
1127func TestConfirmEmptySelectedSafeDefault(t *testing.T) {
1128	ui := getAnalyzedPathMockedApp(t, true, true, true)
1129
1130	ui.table.Select(1, 0)
1131	ui.confirmDeletionSelected(ActionEmpty)
1132
1133	// Verify empty confirmation dialog is created safely
1134	assert.True(t, ui.pages.HasPage("confirm"))
1135}
1136
1137func TestConfirmDeletionMarkedSafeDefault(t *testing.T) {
1138	ui := getAnalyzedPathMockedApp(t, true, true, true)
1139
1140	ui.table.Select(1, 0)
1141	ui.markedRows[1] = struct{}{}
1142	ui.confirmDeletionMarked(ActionDelete)
1143
1144	// Verify marked deletion confirmation dialog is created safely
1145	assert.True(t, ui.pages.HasPage("confirm"))
1146}
1147
1148func TestConfirmEmptyMarkedSafeDefault(t *testing.T) {
1149	ui := getAnalyzedPathMockedApp(t, false, true, true)
1150
1151	ui.table.Select(1, 0)
1152	ui.markedRows[1] = struct{}{}
1153	ui.confirmDeletionMarked(ActionEmpty)
1154
1155	// Verify marked empty confirmation dialog is created safely
1156	assert.True(t, ui.pages.HasPage("confirm"))
1157}
1158
1159func TestSaferConfirmationPreventDataLoss(t *testing.T) {
1160	fin := testdir.CreateTestDir()
1161	defer fin()
1162
1163	ui := getAnalyzedPathMockedApp(t, false, true, false)
1164
1165	assert.Equal(t, 1, ui.table.GetRowCount())
1166	ui.table.Select(0, 0)
1167
1168	// Test that creating confirmation dialog doesn't accidentally trigger deletion
1169	ui.confirmDeletionSelected(ActionDelete)
1170	ui.confirmDeletionSelected(ActionEmpty) // empty
1171
1172	// Directory should still exist - no accidental deletion
1173	assert.DirExists(t, "test_dir/nested")
1174	assert.True(t, ui.pages.HasPage("confirm"))
1175}
1176
1177func TestConfirmDeletionSelectedCase1(t *testing.T) {
1178	fin := testdir.CreateTestDir()
1179	defer fin()
1180
1181	ui := getAnalyzedPathMockedApp(t, false, true, false)
1182	ui.done = make(chan struct{})
1183
1184	assert.Equal(t, 1, ui.table.GetRowCount())
1185	ui.table.Select(0, 0)
1186
1187	// Test case 1 branch (yes button at index 1) by directly calling deleteSelected
1188	ui.deleteSelected(ActionDelete)
1189
1190	<-ui.done
1191
1192	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1193		f()
1194	}
1195
1196	assert.NoDirExists(t, "test_dir/nested")
1197}
1198
1199func TestConfirmDeletionMarkedCase1(t *testing.T) {
1200	fin := testdir.CreateTestDir()
1201	defer fin()
1202
1203	ui := getAnalyzedPathMockedApp(t, false, true, false)
1204	ui.done = make(chan struct{})
1205
1206	ui.fileItemSelected(0, 0)     // nested
1207	ui.markedRows[1] = struct{}{} // subnested
1208
1209	// Test case 1 branch (yes button at index 1) by directly calling deleteMarked
1210	ui.deleteMarked(ActionDelete)
1211
1212	<-ui.done
1213
1214	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1215		f()
1216	}
1217
1218	assert.NoDirExists(t, "test_dir/nested/subnested")
1219}