fork/gdu

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

Daniel Mildefeat: allow scanning multiple directories (#653)34f3996

master
14.2 KiB507 linesraw
1package report
2
3import (
4	"bytes"
5	"errors"
6	"io"
7	"os"
8	"strings"
9	"sync"
10	"testing"
11
12	log "github.com/sirupsen/logrus"
13
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/stretchr/testify/assert"
19)
20
21func init() {
22	log.SetLevel(log.WarnLevel)
23}
24
25func TestMain(m *testing.M) {
26	os.Unsetenv("BLOCK_SIZE")
27	os.Unsetenv("BLOCKSIZE")
28	os.Exit(m.Run())
29}
30
31type errorExportItem struct {
32	*analyze.Dir
33	err error
34}
35
36func (item errorExportItem) EncodeJSON(io.Writer, bool, fs.JSONAttributes) error {
37	return item.err
38}
39
40func TestAnalyzePath(t *testing.T) {
41	fin := testdir.CreateTestDir()
42	defer fin()
43
44	output := bytes.NewBuffer(make([]byte, 10))
45	reportOutput := bytes.NewBuffer(make([]byte, 10))
46
47	ui := CreateExportUI(output, reportOutput, false, false, false, 0, 0, false, nil)
48	ui.SetIgnoreDirPaths([]string{"/xxx"})
49	err := ui.AnalyzePath("test_dir", nil)
50	assert.Nil(t, err)
51	err = ui.StartUILoop()
52
53	assert.Nil(t, err)
54	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
55}
56
57func TestExportDirReturnsEncodeError(t *testing.T) {
58	sentinel := errors.New("encode failed")
59	ui := CreateExportUI(&bytes.Buffer{}, &bytes.Buffer{}, false, false, false, 0, 0, false, nil)
60
61	err := ui.exportDir(errorExportItem{err: sentinel}, &sync.WaitGroup{})
62
63	assert.ErrorIs(t, err, sentinel)
64}
65
66func TestAnalyzePathWithTop(t *testing.T) {
67	fin := testdir.CreateTestDir()
68	defer fin()
69
70	output := bytes.NewBuffer(make([]byte, 10))
71	reportOutput := bytes.NewBuffer(make([]byte, 10))
72
73	ui := CreateExportUI(output, reportOutput, false, false, false, 2, 0, false, nil)
74	ui.SetIgnoreDirPaths([]string{"/xxx"})
75	err := ui.AnalyzePath("test_dir", nil)
76	assert.Nil(t, err)
77	err = ui.StartUILoop()
78
79	assert.Nil(t, err)
80	assert.Contains(t, reportOutput.String(), `"name":"file"`)
81	assert.Contains(t, reportOutput.String(), `"name":"file2"`)
82	assert.NotContains(t, reportOutput.String(), `"name":"nested"`)
83	assert.NotContains(t, reportOutput.String(), `"name":"subnested"`)
84}
85
86func TestAnalyzePathWithTopAndTypeFilter(t *testing.T) {
87	fin := testdir.CreateTestDir()
88	defer fin()
89
90	output := bytes.NewBuffer(make([]byte, 10))
91	reportOutput := bytes.NewBuffer(make([]byte, 10))
92
93	ui := CreateExportUI(output, reportOutput, false, false, false, 10, 0, false, nil)
94	ui.SetIgnoreDirPaths([]string{"/xxx"})
95	ui.SetIncludeTypes([]string{"none"})
96	err := ui.AnalyzePath("test_dir", nil)
97	assert.Nil(t, err)
98	err = ui.StartUILoop()
99
100	assert.Nil(t, err)
101	assert.NotContains(t, reportOutput.String(), `"name":"file"`)
102	assert.NotContains(t, reportOutput.String(), `"name":"file2"`)
103}
104
105func TestAnalyzePathWithDepth(t *testing.T) {
106	fin := testdir.CreateTestDir()
107	defer fin()
108
109	var output bytes.Buffer
110	var reportOutput bytes.Buffer
111
112	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 2, false, nil)
113	ui.SetIgnoreDirPaths([]string{"/xxx"})
114	err := ui.AnalyzePath("test_dir", nil)
115	assert.Nil(t, err)
116	err = ui.StartUILoop()
117
118	assert.Nil(t, err)
119	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
120	assert.Contains(t, reportOutput.String(), `"name":"file2"`)
121	assert.Contains(t, reportOutput.String(), `"name":"subnested"`)
122}
123
124func TestAnalyzePathWithDepthOne(t *testing.T) {
125	fin := testdir.CreateTestDir()
126	defer fin()
127
128	var output bytes.Buffer
129	var reportOutput bytes.Buffer
130
131	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 1, false, nil)
132	ui.SetIgnoreDirPaths([]string{"/xxx"})
133	err := ui.AnalyzePath("test_dir", nil)
134	assert.Nil(t, err)
135	err = ui.StartUILoop()
136
137	assert.Nil(t, err)
138	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
139	assert.NotContains(t, reportOutput.String(), `"name":"file2"`)
140	assert.NotContains(t, reportOutput.String(), `"name":"subnested"`)
141	assert.NotContains(t, reportOutput.String(), `"name":"file"`)
142
143	readDir, err := ReadAnalysis(bytes.NewReader(reportOutput.Bytes()))
144	assert.Nil(t, err)
145	assert.Equal(t, "test_dir", readDir.GetName())
146
147	var nested fs.Item
148	for f := range readDir.GetFiles(fs.SortByName, fs.SortAsc) {
149		if f.GetName() == "nested" {
150			nested = f
151		}
152	}
153	assert.NotNil(t, nested)
154	assert.True(t, nested.IsDir())
155}
156
157func TestAnalyzePathWithSummarize(t *testing.T) {
158	fin := testdir.CreateTestDir()
159	defer fin()
160
161	var output bytes.Buffer
162	var reportOutput bytes.Buffer
163
164	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 0, true, nil)
165	ui.SetIgnoreDirPaths([]string{"/xxx"})
166	err := ui.AnalyzePath("test_dir", nil)
167	assert.Nil(t, err)
168	err = ui.StartUILoop()
169
170	assert.Nil(t, err)
171	assert.Contains(t, reportOutput.String(), `"name":"test_dir"`)
172	assert.NotContains(t, reportOutput.String(), `"name":"nested"`)
173	assert.NotContains(t, reportOutput.String(), `"name":"file"`)
174}
175
176func TestAnalyzePathWithTopRoundTrip(t *testing.T) {
177	fin := testdir.CreateTestDir()
178	defer fin()
179
180	var output bytes.Buffer
181	var reportOutput bytes.Buffer
182
183	ui := CreateExportUI(&output, &reportOutput, false, false, false, 2, 0, false, nil)
184	ui.SetIgnoreDirPaths([]string{"/xxx"})
185	err := ui.AnalyzePath("test_dir", nil)
186	assert.Nil(t, err)
187	err = ui.StartUILoop()
188	assert.Nil(t, err)
189
190	result := reportOutput.Bytes()
191	assert.Contains(t, string(result), `"name":"file"`)
192	assert.Contains(t, string(result), `"name":"file2"`)
193
194	readDir, err := ReadAnalysis(bytes.NewReader(result))
195	assert.Nil(t, err)
196	assert.Equal(t, "test_dir", readDir.GetName())
197
198	var names []string
199	for f := range readDir.GetFiles(fs.SortByName, fs.SortAsc) {
200		names = append(names, f.GetName())
201	}
202	assert.Equal(t, []string{"file", "file2"}, names)
203}
204
205func TestAnalyzePathWithTopLargerThanFileCount(t *testing.T) {
206	fin := testdir.CreateTestDir()
207	defer fin()
208
209	var output bytes.Buffer
210	var reportOutput bytes.Buffer
211
212	ui := CreateExportUI(&output, &reportOutput, false, false, false, 100, 0, false, nil)
213	ui.SetIgnoreDirPaths([]string{"/xxx"})
214	err := ui.AnalyzePath("test_dir", nil)
215	assert.Nil(t, err)
216	err = ui.StartUILoop()
217
218	assert.Nil(t, err)
219	assert.Contains(t, reportOutput.String(), `"name":"file"`)
220	assert.Contains(t, reportOutput.String(), `"name":"file2"`)
221}
222
223func TestAnalyzePathWithDepthLargerThanTreeDepth(t *testing.T) {
224	fin := testdir.CreateTestDir()
225	defer fin()
226
227	var output bytes.Buffer
228	var reportOutput bytes.Buffer
229
230	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 100, false, nil)
231	ui.SetIgnoreDirPaths([]string{"/xxx"})
232	err := ui.AnalyzePath("test_dir", nil)
233	assert.Nil(t, err)
234	err = ui.StartUILoop()
235
236	assert.Nil(t, err)
237	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
238	assert.Contains(t, reportOutput.String(), `"name":"subnested"`)
239	assert.Contains(t, reportOutput.String(), `"name":"file"`)
240}
241
242func TestAnalyzePathWithSummarizeAndTop(t *testing.T) {
243	fin := testdir.CreateTestDir()
244	defer fin()
245
246	var output bytes.Buffer
247	var reportOutput bytes.Buffer
248
249	ui := CreateExportUI(&output, &reportOutput, false, false, false, 2, 0, true, nil)
250	ui.SetIgnoreDirPaths([]string{"/xxx"})
251	err := ui.AnalyzePath("test_dir", nil)
252	assert.Nil(t, err)
253	err = ui.StartUILoop()
254
255	assert.Nil(t, err)
256	assert.Contains(t, reportOutput.String(), `"name":"test_dir"`)
257	assert.NotContains(t, reportOutput.String(), `"name":"file"`)
258	assert.NotContains(t, reportOutput.String(), `"name":"nested"`)
259}
260
261func TestAnalyzePathWithSummarizeAndDepth(t *testing.T) {
262	fin := testdir.CreateTestDir()
263	defer fin()
264
265	var output bytes.Buffer
266	var reportOutput bytes.Buffer
267
268	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 1, true, nil)
269	ui.SetIgnoreDirPaths([]string{"/xxx"})
270	err := ui.AnalyzePath("test_dir", nil)
271	assert.Nil(t, err)
272	err = ui.StartUILoop()
273
274	assert.Nil(t, err)
275	assert.Contains(t, reportOutput.String(), `"name":"test_dir"`)
276	assert.NotContains(t, reportOutput.String(), `"name":"nested"`)
277	assert.NotContains(t, reportOutput.String(), `"name":"file"`)
278}
279
280func TestLimitDirByDepthWithNonDir(t *testing.T) {
281	var output bytes.Buffer
282	var reportOutput bytes.Buffer
283
284	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 1, false, nil)
285	file := &analyze.File{Name: "file"}
286	result := ui.limitDirByDepth(file, 0)
287
288	assert.Equal(t, file, result)
289}
290
291func TestAnalyzePathWithDepthZeroIsIgnored(t *testing.T) {
292	fin := testdir.CreateTestDir()
293	defer fin()
294
295	var output bytes.Buffer
296	var reportOutput bytes.Buffer
297
298	ui := CreateExportUI(&output, &reportOutput, false, false, false, 0, 0, false, nil)
299	ui.SetIgnoreDirPaths([]string{"/xxx"})
300	err := ui.AnalyzePath("test_dir", nil)
301	assert.Nil(t, err)
302	err = ui.StartUILoop()
303
304	assert.Nil(t, err)
305	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
306	assert.Contains(t, reportOutput.String(), `"name":"subnested"`)
307	assert.Contains(t, reportOutput.String(), `"name":"file"`)
308}
309
310func TestAnalyzePathWithProgress(t *testing.T) {
311	fin := testdir.CreateTestDir()
312	defer fin()
313
314	var output bytes.Buffer
315	var reportOutput bytes.Buffer
316
317	ui := CreateExportUI(&output, &reportOutput, true, true, true, 0, 0, false, nil)
318	ui.SetIgnoreDirPaths([]string{"/xxx"})
319	err := ui.AnalyzePath("test_dir", nil)
320	assert.Nil(t, err)
321	err = ui.StartUILoop()
322
323	assert.Nil(t, err)
324	assert.Contains(t, reportOutput.String(), `"name":"nested"`)
325}
326
327func TestExportProgressClearsLineWithoutPadding(t *testing.T) {
328	var output bytes.Buffer
329	ui := CreateExportUI(&output, io.Discard, false, true, false, 0, 0, false, nil)
330
331	written := make(chan struct{})
332	go func() {
333		ui.writtenChan <- struct{}{}
334		close(written)
335	}()
336
337	ui.updateProgress()
338	<-written
339
340	assert.Contains(t, output.String(), "\x1b[2K")
341	assert.NotContains(t, output.String(), strings.Repeat(" ", 100))
342}
343
344func TestShowDevices(t *testing.T) {
345	var output bytes.Buffer
346	var reportOutput bytes.Buffer
347
348	ui := CreateExportUI(&output, &reportOutput, false, true, false, 0, 0, false, nil)
349	err := ui.ListDevices(device.Getter)
350
351	assert.Contains(t, err.Error(), "not supported")
352}
353
354func TestReadAnalysisWhileExporting(t *testing.T) {
355	var output bytes.Buffer
356	var reportOutput bytes.Buffer
357
358	ui := CreateExportUI(&output, &reportOutput, false, true, false, 0, 0, false, nil)
359	err := ui.ReadAnalysis(&output)
360
361	assert.Contains(t, err.Error(), "not possible while exporting")
362}
363
364func TestExportToFile(t *testing.T) {
365	fin := testdir.CreateTestDir()
366	defer fin()
367
368	reportOutput, err := os.OpenFile("output.json", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
369	assert.Nil(t, err)
370	defer func() {
371		os.Remove("output.json")
372	}()
373
374	var output bytes.Buffer
375
376	ui := CreateExportUI(&output, reportOutput, false, true, false, 0, 0, false, nil)
377	ui.SetIgnoreDirPaths([]string{"/xxx"})
378	err = ui.AnalyzePath("test_dir", nil)
379	assert.Nil(t, err)
380	err = ui.StartUILoop()
381	assert.Nil(t, err)
382
383	reportOutput, err = os.OpenFile("output.json", os.O_RDONLY, 0o644)
384	assert.Nil(t, err)
385	_, err = reportOutput.Seek(0, 0)
386	assert.Nil(t, err)
387	buff := make([]byte, 200)
388	_, err = reportOutput.Read(buff)
389	assert.Nil(t, err)
390
391	assert.Contains(t, string(buff), `"name":"nested"`)
392}
393
394func TestExportToFileWithTop(t *testing.T) {
395	fin := testdir.CreateTestDir()
396	defer fin()
397	defer func() {
398		os.Remove("output.json")
399	}()
400
401	reportOutput, err := os.OpenFile("output.json", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
402	assert.Nil(t, err)
403
404	var output bytes.Buffer
405
406	ui := CreateExportUI(&output, reportOutput, false, true, false, 2, 0, false, nil)
407	ui.SetIgnoreDirPaths([]string{"/xxx"})
408	err = ui.AnalyzePath("test_dir", nil)
409	assert.Nil(t, err)
410	err = ui.StartUILoop()
411	assert.Nil(t, err)
412
413	buff, err := os.ReadFile("output.json")
414	assert.Nil(t, err)
415
416	assert.Contains(t, string(buff), `"name":"file"`)
417	assert.Contains(t, string(buff), `"name":"file2"`)
418	assert.NotContains(t, string(buff), `"name":"nested"`)
419}
420
421func TestExportToFileWithDepth(t *testing.T) {
422	fin := testdir.CreateTestDir()
423	defer fin()
424	defer func() {
425		os.Remove("output.json")
426	}()
427
428	reportOutput, err := os.OpenFile("output.json", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
429	assert.Nil(t, err)
430
431	var output bytes.Buffer
432
433	ui := CreateExportUI(&output, reportOutput, false, true, false, 0, 2, false, nil)
434	ui.SetIgnoreDirPaths([]string{"/xxx"})
435	err = ui.AnalyzePath("test_dir", nil)
436	assert.Nil(t, err)
437	err = ui.StartUILoop()
438	assert.Nil(t, err)
439
440	reportOutput, err = os.OpenFile("output.json", os.O_RDONLY, 0o644)
441	assert.Nil(t, err)
442	_, err = reportOutput.Seek(0, 0)
443	assert.Nil(t, err)
444	buff := make([]byte, 400)
445	_, err = reportOutput.Read(buff)
446	assert.Nil(t, err)
447
448	assert.Contains(t, string(buff), `"name":"nested"`)
449	assert.Contains(t, string(buff), `"name":"file2"`)
450	assert.Contains(t, string(buff), `"name":"subnested"`)
451
452	_, err = reportOutput.Seek(0, 0)
453	assert.Nil(t, err)
454	readDir, err := ReadAnalysis(reportOutput)
455	assert.Nil(t, err)
456	assert.Equal(t, "test_dir", readDir.GetName())
457}
458
459func TestFormatSize(t *testing.T) {
460	var output bytes.Buffer
461	var reportOutput bytes.Buffer
462
463	ui := CreateExportUI(&output, &reportOutput, false, true, false, 0, 0, false, nil)
464
465	assert.Contains(t, ui.formatSize(1), "B")
466	assert.Contains(t, ui.formatSize(1<<10+1), "KiB")
467	assert.Contains(t, ui.formatSize(1<<20+1), "MiB")
468	assert.Contains(t, ui.formatSize(1<<30+1), "GiB")
469	assert.Contains(t, ui.formatSize(1<<40+1), "TiB")
470	assert.Contains(t, ui.formatSize(1<<50+1), "PiB")
471	assert.Contains(t, ui.formatSize(1<<60+1), "EiB")
472	assert.Contains(t, ui.formatSize(-1<<10-1), "KiB")
473}
474
475func TestFormatSizeWithBlockSizeEnvironment(t *testing.T) {
476	t.Setenv("BLOCK_SIZE", "1K")
477	var output bytes.Buffer
478	var reportOutput bytes.Buffer
479
480	ui := CreateExportUI(&output, &reportOutput, false, true, false, 0, 0, false, nil)
481	assert.Equal(t, "2", ui.formatSize(1025))
482}
483
484func TestFormatSizeDec(t *testing.T) {
485	var output bytes.Buffer
486	var reportOutput bytes.Buffer
487
488	ui := CreateExportUI(&output, &reportOutput, false, true, true, 0, 0, false, nil)
489
490	assert.Contains(t, ui.formatSize(1), "B")
491	assert.Contains(t, ui.formatSize(1<<10+1), "kB")
492	assert.Contains(t, ui.formatSize(1<<20+1), "MB")
493	assert.Contains(t, ui.formatSize(1<<30+1), "GB")
494	assert.Contains(t, ui.formatSize(1<<40+1), "TB")
495	assert.Contains(t, ui.formatSize(1<<50+1), "PB")
496	assert.Contains(t, ui.formatSize(1<<60+1), "EB")
497	assert.Contains(t, ui.formatSize(-1<<10-1), "kB")
498}
499
500func TestAnalyzePathsRejectsMultipleDirs(t *testing.T) {
501	buff := bytes.NewBuffer(make([]byte, 10))
502	ui := CreateExportUI(buff, buff, false, false, false, 0, 0, false, nil)
503
504	err := ui.AnalyzePaths([]string{"test_dir", "other_dir"})
505
506	assert.ErrorContains(t, err, "more than one directory is not supported")
507}