fork/gdu

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

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

master
44.0 KiB1726 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 TestIgnoreParent(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	assert.Equal(t, 1, ui.table.GetRowCount())
1101
1102	ui.table.Select(0, 0)
1103
1104	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1105	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'I', 0))
1106
1107	assert.Equal(t, len(ui.ignoredRows), 0)
1108}
1109
1110func TestEmptyDir(t *testing.T) {
1111	fin := testdir.CreateTestDir()
1112	defer fin()
1113	simScreen := testapp.CreateSimScreen()
1114	defer simScreen.Fini()
1115
1116	app := testapp.CreateMockedApp(true)
1117	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1118	ui.done = make(chan struct{})
1119	ui.askBeforeDelete = false
1120	err := ui.AnalyzePath("test_dir", nil)
1121	assert.Nil(t, err)
1122
1123	<-ui.done // wait for analyzer
1124
1125	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1126		f()
1127	}
1128
1129	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1130
1131	assert.Equal(t, 1, ui.table.GetRowCount())
1132
1133	ui.table.Select(0, 0)
1134
1135	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1136
1137	<-ui.done
1138
1139	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1140		f()
1141	}
1142
1143	assert.DirExists(t, "test_dir/nested")
1144	assert.NoDirExists(t, "test_dir/nested/subnested")
1145}
1146
1147func TestMarkedEmptyDir(t *testing.T) {
1148	fin := testdir.CreateTestDir()
1149	defer fin()
1150	simScreen := testapp.CreateSimScreen()
1151	defer simScreen.Fini()
1152
1153	app := testapp.CreateMockedApp(true)
1154	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1155	ui.done = make(chan struct{})
1156	ui.askBeforeDelete = false
1157	err := ui.AnalyzePath("test_dir", nil)
1158	assert.Nil(t, err)
1159
1160	<-ui.done // wait for analyzer
1161
1162	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1163		f()
1164	}
1165
1166	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1167
1168	assert.Equal(t, 1, ui.table.GetRowCount())
1169
1170	ui.table.Select(0, 0)
1171
1172	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1173
1174	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1175
1176	<-ui.done
1177
1178	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1179		f()
1180	}
1181
1182	assert.DirExists(t, "test_dir/nested")
1183	assert.NoDirExists(t, "test_dir/nested/subnested")
1184}
1185
1186func TestIgnoreDir(t *testing.T) {
1187	fin := testdir.CreateTestDir()
1188	defer fin()
1189	simScreen := testapp.CreateSimScreen()
1190	defer simScreen.Fini()
1191
1192	app := testapp.CreateMockedApp(true)
1193	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1194	ui.done = make(chan struct{})
1195	ui.askBeforeDelete = false
1196	err := ui.AnalyzePath("test_dir", nil)
1197	assert.Nil(t, err)
1198
1199	<-ui.done // wait for analyzer
1200
1201	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1202		f()
1203	}
1204
1205	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1206
1207	assert.Equal(t, 1, ui.table.GetRowCount())
1208
1209	ui.table.Select(0, 0)
1210
1211	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1212	assert.Equal(t, 3, ui.table.GetRowCount())
1213
1214	ui.table.Select(1, 0) // subnested
1215
1216	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'I', 0)) // ignore subnested
1217
1218	row, _ := ui.table.GetSelection()
1219	assert.Equal(t, 2, row) // selection moves to next row
1220
1221	ui.table.Select(1, 0)
1222	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'I', 0)) // unignore subnested
1223}
1224
1225func TestEmptyFile(t *testing.T) {
1226	fin := testdir.CreateTestDir()
1227	defer fin()
1228	simScreen := testapp.CreateSimScreen()
1229	defer simScreen.Fini()
1230
1231	app := testapp.CreateMockedApp(true)
1232	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1233	ui.done = make(chan struct{})
1234	ui.askBeforeDelete = false
1235	err := ui.AnalyzePath("test_dir", nil)
1236	assert.Nil(t, err)
1237
1238	<-ui.done // wait for analyzer
1239
1240	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1241		f()
1242	}
1243
1244	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1245
1246	assert.Equal(t, 1, ui.table.GetRowCount())
1247
1248	ui.table.Select(0, 0)
1249
1250	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1251
1252	ui.table.Select(2, 0) // file2
1253
1254	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1255
1256	<-ui.done
1257
1258	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1259		f()
1260	}
1261
1262	assert.DirExists(t, "test_dir/nested")
1263	assert.DirExists(t, "test_dir/nested/subnested")
1264}
1265
1266func TestMarkedEmptyFile(t *testing.T) {
1267	fin := testdir.CreateTestDir()
1268	defer fin()
1269	simScreen := testapp.CreateSimScreen()
1270	defer simScreen.Fini()
1271
1272	app := testapp.CreateMockedApp(true)
1273	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1274	ui.done = make(chan struct{})
1275	ui.askBeforeDelete = false
1276	err := ui.AnalyzePath("test_dir", nil)
1277	assert.Nil(t, err)
1278
1279	<-ui.done // wait for analyzer
1280
1281	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1282		f()
1283	}
1284
1285	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1286
1287	assert.Equal(t, 1, ui.table.GetRowCount())
1288
1289	ui.table.Select(0, 0)
1290
1291	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0)) // into nested
1292
1293	ui.table.Select(2, 0) // file2
1294
1295	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1296
1297	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1298
1299	<-ui.done
1300
1301	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1302		f()
1303	}
1304
1305	assert.DirExists(t, "test_dir/nested")
1306	assert.DirExists(t, "test_dir/nested/subnested")
1307}
1308
1309func TestSortByApparentSize(t *testing.T) {
1310	simScreen := testapp.CreateSimScreen()
1311	defer simScreen.Fini()
1312
1313	app := testapp.CreateMockedApp(true)
1314	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1315	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1316	ui.done = make(chan struct{})
1317	err := ui.AnalyzePath("test_dir", nil)
1318	assert.Nil(t, err)
1319
1320	<-ui.done // wait for analyzer
1321
1322	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1323		f()
1324	}
1325
1326	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1327
1328	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'a', 0))
1329
1330	assert.True(t, ui.ShowApparentSize)
1331}
1332
1333func TestShowFileCount(t *testing.T) {
1334	simScreen := testapp.CreateSimScreen()
1335	defer simScreen.Fini()
1336
1337	app := testapp.CreateMockedApp(true)
1338	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
1339	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1340	ui.done = make(chan struct{})
1341	err := ui.AnalyzePath("test_dir", nil)
1342	assert.Nil(t, err)
1343
1344	<-ui.done // wait for analyzer
1345
1346	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1347		f()
1348	}
1349
1350	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1351
1352	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'c', 0))
1353
1354	assert.True(t, ui.showItemCount)
1355}
1356
1357func TestShowFileCountBW(t *testing.T) {
1358	simScreen := testapp.CreateSimScreen()
1359	defer simScreen.Fini()
1360
1361	app := testapp.CreateMockedApp(true)
1362	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1363	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1364	ui.done = make(chan struct{})
1365	err := ui.AnalyzePath("test_dir", nil)
1366	assert.Nil(t, err)
1367
1368	<-ui.done // wait for analyzer
1369
1370	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1371		f()
1372	}
1373
1374	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1375
1376	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'c', 0))
1377
1378	assert.True(t, ui.showItemCount)
1379}
1380
1381func TestShowMtime(t *testing.T) {
1382	simScreen := testapp.CreateSimScreen()
1383	defer simScreen.Fini()
1384
1385	app := testapp.CreateMockedApp(true)
1386	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, false, false, false)
1387	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1388	ui.done = make(chan struct{})
1389	err := ui.AnalyzePath("test_dir", nil)
1390	assert.Nil(t, err)
1391
1392	<-ui.done // wait for analyzer
1393
1394	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1395		f()
1396	}
1397
1398	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1399
1400	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'm', 0))
1401
1402	assert.True(t, ui.showMtime)
1403}
1404
1405func TestShowMtimeBW(t *testing.T) {
1406	simScreen := testapp.CreateSimScreen()
1407	defer simScreen.Fini()
1408
1409	app := testapp.CreateMockedApp(true)
1410	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1411	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1412	ui.done = make(chan struct{})
1413	err := ui.AnalyzePath("test_dir", nil)
1414	assert.Nil(t, err)
1415
1416	<-ui.done // wait for analyzer
1417
1418	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1419		f()
1420	}
1421
1422	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1423
1424	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'm', 0))
1425
1426	assert.True(t, ui.showMtime)
1427}
1428
1429func TestShowRelativeBar(t *testing.T) {
1430	simScreen := testapp.CreateSimScreen()
1431	defer simScreen.Fini()
1432
1433	app := testapp.CreateMockedApp(true)
1434	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, false, false, false)
1435	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1436	ui.done = make(chan struct{})
1437	err := ui.AnalyzePath("test_dir", nil)
1438	assert.Nil(t, err)
1439
1440	<-ui.done // wait for analyzer
1441
1442	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1443		f()
1444	}
1445
1446	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1447	assert.False(t, ui.ShowRelativeSize)
1448
1449	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'B', 0))
1450
1451	assert.True(t, ui.ShowRelativeSize)
1452}
1453
1454func TestRescan(t *testing.T) {
1455	parentDir := &analyze.Dir{
1456		File: &analyze.File{
1457			Name: "parent",
1458		},
1459		Files: make([]fs.Item, 0, 1),
1460	}
1461	currentDir := &analyze.Dir{
1462		File: &analyze.File{
1463			Name:   "sub",
1464			Parent: parentDir,
1465		},
1466	}
1467
1468	simScreen := testapp.CreateSimScreen()
1469	defer simScreen.Fini()
1470
1471	app := testapp.CreateMockedApp(true)
1472	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1473	ui.done = make(chan struct{})
1474	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1475	ui.currentDir = currentDir
1476	ui.topDir = parentDir
1477
1478	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'r', 0))
1479
1480	<-ui.done // wait for analyzer
1481
1482	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1483		f()
1484	}
1485
1486	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1487	assert.Equal(t, parentDir, ui.currentDir.GetParent())
1488
1489	assert.Equal(t, 5, ui.table.GetRowCount())
1490	assert.Contains(t, ui.table.GetCell(0, 0).Text, "/..")
1491	assert.Contains(t, ui.table.GetCell(1, 0).Text, "ddd")
1492}
1493
1494func TestSorting(t *testing.T) {
1495	simScreen := testapp.CreateSimScreen()
1496	defer simScreen.Fini()
1497
1498	app := testapp.CreateMockedApp(true)
1499	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1500	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1501	ui.done = make(chan struct{})
1502	err := ui.AnalyzePath("test_dir", nil)
1503	assert.Nil(t, err)
1504
1505	<-ui.done // wait for analyzer
1506
1507	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1508		f()
1509	}
1510
1511	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1512
1513	ui.table.Select(1, 0)
1514	// mark the item for deletion
1515	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0))
1516	assert.Equal(t, 1, len(ui.markedRows))
1517
1518	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 's', 0))
1519	assert.Equal(t, "size", ui.sortBy)
1520	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'C', 0))
1521	assert.Equal(t, "itemCount", ui.sortBy)
1522	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'n', 0))
1523	assert.Equal(t, "name", ui.sortBy)
1524	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'M', 0))
1525	assert.Equal(t, "mtime", ui.sortBy)
1526
1527	// marking should be dropped after sorting
1528	assert.Equal(t, 0, len(ui.markedRows))
1529}
1530
1531func TestShowFile(t *testing.T) {
1532	fin := testdir.CreateTestDir()
1533	defer fin()
1534	simScreen := testapp.CreateSimScreen()
1535	defer simScreen.Fini()
1536
1537	app := testapp.CreateMockedApp(true)
1538	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1539	ui.done = make(chan struct{})
1540	err := ui.AnalyzePath("test_dir", nil)
1541	assert.Nil(t, err)
1542
1543	<-ui.done // wait for analyzer
1544
1545	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1546		f()
1547	}
1548
1549	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1550
1551	ui.table.Select(0, 0)
1552	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1553	ui.table.Select(2, 0)
1554	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1555	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1556}
1557
1558func TestShowFileWithNoViewFile(t *testing.T) {
1559	fin := testdir.CreateTestDir()
1560	defer fin()
1561	simScreen := testapp.CreateSimScreen()
1562	defer simScreen.Fini()
1563
1564	app := testapp.CreateMockedApp(true)
1565	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1566	ui.done = make(chan struct{})
1567	err := ui.AnalyzePath("test_dir", nil)
1568	assert.Nil(t, err)
1569
1570	<-ui.done // wait for analyzer
1571
1572	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1573		f()
1574	}
1575
1576	ui.SetNoViewFile()
1577	ui.table.Select(0, 0)
1578	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1579	ui.table.Select(2, 0)
1580	previousHeaderText := ui.header.GetText(false)
1581
1582	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1583
1584	assert.False(t, ui.pages.HasPage("file"))
1585	assert.Equal(t, " Viewing files is disabled!", ui.header.GetText(false))
1586
1587	time.Sleep(2100 * time.Millisecond)
1588	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1589		f()
1590	}
1591
1592	assert.Equal(t, previousHeaderText, ui.header.GetText(false))
1593}
1594
1595func TestShowInfoAndMoveAround(t *testing.T) {
1596	fin := testdir.CreateTestDir()
1597	defer fin()
1598	simScreen := testapp.CreateSimScreen()
1599	defer simScreen.Fini()
1600
1601	app := testapp.CreateMockedApp(true)
1602	ui := CreateUI(app, simScreen, &bytes.Buffer{}, false, true, false, false)
1603	ui.done = make(chan struct{})
1604	err := ui.AnalyzePath("test_dir", nil)
1605	assert.Nil(t, err)
1606
1607	<-ui.done // wait for analyzer
1608
1609	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1610		f()
1611	}
1612
1613	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1614
1615	ui.keyPressed(tcell.NewEventKey(tcell.KeyRight, 'l', 0))
1616	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'i', 0))
1617
1618	assert.True(t, ui.pages.HasPage("info"))
1619
1620	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'k', 0)) // move up
1621	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'j', 0)) // move down
1622	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'k', 0)) // move up
1623	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, '?', 0)) // does nothing
1624
1625	assert.True(t, ui.pages.HasPage("info")) // we can still see info page
1626
1627	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1628
1629	assert.False(t, ui.pages.HasPage("info"))
1630}
1631
1632func TestBlockedActionsInArchive(t *testing.T) {
1633	simScreen := testapp.CreateSimScreen()
1634	defer simScreen.Fini()
1635
1636	app := testapp.CreateMockedApp(true)
1637	ui := CreateUI(app, simScreen, &bytes.Buffer{}, true, true, false, false)
1638
1639	// Simulate being in a zip dir
1640	zipDir := &analyze.ZipDir{
1641		Dir: &analyze.Dir{
1642			File: &analyze.File{
1643				Name: "test.zip",
1644				Flag: 'Z',
1645			},
1646		},
1647	}
1648	ui.currentDir = zipDir
1649
1650	// Test 'd' (delete)
1651	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'd', 0))
1652	assert.True(t, ui.pages.HasPage("error"))
1653	ui.pages.RemovePage("error")
1654
1655	// Test 'e' (empty)
1656	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'e', 0))
1657	assert.True(t, ui.pages.HasPage("error"))
1658	ui.pages.RemovePage("error")
1659
1660	// Test 'D' (move to trash)
1661	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'D', 0))
1662	assert.True(t, ui.pages.HasPage("error"))
1663	ui.pages.RemovePage("error")
1664
1665	// Test 'v' (view)
1666	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'v', 0))
1667	assert.True(t, ui.pages.HasPage("error"))
1668	ui.pages.RemovePage("error")
1669
1670	// Test 'b' (shell)
1671	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'b', 0))
1672	assert.True(t, ui.pages.HasPage("error"))
1673	ui.pages.RemovePage("error")
1674}
1675
1676func TestPrintMarkedEmpty(t *testing.T) {
1677	simScreen := testapp.CreateSimScreen()
1678	defer simScreen.Fini()
1679
1680	app := testapp.CreateMockedApp(true)
1681	buff := &bytes.Buffer{}
1682	ui := CreateUI(app, simScreen, buff, false, true, false, false)
1683	ui.done = make(chan struct{})
1684
1685	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'p', 0))
1686	assert.Nil(t, key)
1687	assert.Empty(t, ui.markedPaths)
1688}
1689
1690func TestPrintMarked(t *testing.T) {
1691	fin := testdir.CreateTestDir()
1692	defer fin()
1693	simScreen := testapp.CreateSimScreen()
1694	defer simScreen.Fini()
1695
1696	app := testapp.CreateMockedApp(true)
1697	buff := &bytes.Buffer{}
1698	ui := CreateUI(app, simScreen, buff, false, true, false, false)
1699	ui.Analyzer = &testanalyze.MockedAnalyzer{}
1700	ui.done = make(chan struct{})
1701	err := ui.AnalyzePath("test_dir", nil)
1702	assert.Nil(t, err)
1703
1704	<-ui.done // wait for analyzer
1705
1706	for _, f := range ui.app.(*testapp.MockedApp).GetUpdateDraws() {
1707		f()
1708	}
1709
1710	assert.Equal(t, "test_dir", ui.currentDir.GetName())
1711
1712	ui.table.Select(1, 0)
1713	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, ' ', 0)) // mark item
1714
1715	assert.Equal(t, 1, len(ui.markedRows))
1716
1717	// pressing 'p' saves paths but does not quit
1718	key := ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'p', 0))
1719	assert.Nil(t, key)
1720	assert.Equal(t, 1, len(ui.markedPaths))
1721	assert.Empty(t, buff.String()) // nothing written yet
1722
1723	// quitting with 'q' flushes the saved paths to output
1724	ui.keyPressed(tcell.NewEventKey(tcell.KeyRune, 'q', 0))
1725	assert.NotEmpty(t, buff.String())
1726}