fork/gdu

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

Julia RyanRestore cursor pos on rescan98ee348

ignore
43.5 KiB1704 linesraw
1package tui
2
3import (
4	"bytes"
5	"errors"
6	"fmt"
7	"os"
8	"path/filepath"
9	"testing"
10	"time"
11
12	"github.com/dundee/gdu/v5/internal/testanalyze"
13	"github.com/dundee/gdu/v5/internal/testapp"
14	"github.com/dundee/gdu/v5/internal/testdir"
15	"github.com/dundee/gdu/v5/pkg/analyze"
16	"github.com/dundee/gdu/v5/pkg/device"
17	"github.com/dundee/gdu/v5/pkg/fs"
18	"github.com/gdamore/tcell/v2"
19	"github.com/rivo/tview"
20	"github.com/stretchr/testify/assert"
21)
22
23type devicesInfoGetterErrMock struct{}
24
25func (m devicesInfoGetterErrMock) GetDevicesInfo() (device.Devices, error) {
26	return nil, fmt.Errorf("failed getting devices")
27}
28
29func (m devicesInfoGetterErrMock) GetMounts() (device.Devices, error) {
30	return nil, fmt.Errorf("failed getting mounts")
31}
32
33func TestShowHelp(t *testing.T) {
34	simScreen := testapp.CreateSimScreen()
35	defer simScreen.Fini()
36
37	app := testapp.CreateMockedApp(false)
38	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
39
40	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, '?', 0))
41
42	assert.True(t, ui.pages.HasPage("help"))
43}
44
45func TestCloseHelp(t *testing.T) {
46	simScreen := testapp.CreateSimScreen()
47	defer simScreen.Fini()
48
49	app := testapp.CreateMockedApp(false)
50	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
51	ui.showHelp()
52
53	assert.True(t, ui.pages.HasPage("help"))
54
55	ui.keyPressed(tcell.NewEventKey(tcell.KeyEsc, 'q', 0))
56
57	assert.False(t, ui.pages.HasPage("help"))
58}
59
60func TestCloseHelpWithQuestionMark(t *testing.T) {
61	simScreen := testapp.CreateSimScreen()
62	defer simScreen.Fini()
63
64	app := testapp.CreateMockedApp(false)
65	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
66	ui.showHelp()
67
68	assert.True(t, ui.pages.HasPage("help"))
69
70	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, '?', 0))
71
72	assert.False(t, ui.pages.HasPage("help"))
73}
74
75func TestKeyWhileDeleting(t *testing.T) {
76	simScreen := testapp.CreateSimScreen()
77	defer simScreen.Fini()
78
79	app := testapp.CreateMockedApp(false)
80	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
81
82	modal := tview.NewModal().SetText("Deleting...")
83	ui.pages.AddPage("deleting", modal, true, true)
84
85	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyEnter, ' ', 0))
86	assert.Equal(t, tcell.KeyEnter, key.Key())
87}
88
89func TestLeftRightKeyWhileConfirm(t *testing.T) {
90	simScreen := testapp.CreateSimScreen()
91	defer simScreen.Fini()
92
93	app := testapp.CreateMockedApp(false)
94	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
95
96	modal := tview.NewModal().SetText("Really?")
97	ui.pages.AddPage("confirm", modal, true, true)
98
99	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyLeft, 0, 0))
100	assert.Equal(t, tcell.KeyLeft, key.Key())
101	key = ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 0, 0))
102	assert.Equal(t, tcell.KeyRight, key.Key())
103	key = ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'h', 0))
104	assert.Equal(t, tcell.KeyLeft, key.Key())
105	key = ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'l', 0))
106	assert.Equal(t, tcell.KeyRight, key.Key())
107}
108
109func TestMoveLeftRight(t *testing.T) {
110	origWD, err := os.Getwd()
111	assert.Nil(t, err)
112
113	err = os.Chdir(t.TempDir())
114	assert.Nil(t, err)
115	defer func() {
116		err := os.Chdir(origWD)
117		assert.Nil(t, err)
118	}()
119
120	fin := testdir.CreateTestDir()
121	defer fin()
122	simScreen := testapp.CreateSimScreen()
123	defer simScreen.Fini()
124
125	app := testapp.CreateMockedApp(false)
126	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
127	ui.done = make(chan struct{})
128	ui.browseParentDirs = true
129	err = ui.AnalyzePath("test_dir", nil)
130	assert.Nil(t, err)
131
132	<-ui.done // wait for analyzer
133
134	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
135		f()
136	}
137
138	ui.table.Select(0, 0)
139	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
140
141	assert.Equal(t, "nested", ui.currentDir.GetName())
142
143	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // try /.. first
144
145	assert.Equal(t, "nested", ui.currentDir.GetName())
146
147	ui.table.Select(1, 0)
148
149	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
150
151	assert.Equal(t, "subnested", ui.currentDir.GetName())
152
153	ui.keyPressed(tcell.NewEventKey(tcell.KeyLeft, 'h', 0))
154
155	assert.Equal(t, "nested", ui.currentDir.GetName())
156
157	ui.keyPressed(tcell.NewEventKey(tcell.KeyLeft, 'h', 0))
158
159	assert.Equal(t, "test_dir", ui.currentDir.GetName())
160
161	ui.keyPressed(tcell.NewEventKey(tcell.KeyLeft, 'h', 0))
162	<-ui.done
163
164	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
165		f()
166	}
167
168	assert.Equal(t, filepath.Dir("test_dir"), ui.currentDirPath)
169}
170
171func TestMoveRightOnDevice(t *testing.T) {
172	fin := testdir.CreateTestDir()
173	defer fin()
174	simScreen := testapp.CreateSimScreen()
175	defer simScreen.Fini()
176
177	app := testapp.CreateMockedApp(false)
178	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
179	ui.Analyzer = &testanalyze.MockedAnalyzer{}
180	ui.done = make(chan struct{})
181	ui.SetIgnoreDirPaths([]string{})
182	err := ui.ListDevices(getDevicesInfoMock())
183	assert.Nil(t, err)
184
185	ui.table.Select(1, 0)
186
187	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
188
189	<-ui.done // wait for analyzer
190
191	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
192		f()
193	}
194
195	assert.Equal(t, "test_dir", ui.currentDir.GetName())
196
197	// go back to list of devices
198	ui.keyPressed(tcell.NewEventKey(tcell.KeyLeft, 'h', 0))
199
200	assert.Nil(t, ui.currentDir)
201	assert.Equal(t, "/dev/root", ui.table.GetCell(1, 0).GetReference().(*device.Device).Name)
202}
203
204func TestHandleLeftShowsErrorWhenListDevicesFails(t *testing.T) {
205	simScreen := testapp.CreateSimScreen()
206	defer simScreen.Fini()
207
208	app := testapp.CreateMockedApp(false)
209	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
210	ui.currentDirPath = "test_dir"
211	ui.topDirPath = "test_dir"
212	ui.devices = device.Devices{&device.Device{Name: "x"}}
213	ui.getter = devicesInfoGetterErrMock{}
214
215	ui.handleLeft()
216
217	assert.True(t, ui.pages.HasPage("error"))
218}
219
220func TestHandleLeftAtTopDirDoesNothingWhenBrowseParentDirsDisabled(t *testing.T) {
221	simScreen := testapp.CreateSimScreen()
222	defer simScreen.Fini()
223
224	app := testapp.CreateMockedApp(false)
225	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
226	ui.currentDirPath = "test_dir"
227	ui.topDirPath = "test_dir"
228	ui.currentDir = &analyze.Dir{
229		File:     &analyze.File{Name: "test_dir"},
230		BasePath: ".",
231	}
232
233	ui.handleLeft()
234
235	assert.False(t, ui.pages.HasPage("error"))
236	assert.Equal(t, "test_dir", ui.currentDirPath)
237}
238
239func TestAnalyzeParentOfTopDirNilCurrentDir(t *testing.T) {
240	simScreen := testapp.CreateSimScreen()
241	defer simScreen.Fini()
242
243	app := testapp.CreateMockedApp(false)
244	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
245	ui.currentDir = nil
246
247	ui.analyzeParentOfTopDir()
248
249	assert.False(t, ui.pages.HasPage("error"))
250}
251
252func TestAnalyzeParentOfTopDirInArchive(t *testing.T) {
253	simScreen := testapp.CreateSimScreen()
254	defer simScreen.Fini()
255
256	app := testapp.CreateMockedApp(false)
257	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
258	ui.currentDir = &analyze.ZipDir{Dir: &analyze.Dir{}}
259
260	ui.analyzeParentOfTopDir()
261
262	assert.False(t, ui.pages.HasPage("error"))
263}
264
265func TestAnalyzeParentOfTopDirAtFilesystemRoot(t *testing.T) {
266	simScreen := testapp.CreateSimScreen()
267	defer simScreen.Fini()
268
269	app := testapp.CreateMockedApp(false)
270	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
271	ui.currentDir = &analyze.Dir{File: &analyze.File{Name: "/"}}
272
273	ui.analyzeParentOfTopDir()
274
275	assert.False(t, ui.pages.HasPage("error"))
276}
277
278func TestAnalyzeParentOfTopDirShowsErrorWhenAnalyzeFails(t *testing.T) {
279	simScreen := testapp.CreateSimScreen()
280	defer simScreen.Fini()
281
282	app := testapp.CreateMockedApp(false)
283	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
284	ui.currentDir = &analyze.Dir{
285		File:     &analyze.File{Name: "test_dir"},
286		BasePath: ".",
287	}
288	origAnalyzeParentPath := analyzeParentPath
289	t.Cleanup(func() {
290		analyzeParentPath = origAnalyzeParentPath
291	})
292	analyzeParentPath = func(ui *UI, path string, parentDir fs.Item) error {
293		return errors.New("boom")
294	}
295
296	ui.analyzeParentOfTopDir()
297
298	assert.True(t, ui.pages.HasPage("error"))
299}
300
301func TestStop(t *testing.T) {
302	simScreen := testapp.CreateSimScreen()
303	defer simScreen.Fini()
304
305	app := testapp.CreateMockedApp(false)
306	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
307
308	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
309	assert.Nil(t, key)
310}
311
312func TestStopWithPrintingPath(t *testing.T) {
313	fin := testdir.CreateTestDir()
314	defer fin()
315	simScreen := testapp.CreateSimScreen()
316	defer simScreen.Fini()
317
318	app := testapp.CreateMockedApp(false)
319	buff := &bytes.Buffer{}
320	ui := CreateUI(app, simScreen, buff, true, true, false, false)
321
322	ui.done = make(chan struct{})
323	err := ui.AnalyzePath("test_dir", nil)
324	assert.Nil(t, err)
325
326	<-ui.done // wait for analyzer
327
328	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
329		f()
330	}
331
332	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'Q', 0))
333	assert.Nil(t, key)
334
335	assert.Equal(t, "test_dir\n", buff.String())
336}
337
338// analyzedUI returns a UI with a finished scan, ready for preview tests.
339func analyzedUI(t *testing.T, buff *bytes.Buffer) *UI {
340	t.Helper()
341	simScreen := testapp.CreateSimScreen()
342	t.Cleanup(simScreen.Fini)
343
344	app := testapp.CreateMockedApp(false)
345	ui := CreateUI(app, simScreen, buff, true, true, false, false)
346
347	ui.done = make(chan struct{})
348	assert.Nil(t, ui.AnalyzePath("test_dir", nil))
349	<-ui.done // wait for analyzer
350	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
351		f()
352	}
353	return ui
354}
355
356func TestQuitConfirmsAfterLongScan(t *testing.T) {
357	fin := testdir.CreateTestDir()
358	defer fin()
359
360	ui := analyzedUI(t, &bytes.Buffer{})
361	ui.scanDuration = 10 * time.Second // simulate a long scan
362
363	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
364	assert.Nil(t, key)
365	assert.True(t, ui.pages.HasPage("confirm"))
366}
367
368func TestQuitImmediateAfterShortScan(t *testing.T) {
369	fin := testdir.CreateTestDir()
370	defer fin()
371
372	ui := analyzedUI(t, &bytes.Buffer{})
373	ui.scanDuration = time.Second // below the confirmation threshold
374
375	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
376	assert.Nil(t, key)
377	assert.False(t, ui.pages.HasPage("confirm"))
378}
379
380func TestQuitImmediateWhenConfirmDisabled(t *testing.T) {
381	fin := testdir.CreateTestDir()
382	defer fin()
383
384	ui := analyzedUI(t, &bytes.Buffer{})
385	ui.SetConfirmQuit(false)
386	ui.scanDuration = 10 * time.Second
387
388	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
389	assert.Nil(t, key)
390	assert.False(t, ui.pages.HasPage("confirm"))
391}
392
393func TestQuitNotRetriggeredWhileConfirmOpen(t *testing.T) {
394	fin := testdir.CreateTestDir()
395	defer fin()
396
397	ui := analyzedUI(t, &bytes.Buffer{})
398	ui.scanDuration = 10 * time.Second
399
400	assert.Nil(t, ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0)))
401	assert.True(t, ui.pages.HasPage("confirm"))
402
403	// pressing q again must not stack dialogs nor quit; the key passes through
404	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
405	assert.NotNil(t, key)
406	assert.True(t, ui.pages.HasPage("confirm"))
407}
408
409func TestQuitConfirmsDuringLongRunningScan(t *testing.T) {
410	fin := testdir.CreateTestDir()
411	defer fin()
412
413	ui := analyzedUI(t, &bytes.Buffer{})
414	// simulate a scan that is still running and started long ago
415	ui.scanning = true
416	ui.scanStart = time.Now().Add(-10 * time.Second)
417
418	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
419	assert.Nil(t, key)
420	assert.True(t, ui.pages.HasPage("confirm"))
421}
422
423func TestQuitImmediateDuringShortRunningScan(t *testing.T) {
424	fin := testdir.CreateTestDir()
425	defer fin()
426
427	ui := analyzedUI(t, &bytes.Buffer{})
428	// a scan that just started should not block quitting
429	ui.scanning = true
430	ui.scanStart = time.Now()
431
432	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
433	assert.Nil(t, key)
434	assert.False(t, ui.pages.HasPage("confirm"))
435}
436
437func TestDoQuitPrintsCurrentDirPath(t *testing.T) {
438	fin := testdir.CreateTestDir()
439	defer fin()
440
441	buff := &bytes.Buffer{}
442	ui := analyzedUI(t, buff)
443
444	ui.doQuit(true)
445	assert.Equal(t, "test_dir\n", buff.String())
446}
447
448func TestEnterAndExitPreview(t *testing.T) {
449	fin := testdir.CreateTestDir()
450	defer fin()
451
452	ui := analyzedUI(t, &bytes.Buffer{})
453
454	ui.enterPreview()
455	assert.True(t, ui.previewing)
456	assert.NotNil(t, ui.currentDir)
457	assert.False(t, ui.pages.HasPage("progress"))
458
459	// Tab leaves the preview and restores the scanning progress modal
460	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyTab, 0, 0))
461	assert.Nil(t, key)
462	assert.False(t, ui.previewing)
463	assert.True(t, ui.pages.HasPage("progress"))
464}
465
466func TestTabDuringScanEntersPreview(t *testing.T) {
467	fin := testdir.CreateTestDir()
468	defer fin()
469
470	ui := analyzedUI(t, &bytes.Buffer{})
471	// simulate a scan still in progress: the progress modal is shown
472	ui.pages.AddPage("progress", ui.progressFlex, true, true)
473
474	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyTab, 0, 0))
475	assert.Nil(t, key)
476	assert.True(t, ui.previewing)
477	assert.False(t, ui.pages.HasPage("progress"))
478}
479
480func TestCtrlCDuringScanCancelsAnalyzer(t *testing.T) {
481	fin := testdir.CreateTestDir()
482	defer fin()
483
484	ui := analyzedUI(t, &bytes.Buffer{})
485	ui.progress = tview.NewTextView()
486	ui.scanning = true
487	ui.pages.AddPage("progress", ui.progress, true, true)
488
489	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyCtrlC, 0, 0))
490
491	assert.Nil(t, key)
492	assert.True(t, ui.scanCancelled)
493	assert.True(t, ui.Analyzer.(*analyze.ParallelAnalyzer).IsCancelled())
494	assert.Equal(t, " Stopping scan... ", ui.progress.GetTitle())
495}
496
497func TestCtrlCDuringScanPreviewCancelsAnalyzer(t *testing.T) {
498	fin := testdir.CreateTestDir()
499	defer fin()
500
501	ui := analyzedUI(t, &bytes.Buffer{})
502	ui.progress = tview.NewTextView()
503	ui.scanning = true
504	ui.pages.AddPage("progress", ui.progress, true, true)
505	ui.enterPreview()
506
507	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyCtrlC, 0, 0))
508
509	assert.Nil(t, key)
510	assert.True(t, ui.scanCancelled)
511	assert.True(t, ui.Analyzer.(*analyze.ParallelAnalyzer).IsCancelled())
512}
513
514func TestPreviewIgnoresDestructiveKeys(t *testing.T) {
515	fin := testdir.CreateTestDir()
516	defer fin()
517
518	ui := analyzedUI(t, &bytes.Buffer{})
519	ui.enterPreview()
520
521	// delete must not open a confirmation dialog while previewing
522	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
523	assert.False(t, ui.pages.HasPage("confirm"))
524	assert.True(t, ui.previewing)
525}
526
527func TestPreviewNavigation(t *testing.T) {
528	fin := testdir.CreateTestDir()
529	defer fin()
530
531	ui := analyzedUI(t, &bytes.Buffer{})
532	ui.enterPreview()
533	root := ui.currentDir
534	rootPath := ui.currentDirPath
535
536	// drill into the first subdirectory
537	ui.table.Select(0, 0)
538	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'l', 0))
539	assert.NotEqual(t, rootPath, ui.currentDirPath)
540	assert.True(t, ui.previewing)
541
542	// go back up to the root
543	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'h', 0))
544	assert.Equal(t, root, ui.currentDir)
545
546	// at the root, going up again leaves the preview
547	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'h', 0))
548	assert.False(t, ui.previewing)
549}
550
551func TestEnterPreviewNoopWithoutScan(t *testing.T) {
552	simScreen := testapp.CreateSimScreen()
553	defer simScreen.Fini()
554
555	app := testapp.CreateMockedApp(false)
556	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
557
558	// nothing has been scanned yet -> no tree to preview
559	ui.enterPreview()
560	assert.False(t, ui.previewing)
561}
562
563func TestEnterPreviewNoopWithUnsupportedAnalyzer(t *testing.T) {
564	simScreen := testapp.CreateSimScreen()
565	defer simScreen.Fini()
566
567	app := testapp.CreateMockedApp(false)
568	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
569	ui.Analyzer = &testanalyze.MockedAnalyzer{} // does not expose GetCurrentDir
570
571	ui.enterPreview()
572	assert.False(t, ui.previewing)
573}
574
575func TestSpawnShell(t *testing.T) {
576	fin := testdir.CreateTestDir()
577	defer fin()
578	simScreen := testapp.CreateSimScreen()
579	defer simScreen.Fini()
580
581	app := testapp.CreateMockedApp(false)
582	buff := &bytes.Buffer{}
583	ui := CreateUI(app, simScreen, buff, true, true, false, false)
584	called := false
585	ui.exec = func(argv0 string, argv, envv []string) error {
586		called = true
587		return nil
588	}
589
590	ui.done = make(chan struct{})
591	err := ui.AnalyzePath("test_dir", nil)
592	assert.Nil(t, err)
593
594	<-ui.done // wait for analyzer
595
596	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
597		f()
598	}
599
600	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
601	assert.Nil(t, key)
602	assert.True(t, called)
603}
604
605func TestSpawnShellWithoutDir(t *testing.T) {
606	fin := testdir.CreateTestDir()
607	defer fin()
608	simScreen := testapp.CreateSimScreen()
609	defer simScreen.Fini()
610
611	app := testapp.CreateMockedApp(false)
612	buff := &bytes.Buffer{}
613	ui := CreateUI(app, simScreen, buff, true, true, false, false)
614	called := false
615	ui.exec = func(argv0 string, argv, envv []string) error {
616		called = true
617		return nil
618	}
619
620	ui.done = make(chan struct{})
621
622	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
623	assert.Nil(t, key)
624	assert.False(t, called)
625}
626
627func TestSpawnShellWithWrongDir(t *testing.T) {
628	fin := testdir.CreateTestDir()
629	defer fin()
630	simScreen := testapp.CreateSimScreen()
631	defer simScreen.Fini()
632
633	app := testapp.CreateMockedApp(false)
634	buff := &bytes.Buffer{}
635	ui := CreateUI(app, simScreen, buff, true, true, false, false)
636	called := false
637	ui.exec = func(argv0 string, argv, envv []string) error {
638		called = true
639		return nil
640	}
641
642	ui.done = make(chan struct{})
643	ui.currentDir = &analyze.Dir{}
644	ui.currentDirPath = "/xxxxx"
645
646	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
647	assert.Nil(t, key)
648	assert.False(t, called)
649	assert.True(t, ui.pages.HasPage("error"))
650}
651
652func TestSpawnShellWithError(t *testing.T) {
653	fin := testdir.CreateTestDir()
654	defer fin()
655	simScreen := testapp.CreateSimScreen()
656	defer simScreen.Fini()
657
658	app := testapp.CreateMockedApp(false)
659	buff := &bytes.Buffer{}
660	ui := CreateUI(app, simScreen, buff, true, true, false, false)
661	called := false
662	ui.exec = func(argv0 string, argv, envv []string) error {
663		called = true
664		return errors.New("wrong shell")
665	}
666
667	ui.done = make(chan struct{})
668	ui.currentDir = &analyze.Dir{}
669	ui.currentDirPath = "."
670
671	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
672	assert.Nil(t, key)
673	assert.True(t, called)
674	assert.True(t, ui.pages.HasPage("error"))
675}
676
677func TestSpawnShellWithNoSpawnShell(t *testing.T) {
678	fin := testdir.CreateTestDir()
679	defer fin()
680	simScreen := testapp.CreateSimScreen()
681	defer simScreen.Fini()
682
683	app := testapp.CreateMockedApp(false)
684	buff := &bytes.Buffer{}
685	ui := CreateUI(app, simScreen, buff, true, true, false, false)
686	called := false
687	ui.exec = func(argv0 string, argv, envv []string) error {
688		called = true
689		return nil
690	}
691
692	ui.done = make(chan struct{})
693	err := ui.AnalyzePath("test_dir", nil)
694	assert.Nil(t, err)
695
696	<-ui.done // wait for analyzer
697
698	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
699		f()
700	}
701
702	ui.SetNoSpawnShell()
703	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
704	assert.Nil(t, key)
705	assert.False(t, called)
706}
707
708func TestOpenItemWithNoSpawnShell(t *testing.T) {
709	fin := testdir.CreateTestDir()
710	defer fin()
711	simScreen := testapp.CreateSimScreen()
712	defer simScreen.Fini()
713
714	app := testapp.CreateMockedApp(false)
715	buff := &bytes.Buffer{}
716	ui := CreateUI(app, simScreen, buff, true, true, false, false)
717
718	ui.done = make(chan struct{})
719	err := ui.AnalyzePath("test_dir", nil)
720	assert.Nil(t, err)
721
722	<-ui.done // wait for analyzer
723
724	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
725		f()
726	}
727
728	ui.SetNoSpawnShell()
729	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'o', 0))
730	assert.Nil(t, key)
731}
732
733func TestShowConfirm(t *testing.T) {
734	simScreen := testapp.CreateSimScreen()
735	defer simScreen.Fini()
736
737	app := testapp.CreateMockedApp(true)
738	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
739	ui.Analyzer = &testanalyze.MockedAnalyzer{}
740	ui.done = make(chan struct{})
741	err := ui.AnalyzePath("test_dir", nil)
742	assert.Nil(t, err)
743
744	<-ui.done // wait for analyzer
745
746	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
747		f()
748	}
749
750	assert.Equal(t, "test_dir", ui.currentDir.GetName())
751
752	ui.table.Select(1, 0)
753
754	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
755
756	assert.True(t, ui.pages.HasPage("confirm"))
757
758	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, '?', 0))
759
760	assert.False(t, ui.pages.HasPage("help"))
761}
762
763func TestDeleteEmpty(t *testing.T) {
764	simScreen := testapp.CreateSimScreen()
765	defer simScreen.Fini()
766
767	app := testapp.CreateMockedApp(true)
768	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
769	ui.done = make(chan struct{})
770
771	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
772	assert.NotNil(t, key)
773}
774
775func TestMarkEmpty(t *testing.T) {
776	simScreen := testapp.CreateSimScreen()
777	defer simScreen.Fini()
778
779	app := testapp.CreateMockedApp(true)
780	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
781	ui.done = make(chan struct{})
782
783	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
784	assert.NotNil(t, key)
785}
786
787func TestIgnoreEmpty(t *testing.T) {
788	simScreen := testapp.CreateSimScreen()
789	defer simScreen.Fini()
790
791	app := testapp.CreateMockedApp(true)
792	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
793	ui.done = make(chan struct{})
794
795	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'I', 0))
796	assert.NotNil(t, key)
797}
798
799func TestDelete(t *testing.T) {
800	fin := testdir.CreateTestDir()
801	defer fin()
802	simScreen := testapp.CreateSimScreen()
803	defer simScreen.Fini()
804
805	app := testapp.CreateMockedApp(true)
806	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
807	ui.done = make(chan struct{})
808	ui.askBeforeDelete = false
809	err := ui.AnalyzePath("test_dir", nil)
810	assert.Nil(t, err)
811
812	<-ui.done // wait for analyzer
813
814	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
815		f()
816	}
817
818	assert.Equal(t, "test_dir", ui.currentDir.GetName())
819
820	assert.Equal(t, 1, ui.table.GetRowCount())
821
822	ui.table.Select(0, 0)
823
824	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
825
826	<-ui.done
827
828	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
829		f()
830	}
831
832	assert.NoDirExists(t, "test_dir/nested")
833}
834
835func TestMoveToTrash(t *testing.T) {
836	fin := testdir.CreateTestDir()
837	defer fin()
838	simScreen := testapp.CreateSimScreen()
839	defer simScreen.Fini()
840
841	app := testapp.CreateMockedApp(true)
842	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
843	ui.done = make(chan struct{})
844	ui.askBeforeDelete = false
845	var trashed fs.Item
846	ui.trasher = func(dir, item fs.Item) error {
847		trashed = item
848		dir.RemoveFile(item)
849		return nil
850	}
851	err := ui.AnalyzePath("test_dir", nil)
852	assert.Nil(t, err)
853
854	<-ui.done // wait for analyzer
855
856	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
857		f()
858	}
859
860	assert.Equal(t, "test_dir", ui.currentDir.GetName())
861	assert.Equal(t, 1, ui.table.GetRowCount())
862
863	ui.table.Select(0, 0)
864
865	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'D', 0))
866
867	<-ui.done
868
869	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
870		f()
871	}
872
873	assert.NotNil(t, trashed)
874	assert.Equal(t, "nested", trashed.GetName())
875	assert.Equal(t, 0, ui.table.GetRowCount())
876}
877
878func TestMoveToTrashWithNoDelete(t *testing.T) {
879	fin := testdir.CreateTestDir()
880	defer fin()
881	simScreen := testapp.CreateSimScreen()
882	defer simScreen.Fini()
883
884	app := testapp.CreateMockedApp(true)
885	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
886	ui.done = make(chan struct{})
887	var trashed fs.Item
888	ui.trasher = func(dir, item fs.Item) error {
889		trashed = item
890		return nil
891	}
892	err := ui.AnalyzePath("test_dir", nil)
893	assert.Nil(t, err)
894
895	<-ui.done // wait for analyzer
896
897	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
898		f()
899	}
900
901	assert.Equal(t, "test_dir", ui.currentDir.GetName())
902	assert.Equal(t, 1, ui.table.GetRowCount())
903
904	ui.table.Select(0, 0)
905
906	ui.SetNoDelete()
907	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'D', 0))
908
909	assert.Nil(t, trashed)
910	assert.DirExists(t, "test_dir/nested")
911}
912
913func TestDeleteWithNoDelete(t *testing.T) {
914	fin := testdir.CreateTestDir()
915	defer fin()
916	simScreen := testapp.CreateSimScreen()
917	defer simScreen.Fini()
918
919	app := testapp.CreateMockedApp(true)
920	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
921	ui.done = make(chan struct{})
922	err := ui.AnalyzePath("test_dir", nil)
923	assert.Nil(t, err)
924
925	<-ui.done // wait for analyzer
926
927	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
928		f()
929	}
930
931	assert.Equal(t, "test_dir", ui.currentDir.GetName())
932
933	assert.Equal(t, 1, ui.table.GetRowCount())
934
935	ui.table.Select(0, 0)
936
937	ui.SetNoDelete()
938	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
939
940	assert.DirExists(t, "test_dir/nested")
941}
942
943func TestDeleteMarked(t *testing.T) {
944	fin := testdir.CreateTestDir()
945	defer fin()
946	simScreen := testapp.CreateSimScreen()
947	defer simScreen.Fini()
948
949	app := testapp.CreateMockedApp(true)
950	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
951	ui.done = make(chan struct{})
952	ui.askBeforeDelete = false
953	err := ui.AnalyzePath("test_dir", nil)
954	assert.Nil(t, err)
955
956	<-ui.done // wait for analyzer
957
958	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
959		f()
960	}
961
962	assert.Equal(t, "test_dir", ui.currentDir.GetName())
963
964	assert.Equal(t, 1, ui.table.GetRowCount())
965
966	ui.table.Select(0, 0)
967
968	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
969
970	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
971
972	<-ui.done
973
974	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
975		f()
976	}
977
978	assert.NoDirExists(t, "test_dir/nested")
979}
980
981func TestMoveMarkedToTrash(t *testing.T) {
982	fin := testdir.CreateTestDir()
983	defer fin()
984	simScreen := testapp.CreateSimScreen()
985	defer simScreen.Fini()
986
987	app := testapp.CreateMockedApp(true)
988	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
989	ui.done = make(chan struct{})
990	ui.askBeforeDelete = false
991	var trashed []string
992	ui.trasher = func(dir, item fs.Item) error {
993		trashed = append(trashed, item.GetName())
994		dir.RemoveFile(item)
995		return nil
996	}
997	err := ui.AnalyzePath("test_dir", nil)
998	assert.Nil(t, err)
999
1000	<-ui.done // wait for analyzer
1001
1002	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1003		f()
1004	}
1005
1006	ui.table.Select(0, 0)
1007	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1008	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'D', 0))
1009
1010	<-ui.done
1011
1012	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1013		f()
1014	}
1015
1016	assert.Equal(t, []string{"nested"}, trashed)
1017	assert.Equal(t, 0, ui.table.GetRowCount())
1018}
1019
1020func TestDeleteParent(t *testing.T) {
1021	fin := testdir.CreateTestDir()
1022	defer fin()
1023	simScreen := testapp.CreateSimScreen()
1024	defer simScreen.Fini()
1025
1026	app := testapp.CreateMockedApp(true)
1027	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1028	ui.done = make(chan struct{})
1029	ui.askBeforeDelete = false
1030	err := ui.AnalyzePath("test_dir", nil)
1031	assert.Nil(t, err)
1032
1033	<-ui.done // wait for analyzer
1034
1035	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1036		f()
1037	}
1038
1039	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1040	assert.Equal(t, 1, ui.table.GetRowCount())
1041
1042	ui.table.Select(0, 0)
1043
1044	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1045	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
1046
1047	assert.DirExists(t, "test_dir/nested")
1048}
1049
1050func TestMarkParent(t *testing.T) {
1051	fin := testdir.CreateTestDir()
1052	defer fin()
1053	simScreen := testapp.CreateSimScreen()
1054	defer simScreen.Fini()
1055
1056	app := testapp.CreateMockedApp(true)
1057	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1058	ui.done = make(chan struct{})
1059	ui.askBeforeDelete = false
1060	err := ui.AnalyzePath("test_dir", nil)
1061	assert.Nil(t, err)
1062
1063	<-ui.done // wait for analyzer
1064
1065	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1066		f()
1067	}
1068
1069	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1070	assert.Equal(t, 1, ui.table.GetRowCount())
1071
1072	ui.table.Select(0, 0)
1073
1074	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1075	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1076
1077	assert.Equal(t, len(ui.markedRows), 0)
1078}
1079
1080func TestEmptyDir(t *testing.T) {
1081	fin := testdir.CreateTestDir()
1082	defer fin()
1083	simScreen := testapp.CreateSimScreen()
1084	defer simScreen.Fini()
1085
1086	app := testapp.CreateMockedApp(true)
1087	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1088	ui.done = make(chan struct{})
1089	ui.askBeforeDelete = false
1090	err := ui.AnalyzePath("test_dir", nil)
1091	assert.Nil(t, err)
1092
1093	<-ui.done // wait for analyzer
1094
1095	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1096		f()
1097	}
1098
1099	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1100
1101	assert.Equal(t, 1, ui.table.GetRowCount())
1102
1103	ui.table.Select(0, 0)
1104
1105	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1106
1107	<-ui.done
1108
1109	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1110		f()
1111	}
1112
1113	assert.DirExists(t, "test_dir/nested")
1114	assert.NoDirExists(t, "test_dir/nested/subnested")
1115}
1116
1117func TestMarkedEmptyDir(t *testing.T) {
1118	fin := testdir.CreateTestDir()
1119	defer fin()
1120	simScreen := testapp.CreateSimScreen()
1121	defer simScreen.Fini()
1122
1123	app := testapp.CreateMockedApp(true)
1124	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1125	ui.done = make(chan struct{})
1126	ui.askBeforeDelete = false
1127	err := ui.AnalyzePath("test_dir", nil)
1128	assert.Nil(t, err)
1129
1130	<-ui.done // wait for analyzer
1131
1132	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1133		f()
1134	}
1135
1136	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1137
1138	assert.Equal(t, 1, ui.table.GetRowCount())
1139
1140	ui.table.Select(0, 0)
1141
1142	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1143
1144	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1145
1146	<-ui.done
1147
1148	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1149		f()
1150	}
1151
1152	assert.DirExists(t, "test_dir/nested")
1153	assert.NoDirExists(t, "test_dir/nested/subnested")
1154}
1155
1156func TestIgnoreDir(t *testing.T) {
1157	fin := testdir.CreateTestDir()
1158	defer fin()
1159	simScreen := testapp.CreateSimScreen()
1160	defer simScreen.Fini()
1161
1162	app := testapp.CreateMockedApp(true)
1163	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1164	ui.done = make(chan struct{})
1165	ui.askBeforeDelete = false
1166	err := ui.AnalyzePath("test_dir", nil)
1167	assert.Nil(t, err)
1168
1169	<-ui.done // wait for analyzer
1170
1171	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1172		f()
1173	}
1174
1175	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1176
1177	assert.Equal(t, 1, ui.table.GetRowCount())
1178
1179	ui.table.Select(0, 0)
1180
1181	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1182	assert.Equal(t, 3, ui.table.GetRowCount())
1183
1184	ui.table.Select(1, 0) // subnested
1185	subnestedPath := ui.table.GetCell(1, 0).GetReference().(fs.Item).GetPath()
1186
1187	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'I', 0)) // ignore subnested, triggers rescan
1188
1189	<-ui.done // wait for rescan
1190
1191	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1192		f()
1193	}
1194
1195	_, ok := ui.IgnoreDirPaths[subnestedPath]
1196	assert.True(t, ok)
1197	assert.Equal(t, 2, ui.table.GetRowCount()) // subnested no longer listed
1198
1199	row, _ := ui.table.GetSelection()
1200	assert.Equal(t, 1, row) // cursor position preserved (clamped to new row count)
1201}
1202
1203func TestEmptyFile(t *testing.T) {
1204	fin := testdir.CreateTestDir()
1205	defer fin()
1206	simScreen := testapp.CreateSimScreen()
1207	defer simScreen.Fini()
1208
1209	app := testapp.CreateMockedApp(true)
1210	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1211	ui.done = make(chan struct{})
1212	ui.askBeforeDelete = false
1213	err := ui.AnalyzePath("test_dir", nil)
1214	assert.Nil(t, err)
1215
1216	<-ui.done // wait for analyzer
1217
1218	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1219		f()
1220	}
1221
1222	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1223
1224	assert.Equal(t, 1, ui.table.GetRowCount())
1225
1226	ui.table.Select(0, 0)
1227
1228	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1229
1230	ui.table.Select(2, 0) // file2
1231
1232	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1233
1234	<-ui.done
1235
1236	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1237		f()
1238	}
1239
1240	assert.DirExists(t, "test_dir/nested")
1241	assert.DirExists(t, "test_dir/nested/subnested")
1242}
1243
1244func TestMarkedEmptyFile(t *testing.T) {
1245	fin := testdir.CreateTestDir()
1246	defer fin()
1247	simScreen := testapp.CreateSimScreen()
1248	defer simScreen.Fini()
1249
1250	app := testapp.CreateMockedApp(true)
1251	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1252	ui.done = make(chan struct{})
1253	ui.askBeforeDelete = false
1254	err := ui.AnalyzePath("test_dir", nil)
1255	assert.Nil(t, err)
1256
1257	<-ui.done // wait for analyzer
1258
1259	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1260		f()
1261	}
1262
1263	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1264
1265	assert.Equal(t, 1, ui.table.GetRowCount())
1266
1267	ui.table.Select(0, 0)
1268
1269	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1270
1271	ui.table.Select(2, 0) // file2
1272
1273	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1274
1275	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1276
1277	<-ui.done
1278
1279	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1280		f()
1281	}
1282
1283	assert.DirExists(t, "test_dir/nested")
1284	assert.DirExists(t, "test_dir/nested/subnested")
1285}
1286
1287func TestSortByApparentSize(t *testing.T) {
1288	simScreen := testapp.CreateSimScreen()
1289	defer simScreen.Fini()
1290
1291	app := testapp.CreateMockedApp(true)
1292	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1293	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1294	ui.done = make(chan struct{})
1295	err := ui.AnalyzePath("test_dir", nil)
1296	assert.Nil(t, err)
1297
1298	<-ui.done // wait for analyzer
1299
1300	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1301		f()
1302	}
1303
1304	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1305
1306	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'a', 0))
1307
1308	assert.True(t, ui.ShowApparentSize)
1309}
1310
1311func TestShowFileCount(t *testing.T) {
1312	simScreen := testapp.CreateSimScreen()
1313	defer simScreen.Fini()
1314
1315	app := testapp.CreateMockedApp(true)
1316	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
1317	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1318	ui.done = make(chan struct{})
1319	err := ui.AnalyzePath("test_dir", nil)
1320	assert.Nil(t, err)
1321
1322	<-ui.done // wait for analyzer
1323
1324	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1325		f()
1326	}
1327
1328	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1329
1330	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'c', 0))
1331
1332	assert.True(t, ui.showItemCount)
1333}
1334
1335func TestShowFileCountBW(t *testing.T) {
1336	simScreen := testapp.CreateSimScreen()
1337	defer simScreen.Fini()
1338
1339	app := testapp.CreateMockedApp(true)
1340	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1341	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1342	ui.done = make(chan struct{})
1343	err := ui.AnalyzePath("test_dir", nil)
1344	assert.Nil(t, err)
1345
1346	<-ui.done // wait for analyzer
1347
1348	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1349		f()
1350	}
1351
1352	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1353
1354	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'c', 0))
1355
1356	assert.True(t, ui.showItemCount)
1357}
1358
1359func TestShowMtime(t *testing.T) {
1360	simScreen := testapp.CreateSimScreen()
1361	defer simScreen.Fini()
1362
1363	app := testapp.CreateMockedApp(true)
1364	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
1365	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1366	ui.done = make(chan struct{})
1367	err := ui.AnalyzePath("test_dir", nil)
1368	assert.Nil(t, err)
1369
1370	<-ui.done // wait for analyzer
1371
1372	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1373		f()
1374	}
1375
1376	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1377
1378	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'm', 0))
1379
1380	assert.True(t, ui.showMtime)
1381}
1382
1383func TestShowMtimeBW(t *testing.T) {
1384	simScreen := testapp.CreateSimScreen()
1385	defer simScreen.Fini()
1386
1387	app := testapp.CreateMockedApp(true)
1388	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1389	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1390	ui.done = make(chan struct{})
1391	err := ui.AnalyzePath("test_dir", nil)
1392	assert.Nil(t, err)
1393
1394	<-ui.done // wait for analyzer
1395
1396	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1397		f()
1398	}
1399
1400	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1401
1402	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'm', 0))
1403
1404	assert.True(t, ui.showMtime)
1405}
1406
1407func TestShowRelativeBar(t *testing.T) {
1408	simScreen := testapp.CreateSimScreen()
1409	defer simScreen.Fini()
1410
1411	app := testapp.CreateMockedApp(true)
1412	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1413	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1414	ui.done = make(chan struct{})
1415	err := ui.AnalyzePath("test_dir", nil)
1416	assert.Nil(t, err)
1417
1418	<-ui.done // wait for analyzer
1419
1420	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1421		f()
1422	}
1423
1424	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1425	assert.False(t, ui.ShowRelativeSize)
1426
1427	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'B', 0))
1428
1429	assert.True(t, ui.ShowRelativeSize)
1430}
1431
1432func TestRescan(t *testing.T) {
1433	parentDir := &analyze.Dir{
1434		File: &analyze.File{
1435			Name: "parent",
1436		},
1437		Files: make([]fs.Item, 0, 1),
1438	}
1439	currentDir := &analyze.Dir{
1440		File: &analyze.File{
1441			Name:   "sub",
1442			Parent: parentDir,
1443		},
1444	}
1445
1446	simScreen := testapp.CreateSimScreen()
1447	defer simScreen.Fini()
1448
1449	app := testapp.CreateMockedApp(true)
1450	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1451	ui.done = make(chan struct{})
1452	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1453	ui.currentDir = currentDir
1454	ui.topDir = parentDir
1455
1456	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'r', 0))
1457
1458	<-ui.done // wait for analyzer
1459
1460	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1461		f()
1462	}
1463
1464	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1465	assert.Equal(t, parentDir, ui.currentDir.GetParent())
1466
1467	assert.Equal(t, 5, ui.table.GetRowCount())
1468	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
1469	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ddd")
1470}
1471
1472func TestSorting(t *testing.T) {
1473	simScreen := testapp.CreateSimScreen()
1474	defer simScreen.Fini()
1475
1476	app := testapp.CreateMockedApp(true)
1477	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1478	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1479	ui.done = make(chan struct{})
1480	err := ui.AnalyzePath("test_dir", nil)
1481	assert.Nil(t, err)
1482
1483	<-ui.done // wait for analyzer
1484
1485	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1486		f()
1487	}
1488
1489	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1490
1491	ui.table.Select(1, 0)
1492	// mark the item for deletion
1493	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1494	assert.Equal(t, 1, len(ui.markedRows))
1495
1496	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 's', 0))
1497	assert.Equal(t, "size", ui.sortBy)
1498	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'C', 0))
1499	assert.Equal(t, "itemCount", ui.sortBy)
1500	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'n', 0))
1501	assert.Equal(t, "name", ui.sortBy)
1502	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'M', 0))
1503	assert.Equal(t, "mtime", ui.sortBy)
1504
1505	// marking should be dropped after sorting
1506	assert.Equal(t, 0, len(ui.markedRows))
1507}
1508
1509func TestShowFile(t *testing.T) {
1510	fin := testdir.CreateTestDir()
1511	defer fin()
1512	simScreen := testapp.CreateSimScreen()
1513	defer simScreen.Fini()
1514
1515	app := testapp.CreateMockedApp(true)
1516	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1517	ui.done = make(chan struct{})
1518	err := ui.AnalyzePath("test_dir", nil)
1519	assert.Nil(t, err)
1520
1521	<-ui.done // wait for analyzer
1522
1523	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1524		f()
1525	}
1526
1527	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1528
1529	ui.table.Select(0, 0)
1530	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1531	ui.table.Select(2, 0)
1532	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1533	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1534}
1535
1536func TestShowFileWithNoViewFile(t *testing.T) {
1537	fin := testdir.CreateTestDir()
1538	defer fin()
1539	simScreen := testapp.CreateSimScreen()
1540	defer simScreen.Fini()
1541
1542	app := testapp.CreateMockedApp(true)
1543	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1544	ui.done = make(chan struct{})
1545	err := ui.AnalyzePath("test_dir", nil)
1546	assert.Nil(t, err)
1547
1548	<-ui.done // wait for analyzer
1549
1550	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1551		f()
1552	}
1553
1554	ui.SetNoViewFile()
1555	ui.table.Select(0, 0)
1556	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1557	ui.table.Select(2, 0)
1558	previousHeaderText := ui.header.GetText(false)
1559
1560	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1561
1562	assert.False(t, ui.pages.HasPage("file"))
1563	assert.Equal(t, " Viewing files is disabled!", ui.header.GetText(false))
1564
1565	time.Sleep(2100 * time.Millisecond)
1566	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1567		f()
1568	}
1569
1570	assert.Equal(t, previousHeaderText, ui.header.GetText(false))
1571}
1572
1573func TestShowInfoAndMoveAround(t *testing.T) {
1574	fin := testdir.CreateTestDir()
1575	defer fin()
1576	simScreen := testapp.CreateSimScreen()
1577	defer simScreen.Fini()
1578
1579	app := testapp.CreateMockedApp(true)
1580	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1581	ui.done = make(chan struct{})
1582	err := ui.AnalyzePath("test_dir", nil)
1583	assert.Nil(t, err)
1584
1585	<-ui.done // wait for analyzer
1586
1587	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1588		f()
1589	}
1590
1591	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1592
1593	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1594	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
1595
1596	assert.True(t, ui.pages.HasPage("info"))
1597
1598	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'k', 0)) // move up
1599	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'j', 0)) // move down
1600	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'k', 0)) // move up
1601	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, '?', 0)) // does nothing
1602
1603	assert.True(t, ui.pages.HasPage("info")) // we can still see info page
1604
1605	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1606
1607	assert.False(t, ui.pages.HasPage("info"))
1608}
1609
1610func TestBlockedActionsInArchive(t *testing.T) {
1611	simScreen := testapp.CreateSimScreen()
1612	defer simScreen.Fini()
1613
1614	app := testapp.CreateMockedApp(true)
1615	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
1616
1617	// Simulate being in a zip dir
1618	zipDir := &analyze.ZipDir{
1619		Dir: &analyze.Dir{
1620			File: &analyze.File{
1621				Name: "test.zip",
1622				Flag: 'Z',
1623			},
1624		},
1625	}
1626	ui.currentDir = zipDir
1627
1628	// Test 'd' (delete)
1629	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
1630	assert.True(t, ui.pages.HasPage("error"))
1631	ui.pages.RemovePage("error")
1632
1633	// Test 'e' (empty)
1634	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1635	assert.True(t, ui.pages.HasPage("error"))
1636	ui.pages.RemovePage("error")
1637
1638	// Test 'D' (move to trash)
1639	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'D', 0))
1640	assert.True(t, ui.pages.HasPage("error"))
1641	ui.pages.RemovePage("error")
1642
1643	// Test 'v' (view)
1644	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1645	assert.True(t, ui.pages.HasPage("error"))
1646	ui.pages.RemovePage("error")
1647
1648	// Test 'b' (shell)
1649	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
1650	assert.True(t, ui.pages.HasPage("error"))
1651	ui.pages.RemovePage("error")
1652}
1653
1654func TestPrintMarkedEmpty(t *testing.T) {
1655	simScreen := testapp.CreateSimScreen()
1656	defer simScreen.Fini()
1657
1658	app := testapp.CreateMockedApp(true)
1659	buff := &bytes.Buffer{}
1660	ui := CreateUI(app, simScreen, buff, false, true, false, false)
1661	ui.done = make(chan struct{})
1662
1663	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'p', 0))
1664	assert.Nil(t, key)
1665	assert.Empty(t, ui.markedPaths)
1666}
1667
1668func TestPrintMarked(t *testing.T) {
1669	fin := testdir.CreateTestDir()
1670	defer fin()
1671	simScreen := testapp.CreateSimScreen()
1672	defer simScreen.Fini()
1673
1674	app := testapp.CreateMockedApp(true)
1675	buff := &bytes.Buffer{}
1676	ui := CreateUI(app, simScreen, buff, false, true, false, false)
1677	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1678	ui.done = make(chan struct{})
1679	err := ui.AnalyzePath("test_dir", nil)
1680	assert.Nil(t, err)
1681
1682	<-ui.done // wait for analyzer
1683
1684	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1685		f()
1686	}
1687
1688	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1689
1690	ui.table.Select(1, 0)
1691	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0)) // mark item
1692
1693	assert.Equal(t, 1, len(ui.markedRows))
1694
1695	// pressing 'p' saves paths but does not quit
1696	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'p', 0))
1697	assert.Nil(t, key)
1698	assert.Equal(t, 1, len(ui.markedPaths))
1699	assert.Empty(t, buff.String()) // nothing written yet
1700
1701	// quitting with 'q' flushes the saved paths to output
1702	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1703	assert.NotEmpty(t, buff.String())
1704}