fork/gdu

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

Daniel Mildeperf: replace progress channel with atomic counters and ticker polling in all analyzers (#563)4faa51c

subvolume
4.7 KiB198 linesraw
1package analyze
2
3import (
4	"os"
5	"slices"
6	"testing"
7	"time"
8
9	"github.com/dundee/gdu/v5/internal/testdir"
10	"github.com/dundee/gdu/v5/pkg/fs"
11	"github.com/stretchr/testify/assert"
12)
13
14func TestStoredAnalyzerGetProgress(t *testing.T) {
15	analyzer := CreateStoredAnalyzer("/tmp/test")
16	progress := analyzer.GetProgress()
17	assert.Equal(t, int64(0), progress.ItemCount)
18}
19
20func TestStoredAnalyzerSetFollowSymlinks(t *testing.T) {
21	analyzer := CreateStoredAnalyzer("/tmp/test")
22	analyzer.SetFollowSymlinks(true)
23	assert.True(t, analyzer.followSymlinks)
24	analyzer.SetFollowSymlinks(false)
25	assert.False(t, analyzer.followSymlinks)
26}
27
28func TestStoredAnalyzerSetShowAnnexedSize(t *testing.T) {
29	analyzer := CreateStoredAnalyzer("/tmp/test")
30	analyzer.SetShowAnnexedSize(true)
31	assert.True(t, analyzer.gitAnnexedSize)
32	analyzer.SetShowAnnexedSize(false)
33	assert.False(t, analyzer.gitAnnexedSize)
34}
35
36func TestStoredDirGetFilesCached(t *testing.T) {
37	// Test when files are already cached
38	files := make(fs.Files, 0)
39	dir := &StoredDir{
40		Dir: &Dir{
41			File: &File{
42				Name: "test",
43			},
44			BasePath: "/test",
45		},
46		cachedFiles: files,
47	}
48
49	result := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
50	assert.Equal(t, len(files), len(result))
51}
52
53func TestStoredDirRemoveFile(t *testing.T) {
54	// Test RemoveFile functionality
55	fin := testdir.CreateTestDir()
56	defer fin()
57
58	analyzer := CreateStoredAnalyzer("/tmp/test")
59	dir := analyzer.AnalyzeDir(
60		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
61	).(*StoredDir)
62
63	analyzer.GetDone().Wait()
64
65	// Remove a file
66	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
67	if len(files) > 0 {
68		dir.RemoveFile(files[0])
69	}
70}
71
72func TestStoredDirUpdateStats(t *testing.T) {
73	// Test UpdateStats functionality
74	fin := testdir.CreateTestDir()
75	defer fin()
76
77	analyzer := CreateStoredAnalyzer("/tmp/test")
78	dir := analyzer.AnalyzeDir(
79		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
80	).(*StoredDir)
81
82	analyzer.GetDone().Wait()
83
84	dir.UpdateStats(make(fs.HardLinkedItems))
85}
86
87func TestStoredDirUpdateStatsWithMtimeUpdate(t *testing.T) {
88	// Test UpdateStats with mtime updates
89	fin := testdir.CreateTestDir()
90	defer fin()
91
92	analyzer := CreateStoredAnalyzer("/tmp/test")
93	dir := analyzer.AnalyzeDir(
94		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
95	).(*StoredDir)
96
97	analyzer.GetDone().Wait()
98
99	// Create a file with newer mtime
100	file := &File{
101		Name:  "newfile",
102		Mtime: time.Now().Add(time.Hour),
103	}
104	dir.AddFile(file)
105
106	dir.UpdateStats(make(fs.HardLinkedItems))
107}
108
109func TestStoredDirUpdateStatsWithFlagUpdate(t *testing.T) {
110	// Test UpdateStats with flag updates
111	fin := testdir.CreateTestDir()
112	defer fin()
113
114	analyzer := CreateStoredAnalyzer("/tmp/test")
115	dir := analyzer.AnalyzeDir(
116		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
117	).(*StoredDir)
118
119	analyzer.GetDone().Wait()
120
121	// Create a file with error flag
122	file := &File{
123		Name: "errorfile",
124		Flag: '!',
125	}
126	dir.AddFile(file)
127
128	dir.UpdateStats(make(fs.HardLinkedItems))
129	// Just test that UpdateStats runs without error
130	// The flag behavior depends on the specific implementation
131}
132
133func TestStoredDirUpdateStatsWithDotFlag(t *testing.T) {
134	// Test UpdateStats with dot flag
135	fin := testdir.CreateTestDir()
136	defer fin()
137
138	analyzer := CreateStoredAnalyzer("/tmp/test")
139	dir := analyzer.AnalyzeDir(
140		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
141	).(*StoredDir)
142
143	analyzer.GetDone().Wait()
144
145	// Create a file with dot flag
146	file := &File{
147		Name: "dotfile",
148		Flag: '.',
149	}
150	dir.AddFile(file)
151
152	dir.UpdateStats(make(fs.HardLinkedItems))
153	assert.Equal(t, '.', dir.Flag)
154}
155
156func TestStoredAnalyzerWithZip(t *testing.T) {
157	fin := testdir.CreateTestDir()
158	defer fin()
159
160	// Create valid zip
161	createTestZipFile(t, "test_dir/valid.zip")
162
163	// Create invalid zip
164	f, err := os.Create("test_dir/invalid.zip")
165	assert.NoError(t, err)
166	_, err = f.WriteString("this is not a zip file")
167	assert.NoError(t, err)
168	f.Close()
169
170	analyzer := CreateStoredAnalyzer("/tmp/test")
171	analyzer.SetArchiveBrowsing(true)
172	dir := analyzer.AnalyzeDir(
173		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
174	).(*StoredDir)
175
176	analyzer.GetDone().Wait()
177
178	// Check valid.zip
179	var validZip fs.Item
180	var invalidZip fs.Item
181
182	for _, file := range dir.Files {
183		if file.GetName() == "valid.zip" {
184			validZip = file
185		}
186		if file.GetName() == "invalid.zip" {
187			invalidZip = file
188		}
189	}
190
191	assert.NotNil(t, validZip)
192	assert.True(t, validZip.IsDir())
193	assert.Greater(t, validZip.GetSize(), int64(0))
194
195	assert.NotNil(t, invalidZip)
196	assert.False(t, invalidZip.IsDir())
197	assert.Equal(t, int64(22), invalidZip.GetSize())
198}