fork/gdu

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

ShivamB25feat: customize JSON export attributes (#605)d062e88

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