fork/gdu

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

ShivamB25feat: stop scanning and keep partial results (#606)99a7f2a

master
4.7 KiB189 linesraw
1package analyze
2
3import (
4	"os"
5	"path/filepath"
6	"testing"
7	"time"
8
9	"github.com/dundee/gdu/v5/internal/common"
10	"github.com/dundee/gdu/v5/internal/testdir"
11	"github.com/stretchr/testify/assert"
12	"github.com/stretchr/testify/require"
13)
14
15func TestParallelAnalyzerSetFollowSymlinks(t *testing.T) {
16	analyzer := CreateAnalyzer()
17	analyzer.SetFollowSymlinks(true)
18	assert.True(t, analyzer.followSymlinks)
19	analyzer.SetFollowSymlinks(false)
20	assert.False(t, analyzer.followSymlinks)
21}
22
23func TestParallelAnalyzerSetShowAnnexedSize(t *testing.T) {
24	analyzer := CreateAnalyzer()
25	analyzer.SetShowAnnexedSize(true)
26	assert.True(t, analyzer.gitAnnexedSize)
27	analyzer.SetShowAnnexedSize(false)
28	assert.False(t, analyzer.gitAnnexedSize)
29}
30
31func TestGetDirFlagWithError(t *testing.T) {
32	flag := getDirFlag(os.ErrNotExist, 5)
33	assert.Equal(t, '!', flag)
34}
35
36func TestGetDirFlagWithEmptyDir(t *testing.T) {
37	flag := getDirFlag(nil, 0)
38	assert.Equal(t, 'e', flag)
39}
40
41func TestGetDirFlagWithNormalDir(t *testing.T) {
42	flag := getDirFlag(nil, 5)
43	assert.Equal(t, ' ', flag)
44}
45
46func TestGetFlagWithSymlink(t *testing.T) {
47	// Create a temporary symlink
48	symlinkPath := "/tmp/test_symlink"
49	defer os.Remove(symlinkPath)
50
51	err := os.Symlink("/tmp", symlinkPath)
52	assert.NoError(t, err)
53
54	info, err := os.Lstat(symlinkPath)
55	assert.NoError(t, err)
56
57	flag := getFlag(info)
58	assert.Equal(t, '@', flag)
59}
60
61func TestGetFlagWithRegularFile(t *testing.T) {
62	fin := testdir.CreateTestDir()
63	defer fin()
64
65	info, err := os.Stat("test_dir/nested/file2")
66	assert.NoError(t, err)
67
68	flag := getFlag(info)
69	assert.Equal(t, ' ', flag)
70}
71
72func TestParallelAnalyzerUpdateProgress(t *testing.T) {
73	analyzer := CreateAnalyzer()
74
75	// Start the progress updater
76	go analyzer.UpdateProgress()
77
78	// Set some progress via atomics
79	analyzer.progressCurrentItemName.Store("test")
80	analyzer.progressItemCount.Add(5)
81	analyzer.progressTotalUsage.Add(100)
82
83	// Wait a bit for the progress to be processed
84	time.Sleep(100 * time.Millisecond)
85
86	// Send done signal
87	analyzer.progressDoneChan <- struct{}{}
88
89	// Wait for the updater to finish
90	time.Sleep(10 * time.Millisecond)
91}
92
93func TestParallelAnalyzerUpdateProgressWithDefaultCase(t *testing.T) {
94	analyzer := CreateAnalyzer()
95
96	// Start the progress updater
97	go analyzer.UpdateProgress()
98
99	// Set some progress via atomics
100	analyzer.progressCurrentItemName.Store("test")
101	analyzer.progressItemCount.Add(5)
102	analyzer.progressTotalUsage.Add(100)
103
104	// Wait a bit for the progress to be processed
105	time.Sleep(100 * time.Millisecond)
106
107	// Update progress again
108	analyzer.progressCurrentItemName.Store("test2")
109	analyzer.progressItemCount.Add(3)
110	analyzer.progressTotalUsage.Store(50)
111
112	// Wait a bit for the progress to be processed
113	time.Sleep(100 * time.Millisecond)
114
115	// Send done signal
116	analyzer.progressDoneChan <- struct{}{}
117
118	// Wait for the updater to finish
119	time.Sleep(10 * time.Millisecond)
120}
121
122func TestParallelAnalyzerAnalyzeDirWithIgnoreDir(t *testing.T) {
123	fin := testdir.CreateTestDir()
124	defer fin()
125
126	analyzer := CreateAnalyzer()
127	dir := analyzer.AnalyzeDir(
128		"test_dir", func(name, _ string) bool { return name == "nested" }, func(_ string) bool { return false },
129	).(*Dir)
130
131	analyzer.GetDone().Wait()
132
133	assert.NotNil(t, dir)
134	assert.Equal(t, "test_dir", dir.Name)
135	// Should have fewer items since nested directory was ignored
136	assert.Less(t, dir.ItemCount, int64(5))
137}
138
139func TestAnalyzersMarkFilesystemErrors(t *testing.T) {
140	factories := []struct {
141		name string
142		new  func() common.Analyzer
143	}{
144		{name: "parallel", new: func() common.Analyzer { return CreateAnalyzer() }},
145		{name: "stable parallel", new: func() common.Analyzer { return CreateStableOrderAnalyzer() }},
146		{name: "sequential", new: func() common.Analyzer { return CreateSeqAnalyzer() }},
147	}
148
149	for _, factory := range factories {
150		t.Run(factory.name, func(t *testing.T) {
151			t.Run("disappeared file", func(t *testing.T) {
152				root := t.TempDir()
153				filePath := filepath.Join(root, "removed-during-scan")
154				require.NoError(t, os.WriteFile(filePath, []byte("data"), 0o600))
155
156				var removeErr error
157				dir := factory.new().AnalyzeDir(
158					root,
159					func(_, _ string) bool { return false },
160					func(string) bool {
161						removeErr = os.Remove(filePath)
162						return false
163					},
164				)
165
166				require.NoError(t, removeErr)
167				assert.Equal(t, '!', dir.GetFlag())
168			})
169
170			t.Run("broken symlink", func(t *testing.T) {
171				root := t.TempDir()
172				err := os.Symlink(filepath.Join(root, "missing-target"), filepath.Join(root, "broken-link"))
173				if err != nil {
174					t.Skipf("creating symlink: %v", err)
175				}
176
177				analyzer := factory.new()
178				analyzer.SetFollowSymlinks(true)
179				dir := analyzer.AnalyzeDir(
180					root,
181					func(_, _ string) bool { return false },
182					func(string) bool { return false },
183				)
184
185				assert.Equal(t, '!', dir.GetFlag())
186			})
187		})
188	}
189}