fork/gdu

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

yurenchen000Feat: Show symlink target #260 (#612)1eaa266

master
5.3 KiB184 linesraw
1package analyze
2
3import (
4	"os"
5	"path/filepath"
6	"testing"
7
8	"github.com/dundee/gdu/v5/internal/testdir"
9	"github.com/dundee/gdu/v5/pkg/fs"
10	"github.com/stretchr/testify/assert"
11)
12
13func TestReadSymlinkTarget(t *testing.T) {
14	dir := t.TempDir()
15	linkPath := filepath.Join(dir, "link")
16	err := os.Symlink("target/path", linkPath)
17	assert.Nil(t, err)
18
19	info, err := os.Lstat(linkPath)
20	assert.Nil(t, err)
21
22	assert.Equal(t, "target/path", readSymlinkTarget(info.Mode(), linkPath))
23}
24
25func TestReadSymlinkTargetNonSymlink(t *testing.T) {
26	dir := t.TempDir()
27	filePath := filepath.Join(dir, "file")
28	err := os.WriteFile(filePath, []byte("hi"), 0o600)
29	assert.Nil(t, err)
30
31	info, err := os.Lstat(filePath)
32	assert.Nil(t, err)
33
34	assert.Equal(t, "", readSymlinkTarget(info.Mode(), filePath))
35}
36
37func TestReadSymlinkTargetUnreadable(t *testing.T) {
38	// A path flagged as a symlink but with no readable link returns empty.
39	assert.Equal(t, "", readSymlinkTarget(os.ModeSymlink, "nonexistent/link"))
40}
41
42// findSymlink locates a file item named "link" anywhere in the analyzed tree.
43func findSymlink(item fs.Item) fs.Item {
44	if !item.IsDir() && item.GetName() == "link" {
45		return item
46	}
47	for child := range item.GetFiles(fs.SortByName, fs.SortAsc) {
48		if found := findSymlink(child); found != nil {
49			return found
50		}
51	}
52	return nil
53}
54
55// analyzerFactory builds a fresh analyzer that returns the full tree.
56type analyzerFactory struct {
57	name    string
58	analyze func(path string) fs.Item
59}
60
61func symlinkTreeAnalyzers() []analyzerFactory {
62	ignoreDir := func(_, _ string) bool { return false }
63	ignoreType := func(_ string) bool { return false }
64	return []analyzerFactory{
65		{"parallel", func(path string) fs.Item {
66			a := CreateAnalyzer()
67			item := a.AnalyzeDir(path, ignoreDir, ignoreType)
68			a.GetDone().Wait()
69			return item
70		}},
71		{"sequential", func(path string) fs.Item {
72			a := CreateSeqAnalyzer()
73			item := a.AnalyzeDir(path, ignoreDir, ignoreType)
74			a.GetDone().Wait()
75			return item
76		}},
77		{"stable", func(path string) fs.Item {
78			a := CreateStableOrderAnalyzer()
79			item := a.AnalyzeDir(path, ignoreDir, ignoreType)
80			a.GetDone().Wait()
81			return item
82		}},
83	}
84}
85
86// TestAnalyzersPopulateSymlinkTarget guards against the shotgun-surgery hazard:
87// every tree-returning analyzer must set the symlink target on File items.
88func TestAnalyzersPopulateSymlinkTarget(t *testing.T) {
89	for _, tc := range symlinkTreeAnalyzers() {
90		t.Run(tc.name, func(t *testing.T) {
91			fin := testdir.CreateTestDir()
92			defer fin()
93
94			err := os.Symlink("nested/file2", "test_dir/link")
95			assert.Nil(t, err)
96
97			tree := tc.analyze("test_dir")
98			link := findSymlink(tree)
99			assert.NotNil(t, link, "symlink item should be present in the tree")
100
101			si, ok := link.(fs.SymlinkItem)
102			assert.True(t, ok, "File must implement fs.SymlinkItem")
103			assert.Equal(t, "nested/file2", si.GetSymlinkTarget())
104			assert.Equal(t, "Symlink", link.GetType())
105		})
106	}
107}
108
109// TestTopDirAnalyzerPopulatesSymlinkTarget covers the non-interactive top-dir
110// analyzer, which returns SimpleDir items reconstructed on GetFiles.
111func TestTopDirAnalyzerPopulatesSymlinkTarget(t *testing.T) {
112	fin := testdir.CreateTestDir()
113	defer fin()
114
115	err := os.Symlink("nested/file2", "test_dir/link")
116	assert.Nil(t, err)
117
118	analyzer := CreateTopDirAnalyzer()
119	dir := analyzer.AnalyzeDir(
120		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
121	).(*SimpleDir)
122	analyzer.GetDone().Wait()
123
124	link := findSymlink(dir)
125	assert.NotNil(t, link, "symlink item should be present in the tree")
126	si, ok := link.(fs.SymlinkItem)
127	assert.True(t, ok, "File must implement fs.SymlinkItem")
128	assert.Equal(t, "nested/file2", si.GetSymlinkTarget())
129}
130
131// TestStoredAnalyzerPopulatesSymlinkTarget covers the stored analyzer, whose
132// items are scanned into the top-level dir before being persisted.
133func TestStoredAnalyzerPopulatesSymlinkTarget(t *testing.T) {
134	fin := testdir.CreateTestDir()
135	defer fin()
136
137	err := os.Symlink("nested/file2", "test_dir/link")
138	assert.Nil(t, err)
139
140	a := CreateStoredAnalyzer("/tmp/badger")
141	dir := a.AnalyzeDir(
142		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
143	).(*StoredDir)
144	a.GetDone().Wait()
145
146	idx, ok := dir.Files.FindByName("link")
147	assert.True(t, ok, "symlink item should be present in the tree")
148	si, ok := dir.Files[idx].(fs.SymlinkItem)
149	assert.True(t, ok, "File must implement fs.SymlinkItem")
150	assert.Equal(t, "nested/file2", si.GetSymlinkTarget())
151}
152
153func TestFollowSymlinkErr(t *testing.T) {
154	fin := testdir.CreateTestDir()
155	defer fin()
156
157	err := os.Mkdir("test_dir/empty", 0o644)
158	assert.Nil(t, err)
159
160	err = os.Symlink(
161		".git/annex/objects/qx/qX/SHA256E-s967858083--"+
162			"3e54803fded8dc3a9ea68b106f7b51e04e33c79b4a7b32a860f0b22d89af5c65.mp4/SHA256E-s967858083--"+
163			"3e54803fded8dc3a9ea68b106f7b51e04e33c79b4a7b32a860f0b22d89af5c65.mp4",
164		"test_dir/nested/file3")
165	assert.Nil(t, err)
166
167	err = os.Symlink(
168		"test_dir/nested",
169		"test_dir/some_dir")
170	assert.Nil(t, err)
171
172	_, err = followSymlink("xxx", false)
173	assert.ErrorContains(t, err, "no such file or directory")
174
175	_, err = followSymlink("test_dir/nested/file3", false)
176	assert.ErrorContains(t, err, "no such file or directory")
177
178	_, err = followSymlink("test_dir/nested/file3", true)
179	assert.NoError(t, err)
180
181	res, err := followSymlink("test_dir/some_dir", true)
182	assert.Equal(t, nil, res)
183	assert.NoError(t, err)
184}