fork/gdu

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

Julia RyanRestore cursor pos on rescan98ee348

ignore
29.4 KiB1261 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 TestRescanDirRestoresCursorPosition(t *testing.T) {
289	parentDir := &analyze.Dir{
290		File: &analyze.File{
291			Name: "parent",
292		},
293		Files: make([]fs.Item, 0, 1),
294	}
295	currentDir := &analyze.Dir{
296		File: &analyze.File{
297			Name:   "sub",
298			Parent: parentDir,
299		},
300	}
301
302	simScreen := testapp.CreateSimScreen()
303	defer simScreen.Fini()
304	app := testapp.CreateMockedApp(true)
305	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
306	ui.done = make(chan struct{})
307	ui.Analyzer = &testanalyze.MockedAnalyzer{}
308	ui.currentDir = currentDir
309	ui.topDir = parentDir
310
311	ui.table.Select(2, 0)
312	ui.table.SetOffset(1, 0)
313
314	ui.rescanDir()
315
316	<-ui.done // wait for analyzer
317
318	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
319		f()
320	}
321
322	row, column := ui.table.GetSelection()
323	assert.Equal(t, 2, row)
324	assert.Equal(t, 0, column)
325
326	rowOffset, _ := ui.table.GetOffset()
327	assert.Equal(t, 1, rowOffset)
328}
329
330func TestDirSelected(t *testing.T) {
331	fin := testdir.CreateTestDir()
332	defer fin()
333
334	ui := getAnalyzedPathMockedApp(t, true, false, false)
335	ui.done = make(chan struct{})
336
337	ui.fileItemSelected(0, 0)
338
339	assert.Equal(t, 3, ui.table.GetRowCount())
340	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
341	assert.Contains(t, ui.table.GetCell(1, 0).Text, "subnested")
342}
343
344func TestFileSelected(t *testing.T) {
345	ui := getAnalyzedPathMockedApp(t, true, true, true)
346
347	ui.fileItemSelected(0, 0) // does nothing, since it's a file
348
349	assert.Equal(t, 4, ui.table.GetRowCount())
350	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ccc")
351}
352
353func TestSelectedWithoutCurrentDir(t *testing.T) {
354	simScreen := testapp.CreateSimScreen()
355	defer simScreen.Fini()
356
357	app := testapp.CreateMockedApp(true)
358	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
359
360	ui.fileItemSelected(1, 0)
361
362	assert.Nil(t, ui.currentDir)
363}
364
365func TestBeforeDraw(t *testing.T) {
366	screen := tcell.NewSimulationScreen("UTF-8")
367	err := screen.Init()
368
369	assert.Nil(t, err)
370
371	app := testapp.CreateMockedApp(true)
372	ui := CreateUI(app, screen, &bytes.Buffer{}, false, true, false, false)
373
374	for _, f := range ui.app.(*testapp.MockedApp).BeforeDraws {
375		assert.False(t, f(screen))
376	}
377}
378
379func TestIgnorePaths(t *testing.T) {
380	simScreen := testapp.CreateSimScreen()
381	defer simScreen.Fini()
382
383	app := testapp.CreateMockedApp(true)
384	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
385
386	ui.SetIgnoreDirPaths([]string{"/aaa", "/bbb"})
387
388	assert.True(t, ui.ShouldDirBeIgnored("aaa", "/aaa"))
389	assert.True(t, ui.ShouldDirBeIgnored("bbb", "/bbb"))
390	assert.False(t, ui.ShouldDirBeIgnored("ccc", "/ccc"))
391}
392
393func TestConfirmDeletion(t *testing.T) {
394	ui := getAnalyzedPathMockedApp(t, true, true, true)
395
396	ui.table.Select(1, 0)
397	ui.confirmDeletion(ActionDelete)
398
399	assert.True(t, ui.pages.HasPage("confirm"))
400}
401
402func TestConfirmDeletionBW(t *testing.T) {
403	ui := getAnalyzedPathMockedApp(t, false, true, true)
404
405	ui.table.Select(1, 0)
406	ui.confirmDeletion(ActionDelete)
407
408	assert.True(t, ui.pages.HasPage("confirm"))
409}
410
411func TestConfirmEmpty(t *testing.T) {
412	ui := getAnalyzedPathMockedApp(t, false, true, true)
413
414	ui.table.Select(1, 0)
415	ui.confirmDeletion(ActionEmpty)
416
417	assert.True(t, ui.pages.HasPage("confirm"))
418}
419
420func TestConfirmEmptyMarked(t *testing.T) {
421	ui := getAnalyzedPathMockedApp(t, false, true, true)
422
423	ui.table.Select(1, 0)
424	ui.markedRows[1] = struct{}{}
425	ui.confirmDeletion(ActionEmpty)
426
427	assert.True(t, ui.pages.HasPage("confirm"))
428}
429
430func TestConfirmDeletionMarked(t *testing.T) {
431	ui := getAnalyzedPathMockedApp(t, true, true, true)
432
433	ui.table.Select(1, 0)
434	ui.markedRows[1] = struct{}{}
435	ui.confirmDeletion(ActionDelete)
436
437	assert.True(t, ui.pages.HasPage("confirm"))
438}
439
440func TestConfirmDeletionMarkedBW(t *testing.T) {
441	ui := getAnalyzedPathMockedApp(t, false, true, true)
442
443	ui.table.Select(1, 0)
444	ui.markedRows[1] = struct{}{}
445	ui.confirmDeletion(ActionDelete)
446
447	assert.True(t, ui.pages.HasPage("confirm"))
448}
449
450func TestDeleteSelected(t *testing.T) {
451	fin := testdir.CreateTestDir()
452	defer fin()
453
454	ui := getAnalyzedPathMockedApp(t, false, true, false)
455	ui.done = make(chan struct{})
456
457	assert.Equal(t, 1, ui.table.GetRowCount())
458
459	ui.table.Select(0, 0)
460
461	ui.deleteSelected(ActionDelete)
462
463	<-ui.done
464
465	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
466		f()
467	}
468
469	assert.NoDirExists(t, "test_dir/nested")
470}
471
472func TestDeleteSelectedInParallel(t *testing.T) {
473	fin := testdir.CreateTestDir()
474	defer fin()
475
476	ui := getAnalyzedPathMockedApp(t, false, true, false)
477	ui.done = make(chan struct{})
478	ui.SetDeleteInParallel()
479
480	assert.Equal(t, 1, ui.table.GetRowCount())
481
482	ui.table.Select(0, 0)
483
484	ui.deleteSelected(ActionDelete)
485
486	<-ui.done
487
488	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
489		f()
490	}
491
492	assert.NoDirExists(t, "test_dir/nested")
493}
494
495func TestDeleteSelectedInBackground(t *testing.T) {
496	fin := testdir.CreateTestDir()
497	defer fin()
498
499	ui := getAnalyzedPathMockedApp(t, true, true, false)
500	ui.remover = testanalyze.ItemFromDirWithSleep
501	ui.done = make(chan struct{})
502	ui.SetDeleteInBackground()
503
504	assert.Equal(t, 1, ui.table.GetRowCount())
505
506	ui.table.Select(0, 0)
507
508	ui.deleteSelected(ActionDelete)
509
510	<-ui.done
511
512	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
513		f()
514	}
515
516	assert.NoDirExists(t, "test_dir/nested")
517}
518
519func TestMoveToTrashSelectedInBackground(t *testing.T) {
520	fin := testdir.CreateTestDir()
521	defer fin()
522
523	ui := getAnalyzedPathMockedApp(t, true, true, false)
524	ui.done = make(chan struct{})
525	ui.SetDeleteInBackground()
526	var trashed string
527	ui.trasher = func(dir, item fs.Item) error {
528		trashed = item.GetName()
529		dir.RemoveFile(item)
530		return nil
531	}
532
533	assert.Equal(t, 1, ui.table.GetRowCount())
534	ui.table.Select(0, 0)
535	ui.deleteSelected(ActionMoveToTrash)
536
537	<-ui.done
538
539	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
540		f()
541	}
542
543	assert.Equal(t, "nested", trashed)
544	assert.Equal(t, 0, ui.table.GetRowCount())
545}
546
547func TestDeleteSelectedInBackgroundAndParallel(t *testing.T) {
548	fin := testdir.CreateTestDir()
549	defer fin()
550
551	ui := getAnalyzedPathMockedApp(t, true, true, false)
552	ui.remover = testanalyze.ItemFromDirWithSleep
553	ui.done = make(chan struct{})
554	ui.SetDeleteInBackground()
555	ui.SetDeleteInParallel()
556
557	assert.Equal(t, 1, ui.table.GetRowCount())
558
559	ui.table.Select(0, 0)
560
561	ui.deleteSelected(ActionDelete)
562
563	<-ui.done
564
565	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
566		f()
567	}
568
569	assert.NoDirExists(t, "test_dir/nested")
570}
571
572func TestDeleteSelectedInBackgroundBW(t *testing.T) {
573	fin := testdir.CreateTestDir()
574	defer fin()
575
576	ui := getAnalyzedPathMockedApp(t, false, true, false)
577	ui.done = make(chan struct{})
578	ui.SetDeleteInBackground()
579
580	assert.Equal(t, 1, ui.table.GetRowCount())
581
582	ui.table.Select(0, 0)
583
584	ui.deleteSelected(ActionDelete)
585
586	<-ui.done
587
588	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
589		f()
590	}
591
592	assert.NoDirExists(t, "test_dir/nested")
593}
594
595func TestEmptyDirInBackground(t *testing.T) {
596	fin := testdir.CreateTestDir()
597	defer fin()
598
599	ui := getAnalyzedPathMockedApp(t, true, true, false)
600	ui.done = make(chan struct{})
601	ui.SetDeleteInBackground()
602
603	assert.Equal(t, 1, ui.table.GetRowCount())
604
605	ui.table.Select(0, 0)
606
607	ui.deleteSelected(ActionEmpty)
608
609	<-ui.done
610
611	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
612		f()
613	}
614
615	assert.DirExists(t, "test_dir/nested")
616	assert.NoDirExists(t, "test_dir/nested/subnested")
617}
618
619func TestEmptyFileInBackground(t *testing.T) {
620	fin := testdir.CreateTestDir()
621	defer fin()
622
623	ui := getAnalyzedPathMockedApp(t, true, true, false)
624	ui.done = make(chan struct{})
625	ui.SetDeleteInBackground()
626
627	assert.Equal(t, 1, ui.table.GetRowCount())
628
629	ui.fileItemSelected(0, 0) // nested
630	ui.table.Select(2, 0)
631
632	ui.deleteSelected(ActionEmpty)
633
634	<-ui.done
635
636	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
637		f()
638	}
639
640	assert.DirExists(t, "test_dir/nested")
641	assert.FileExists(t, "test_dir/nested/file2")
642
643	f, err := os.Open("test_dir/nested/file2")
644	assert.Nil(t, err)
645	info, err := f.Stat()
646	assert.Nil(t, err)
647	assert.Equal(t, int64(0), info.Size())
648}
649
650func TestDeleteSelectedWithErr(t *testing.T) {
651	fin := testdir.CreateTestDir()
652	defer fin()
653
654	ui := getAnalyzedPathMockedApp(t, false, true, false)
655	ui.remover = testanalyze.ItemFromDirWithErr
656
657	assert.Equal(t, 1, ui.table.GetRowCount())
658
659	ui.table.Select(0, 0)
660
661	ui.delete(ActionDelete)
662
663	<-ui.done
664
665	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
666		f()
667	}
668
669	assert.True(t, ui.pages.HasPage("error"))
670	assert.DirExists(t, "test_dir/nested")
671}
672
673func TestDeleteSelectedInBackgroundWithErr(t *testing.T) {
674	fin := testdir.CreateTestDir()
675	defer fin()
676
677	ui := getAnalyzedPathMockedApp(t, false, true, false)
678	ui.SetDeleteInBackground()
679	ui.remover = testanalyze.ItemFromDirWithSleepAndErr
680
681	assert.Equal(t, 1, ui.table.GetRowCount())
682
683	ui.table.Select(0, 0)
684
685	ui.delete(ActionDelete)
686
687	<-ui.done
688
689	// change the status
690	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
691		f()
692	}
693
694	// wait for status to be removed
695	time.Sleep(500 * time.Millisecond)
696
697	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
698		f()
699	}
700
701	assert.True(t, ui.pages.HasPage("error"))
702	assert.DirExists(t, "test_dir/nested")
703}
704
705func TestDeleteMarkedWithErr(t *testing.T) {
706	fin := testdir.CreateTestDir()
707	defer fin()
708
709	ui := getAnalyzedPathMockedApp(t, false, true, false)
710	ui.remover = testanalyze.ItemFromDirWithErr
711
712	assert.Equal(t, 1, ui.table.GetRowCount())
713
714	ui.table.Select(0, 0)
715	ui.markedRows[0] = struct{}{}
716
717	ui.deleteMarked(ActionDelete)
718
719	<-ui.done
720
721	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
722		f()
723	}
724
725	assert.True(t, ui.pages.HasPage("error"))
726	assert.DirExists(t, "test_dir/nested")
727}
728
729func TestDeleteMarkedInBackground(t *testing.T) {
730	fin := testdir.CreateTestDir()
731	defer fin()
732
733	ui := getAnalyzedPathMockedApp(t, false, true, false)
734	ui.SetDeleteInBackground()
735
736	assert.Equal(t, 1, ui.table.GetRowCount())
737
738	ui.fileItemSelected(0, 0) // nested
739
740	ui.markedRows[1] = struct{}{} // subnested
741	ui.markedRows[2] = struct{}{} // file2
742
743	ui.deleteMarked(ActionDelete)
744
745	<-ui.done // wait for deletion of subnested
746	<-ui.done // wait for deletion of file2
747
748	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
749		f()
750	}
751
752	assert.DirExists(t, "test_dir/nested")
753	assert.NoDirExists(t, "test_dir/nested/subnested")
754	assert.NoFileExists(t, "test_dir/nested/file2")
755}
756
757func TestDeleteMarkedInBackgroundWithStorage(t *testing.T) {
758	fin := testdir.CreateTestDir()
759	defer fin()
760
761	ui := getAnalyzedPathMockedApp(t, false, true, false)
762	ui.SetAnalyzer(analyze.CreateStoredAnalyzer("/tmp/badger"))
763	ui.SetDeleteInBackground()
764
765	assert.Equal(t, 1, ui.table.GetRowCount())
766
767	ui.fileItemSelected(0, 0) // nested
768
769	ui.markedRows[1] = struct{}{} // subnested
770	ui.markedRows[2] = struct{}{} // file2
771
772	ui.deleteMarked(ActionDelete)
773
774	<-ui.done // wait for deletion of subnested
775	<-ui.done // wait for deletion of file2
776
777	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
778		f()
779	}
780
781	assert.DirExists(t, "test_dir/nested")
782	assert.NoDirExists(t, "test_dir/nested/subnested")
783	assert.NoFileExists(t, "test_dir/nested/file2")
784}
785
786func TestDeleteMarkedInBackgroundWithStorageAndParallel(t *testing.T) {
787	fin := testdir.CreateTestDir()
788	defer fin()
789
790	ui := getAnalyzedPathMockedApp(t, false, true, false)
791	ui.SetAnalyzer(analyze.CreateStoredAnalyzer("/tmp/badger"))
792	ui.SetDeleteInBackground()
793	ui.SetDeleteInParallel()
794
795	assert.Equal(t, 1, ui.table.GetRowCount())
796
797	ui.fileItemSelected(0, 0) // nested
798
799	ui.markedRows[1] = struct{}{} // subnested
800	ui.markedRows[2] = struct{}{} // file2
801
802	ui.deleteMarked(ActionDelete)
803
804	<-ui.done // wait for deletion of subnested
805	<-ui.done // wait for deletion of file2
806
807	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
808		f()
809	}
810
811	assert.DirExists(t, "test_dir/nested")
812	assert.NoDirExists(t, "test_dir/nested/subnested")
813	assert.NoFileExists(t, "test_dir/nested/file2")
814}
815
816func TestDeleteMarkedInBackgroundWithErr(t *testing.T) {
817	fin := testdir.CreateTestDir()
818	defer fin()
819
820	ui := getAnalyzedPathMockedApp(t, false, true, false)
821	ui.SetDeleteInBackground()
822	ui.remover = testanalyze.ItemFromDirWithErr
823
824	assert.Equal(t, 1, ui.table.GetRowCount())
825
826	ui.table.Select(0, 0)
827	ui.markedRows[0] = struct{}{}
828
829	ui.deleteMarked(ActionDelete)
830
831	<-ui.done
832
833	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
834		f()
835	}
836
837	assert.True(t, ui.pages.HasPage("error"))
838	assert.DirExists(t, "test_dir/nested")
839}
840
841func TestShowErr(t *testing.T) {
842	simScreen := testapp.CreateSimScreen()
843	defer simScreen.Fini()
844
845	app := testapp.CreateMockedApp(true)
846	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
847
848	ui.showErr("Something went wrong", errors.New("error"))
849
850	assert.True(t, ui.pages.HasPage("error"))
851}
852
853func TestShowErrBW(t *testing.T) {
854	simScreen := testapp.CreateSimScreen()
855	defer simScreen.Fini()
856
857	app := testapp.CreateMockedApp(true)
858	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
859
860	ui.showErr("Something went wrong", errors.New("error"))
861
862	assert.True(t, ui.pages.HasPage("error"))
863}
864
865func TestMin(t *testing.T) {
866	assert.Equal(t, 2, min(2, 5))
867	assert.Equal(t, 3, min(4, 3))
868}
869
870func TestSetStyles(t *testing.T) {
871	simScreen := testapp.CreateSimScreen()
872	defer simScreen.Fini()
873
874	opts := []Option{}
875	opts = append(opts, func(ui *UI) {
876		ui.SetHeaderHidden()
877	})
878
879	app := testapp.CreateMockedApp(true)
880	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false, opts...)
881
882	ui.SetSelectedBackgroundColor(tcell.ColorRed)
883	ui.SetSelectedTextColor(tcell.ColorRed)
884	ui.SetMarkedTextColor(tcell.ColorRed)
885	ui.SetMarkedBackgroundColor(tcell.ColorRed)
886	ui.SetFooterTextColor("red")
887	ui.SetFooterBackgroundColor("red")
888	ui.SetFooterNumberColor("red")
889	ui.SetHeaderTextColor("red")
890	ui.SetHeaderBackgroundColor("red")
891	ui.SetResultRowDirectoryColor("red")
892	ui.SetResultRowNumberColor("red")
893
894	assert.Equal(t, ui.selectedBackgroundColor, tcell.ColorRed)
895	assert.Equal(t, ui.selectedTextColor, tcell.ColorRed)
896	assert.Equal(t, ui.markedTextColor, tcell.ColorRed)
897	assert.Equal(t, ui.markedBackgroundColor, tcell.ColorRed)
898	assert.Equal(t, ui.footerTextColor, "red")
899	assert.Equal(t, ui.footerBackgroundColor, "red")
900	assert.Equal(t, ui.footerNumberColor, "red")
901	assert.Equal(t, ui.headerTextColor, "red")
902	assert.Equal(t, ui.headerBackgroundColor, "red")
903	assert.Equal(t, ui.headerHidden, true)
904	assert.Equal(t, ui.resultRow.DirectoryColor, "red")
905	assert.Equal(t, ui.resultRow.NumberColor, "red")
906}
907
908func TestSetCurrentItemNameMaxLen(t *testing.T) {
909	simScreen := testapp.CreateSimScreen()
910	defer simScreen.Fini()
911
912	app := testapp.CreateMockedApp(true)
913	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
914
915	ui.SetCurrentItemNameMaxLen(5)
916
917	assert.Equal(t, ui.currentItemNameMaxLen, 5)
918}
919
920func TestUseOldSizeBar(t *testing.T) {
921	simScreen := testapp.CreateSimScreen()
922	defer simScreen.Fini()
923
924	app := testapp.CreateMockedApp(true)
925	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
926
927	ui.UseOldSizeBar()
928
929	assert.Equal(t, ui.useOldSizeBar, true)
930}
931
932func TestSetShowBarPercentage(t *testing.T) {
933	simScreen := testapp.CreateSimScreen()
934	defer simScreen.Fini()
935
936	app := testapp.CreateMockedApp(true)
937	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
938
939	ui.SetShowBarPercentage()
940
941	assert.Equal(t, ui.showBarPercentage, true)
942}
943
944func TestSetShowItemCount(t *testing.T) {
945	simScreen := testapp.CreateSimScreen()
946	defer simScreen.Fini()
947
948	app := testapp.CreateMockedApp(true)
949	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
950
951	ui.SetShowItemCount()
952
953	assert.Equal(t, ui.showItemCount, true)
954}
955
956func TestSetShowMTime(t *testing.T) {
957	simScreen := testapp.CreateSimScreen()
958	defer simScreen.Fini()
959
960	app := testapp.CreateMockedApp(true)
961	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
962
963	ui.SetShowMTime()
964
965	assert.Equal(t, ui.showMtime, true)
966}
967
968func TestNoDelete(t *testing.T) {
969	simScreen := testapp.CreateSimScreen()
970	defer simScreen.Fini()
971
972	app := testapp.CreateMockedApp(true)
973	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
974
975	ui.SetNoDelete()
976
977	assert.Equal(t, ui.noDelete, true)
978}
979
980func TestNoSpawnShell(t *testing.T) {
981	simScreen := testapp.CreateSimScreen()
982	defer simScreen.Fini()
983
984	app := testapp.CreateMockedApp(true)
985	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
986
987	ui.SetNoSpawnShell()
988
989	assert.Equal(t, ui.noSpawnShell, true)
990}
991
992func TestNoViewFile(t *testing.T) {
993	simScreen := testapp.CreateSimScreen()
994	defer simScreen.Fini()
995
996	app := testapp.CreateMockedApp(true)
997	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
998
999	ui.SetNoViewFile()
1000
1001	assert.Equal(t, ui.noViewFile, true)
1002}
1003
1004// nolint: unused // Why: for debugging
1005func printScreen(simScreen tcell.SimulationScreen) {
1006	b, _, _ := simScreen.GetContents()
1007
1008	for i, r := range b {
1009		if string(r.Bytes) != " " {
1010			println(i, string(r.Bytes))
1011		}
1012	}
1013}
1014
1015func getDevicesInfoMock() device.DevicesInfoGetter {
1016	item := &device.Device{
1017		Name:       "/dev/root",
1018		MountPoint: "test_dir",
1019		Size:       1e12,
1020		Free:       1e6,
1021	}
1022	item2 := &device.Device{
1023		Name:       "/dev/boot",
1024		MountPoint: "/boot",
1025		Size:       1e6,
1026		Free:       1e3,
1027	}
1028
1029	mock := testdev.DevicesInfoGetterMock{}
1030	mock.Devices = []*device.Device{item, item2}
1031	return mock
1032}
1033
1034func getAnalyzedPathMockedApp(t *testing.T, useColors, apparentSize, mockedAnalyzer bool) *UI {
1035	simScreen := testapp.CreateSimScreen()
1036	defer simScreen.Fini()
1037
1038	app := testapp.CreateMockedApp(true)
1039	ui := CreateUI(app, simScreen, &bytes.Buffer{}, useColors, apparentSize, false, false)
1040
1041	if mockedAnalyzer {
1042		ui.Analyzer = &testanalyze.MockedAnalyzer{}
1043	}
1044	ui.done = make(chan struct{})
1045	err := ui.AnalyzePath("test_dir", nil)
1046	assert.Nil(t, err)
1047
1048	<-ui.done // wait for analyzer
1049
1050	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1051		f()
1052	}
1053
1054	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1055
1056	return ui
1057}
1058
1059func TestConfirmDeletionSelectedButtonOrder(t *testing.T) {
1060	ui := getAnalyzedPathMockedApp(t, true, true, true)
1061
1062	ui.table.Select(1, 0)
1063	ui.confirmDeletionSelected(ActionDelete)
1064
1065	// Verify confirmation page is created
1066	assert.True(t, ui.pages.HasPage("confirm"))
1067}
1068
1069func selectConfirmationYes(t *testing.T, ui *UI) {
1070	t.Helper()
1071	_, primitive := ui.pages.GetFrontPage()
1072	modal, ok := primitive.(*tview.Modal)
1073	if !assert.True(t, ok) {
1074		return
1075	}
1076	var setFocus func(tview.Primitive)
1077	setFocus = func(p tview.Primitive) {
1078		p.Focus(setFocus)
1079	}
1080	modal.SetFocus(1)
1081	modal.Focus(setFocus)
1082	modal.InputHandler()(tcell.NewEventKey(tcell.KeyEnter, 0, 0), setFocus)
1083}
1084
1085func TestConfirmMoveToTrashSelectedYes(t *testing.T) {
1086	fin := testdir.CreateTestDir()
1087	defer fin()
1088
1089	ui := getAnalyzedPathMockedApp(t, true, true, false)
1090	ui.done = make(chan struct{})
1091	var trashed string
1092	ui.trasher = func(dir, item fs.Item) error {
1093		trashed = item.GetName()
1094		dir.RemoveFile(item)
1095		return nil
1096	}
1097	ui.table.Select(0, 0)
1098	selected := ui.table.GetCell(0, 0).GetReference().(fs.Item).GetName()
1099
1100	ui.confirmDeletionSelected(ActionMoveToTrash)
1101	selectConfirmationYes(t, ui)
1102	<-ui.done
1103
1104	assert.Equal(t, selected, trashed)
1105}
1106
1107func TestConfirmMoveToTrashMarkedYes(t *testing.T) {
1108	fin := testdir.CreateTestDir()
1109	defer fin()
1110
1111	ui := getAnalyzedPathMockedApp(t, true, true, false)
1112	ui.done = make(chan struct{})
1113	var trashed string
1114	ui.trasher = func(dir, item fs.Item) error {
1115		trashed = item.GetName()
1116		dir.RemoveFile(item)
1117		return nil
1118	}
1119	ui.markedRows[0] = struct{}{}
1120
1121	ui.confirmDeletionMarked(ActionMoveToTrash)
1122	selectConfirmationYes(t, ui)
1123	<-ui.done
1124
1125	assert.Equal(t, "nested", trashed)
1126}
1127
1128func TestConfirmDeletionSelectedSafeDefault(t *testing.T) {
1129	fin := testdir.CreateTestDir()
1130	defer fin()
1131
1132	ui := getAnalyzedPathMockedApp(t, false, true, false)
1133	ui.done = make(chan struct{})
1134
1135	assert.Equal(t, 1, ui.table.GetRowCount())
1136	ui.table.Select(0, 0)
1137
1138	// Create confirmation dialog
1139	ui.confirmDeletionSelected(ActionDelete)
1140
1141	// Verify that the confirmation dialog exists with safer defaults
1142	assert.DirExists(t, "test_dir/nested")
1143	assert.True(t, ui.pages.HasPage("confirm"))
1144}
1145
1146func TestConfirmDeletionButtonIndexMapping(t *testing.T) {
1147	fin := testdir.CreateTestDir()
1148	defer fin()
1149
1150	ui := getAnalyzedPathMockedApp(t, false, true, false)
1151	ui.done = make(chan struct{})
1152	ui.askBeforeDelete = false // Skip confirmation for direct testing
1153
1154	assert.Equal(t, 1, ui.table.GetRowCount())
1155	ui.table.Select(0, 0)
1156
1157	// Test that deletion still works when explicitly called
1158	ui.deleteSelected(ActionDelete)
1159
1160	<-ui.done
1161
1162	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1163		f()
1164	}
1165
1166	assert.NoDirExists(t, "test_dir/nested")
1167}
1168
1169func TestConfirmEmptySelectedSafeDefault(t *testing.T) {
1170	ui := getAnalyzedPathMockedApp(t, true, true, true)
1171
1172	ui.table.Select(1, 0)
1173	ui.confirmDeletionSelected(ActionEmpty)
1174
1175	// Verify empty confirmation dialog is created safely
1176	assert.True(t, ui.pages.HasPage("confirm"))
1177}
1178
1179func TestConfirmDeletionMarkedSafeDefault(t *testing.T) {
1180	ui := getAnalyzedPathMockedApp(t, true, true, true)
1181
1182	ui.table.Select(1, 0)
1183	ui.markedRows[1] = struct{}{}
1184	ui.confirmDeletionMarked(ActionDelete)
1185
1186	// Verify marked deletion confirmation dialog is created safely
1187	assert.True(t, ui.pages.HasPage("confirm"))
1188}
1189
1190func TestConfirmEmptyMarkedSafeDefault(t *testing.T) {
1191	ui := getAnalyzedPathMockedApp(t, false, true, true)
1192
1193	ui.table.Select(1, 0)
1194	ui.markedRows[1] = struct{}{}
1195	ui.confirmDeletionMarked(ActionEmpty)
1196
1197	// Verify marked empty confirmation dialog is created safely
1198	assert.True(t, ui.pages.HasPage("confirm"))
1199}
1200
1201func TestSaferConfirmationPreventDataLoss(t *testing.T) {
1202	fin := testdir.CreateTestDir()
1203	defer fin()
1204
1205	ui := getAnalyzedPathMockedApp(t, false, true, false)
1206
1207	assert.Equal(t, 1, ui.table.GetRowCount())
1208	ui.table.Select(0, 0)
1209
1210	// Test that creating confirmation dialog doesn't accidentally trigger deletion
1211	ui.confirmDeletionSelected(ActionDelete)
1212	ui.confirmDeletionSelected(ActionEmpty) // empty
1213
1214	// Directory should still exist - no accidental deletion
1215	assert.DirExists(t, "test_dir/nested")
1216	assert.True(t, ui.pages.HasPage("confirm"))
1217}
1218
1219func TestConfirmDeletionSelectedCase1(t *testing.T) {
1220	fin := testdir.CreateTestDir()
1221	defer fin()
1222
1223	ui := getAnalyzedPathMockedApp(t, false, true, false)
1224	ui.done = make(chan struct{})
1225
1226	assert.Equal(t, 1, ui.table.GetRowCount())
1227	ui.table.Select(0, 0)
1228
1229	// Test case 1 branch (yes button at index 1) by directly calling deleteSelected
1230	ui.deleteSelected(ActionDelete)
1231
1232	<-ui.done
1233
1234	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1235		f()
1236	}
1237
1238	assert.NoDirExists(t, "test_dir/nested")
1239}
1240
1241func TestConfirmDeletionMarkedCase1(t *testing.T) {
1242	fin := testdir.CreateTestDir()
1243	defer fin()
1244
1245	ui := getAnalyzedPathMockedApp(t, false, true, false)
1246	ui.done = make(chan struct{})
1247
1248	ui.fileItemSelected(0, 0)     // nested
1249	ui.markedRows[1] = struct{}{} // subnested
1250
1251	// Test case 1 branch (yes button at index 1) by directly calling deleteMarked
1252	ui.deleteMarked(ActionDelete)
1253
1254	<-ui.done
1255
1256	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1257		f()
1258	}
1259
1260	assert.NoDirExists(t, "test_dir/nested/subnested")
1261}