fork/gdu

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

cosmolifeat: move items to XDG trash with D key (#12) (#608)9ca5c60

subvolume
10.9 KiB442 linesraw
1//go:build !windows && !darwin
2
3package remove
4
5import (
6	"fmt"
7	"os"
8	"path/filepath"
9	"sync"
10	"syscall"
11	"testing"
12
13	"github.com/stretchr/testify/assert"
14	"github.com/stretchr/testify/require"
15
16	"github.com/dundee/gdu/v5/internal/testdir"
17	"github.com/dundee/gdu/v5/pkg/analyze"
18	"github.com/dundee/gdu/v5/pkg/fs"
19)
20
21func mockTrashOS(t *testing.T, configure func(*trashOSOps)) {
22	t.Helper()
23	original := trashOS
24	t.Cleanup(func() { trashOS = original })
25	configure(&trashOS)
26}
27
28func TestMoveItemToTrash(t *testing.T) {
29	fin := testdir.CreateTestDir()
30	defer fin()
31
32	xdg := t.TempDir()
33	t.Setenv("XDG_DATA_HOME", xdg)
34
35	dir := &analyze.Dir{
36		File: &analyze.File{
37			Name:  "test_dir",
38			Size:  5,
39			Usage: 12,
40		},
41		ItemCount: 3,
42		BasePath:  ".",
43	}
44	subdir := &analyze.Dir{
45		File: &analyze.File{
46			Name:   "nested",
47			Size:   4,
48			Usage:  8,
49			Parent: dir,
50		},
51		ItemCount: 2,
52	}
53	file := &analyze.File{
54		Name:   "file2",
55		Size:   3,
56		Usage:  4,
57		Parent: subdir,
58	}
59	dir.Files = fs.Files{subdir}
60	subdir.Files = fs.Files{file}
61
62	err := MoveItemToTrash(subdir, file)
63	require.NoError(t, err)
64
65	_, err = os.Stat("test_dir/nested/file2")
66	assert.True(t, os.IsNotExist(err))
67
68	trashFile := filepath.Join(xdg, "Trash", "files", "file2")
69	_, err = os.Stat(trashFile)
70	assert.NoError(t, err)
71
72	infoPath := filepath.Join(xdg, "Trash", "info", "file2.trashinfo")
73	data, err := os.ReadFile(infoPath)
74	require.NoError(t, err)
75	assert.Contains(t, string(data), "[Trash Info]")
76	assert.Contains(t, string(data), "DeletionDate=")
77	wantPath, err := filepath.Abs("test_dir/nested/file2")
78	require.NoError(t, err)
79	assert.Contains(t, string(data), "Path="+escapeTrashPath(wantPath))
80
81	assert.Equal(t, 0, len(subdir.Files))
82	assert.Equal(t, int64(1), subdir.ItemCount)
83}
84
85func TestMoveItemToTrashNameConflict(t *testing.T) {
86	fin := testdir.CreateTestDir()
87	defer fin()
88
89	xdg := t.TempDir()
90	t.Setenv("XDG_DATA_HOME", xdg)
91
92	trashFiles := filepath.Join(xdg, "Trash", "files")
93	require.NoError(t, os.MkdirAll(trashFiles, 0o700))
94	require.NoError(t, os.WriteFile(filepath.Join(trashFiles, "file2"), []byte("old"), 0o600))
95
96	dir := &analyze.Dir{
97		File: &analyze.File{
98			Name:  "test_dir",
99			Size:  5,
100			Usage: 12,
101		},
102		ItemCount: 3,
103		BasePath:  ".",
104	}
105	subdir := &analyze.Dir{
106		File: &analyze.File{
107			Name:   "nested",
108			Size:   4,
109			Usage:  8,
110			Parent: dir,
111		},
112		ItemCount: 2,
113	}
114	file := &analyze.File{
115		Name:   "file2",
116		Size:   3,
117		Usage:  4,
118		Parent: subdir,
119	}
120	dir.Files = fs.Files{subdir}
121	subdir.Files = fs.Files{file}
122
123	err := MoveItemToTrash(subdir, file)
124	require.NoError(t, err)
125
126	_, err = os.Stat("test_dir/nested/file2")
127	assert.True(t, os.IsNotExist(err))
128
129	oldData, err := os.ReadFile(filepath.Join(trashFiles, "file2"))
130	require.NoError(t, err)
131	assert.Equal(t, "old", string(oldData))
132
133	movedData, err := os.ReadFile(filepath.Join(trashFiles, "file2.2"))
134	require.NoError(t, err)
135	assert.Equal(t, "go", string(movedData))
136
137	infoPath := filepath.Join(xdg, "Trash", "info", "file2.2.trashinfo")
138	_, err = os.Stat(infoPath)
139	assert.NoError(t, err)
140
141	assert.Equal(t, 0, len(subdir.Files))
142	assert.Equal(t, int64(1), subdir.ItemCount)
143}
144
145func TestReserveTrashInfoUsesUniqueNamesConcurrently(t *testing.T) {
146	trashRoot := t.TempDir()
147	filesDir := filepath.Join(trashRoot, "files")
148	infoDir := filepath.Join(trashRoot, "info")
149	require.NoError(t, os.MkdirAll(filesDir, 0o700))
150	require.NoError(t, os.MkdirAll(infoDir, 0o700))
151
152	const workers = 16
153	start := make(chan struct{})
154	names := make(chan string, workers)
155	errs := make(chan error, workers)
156
157	var wg sync.WaitGroup
158	for i := range workers {
159		wg.Add(1)
160		go func() {
161			defer wg.Done()
162			<-start
163
164			name, _, err := reserveTrashInfo(
165				filesDir,
166				infoDir,
167				"same-name",
168				filepath.Join("/source", fmt.Sprintf("%d", i), "same-name"),
169			)
170			if err != nil {
171				errs <- err
172				return
173			}
174			names <- name
175		}()
176	}
177
178	close(start)
179	wg.Wait()
180	close(names)
181	close(errs)
182
183	for err := range errs {
184		require.NoError(t, err)
185	}
186
187	uniqueNames := make(map[string]struct{}, workers)
188	for name := range names {
189		uniqueNames[name] = struct{}{}
190	}
191	assert.Len(t, uniqueNames, workers)
192
193	entries, err := os.ReadDir(infoDir)
194	require.NoError(t, err)
195	assert.Len(t, entries, workers)
196}
197
198func TestCopyRecursivelyPreservesSymlink(t *testing.T) {
199	root := t.TempDir()
200	target := filepath.Join(root, "target")
201	src := filepath.Join(root, "link")
202	dst := filepath.Join(root, "copied-link")
203
204	require.NoError(t, os.WriteFile(target, []byte("target contents"), 0o600))
205	require.NoError(t, os.Symlink("target", src))
206
207	require.NoError(t, copyRecursively(src, dst))
208
209	info, err := os.Lstat(dst)
210	require.NoError(t, err)
211	assert.NotZero(t, info.Mode()&os.ModeSymlink)
212
213	linkTarget, err := os.Readlink(dst)
214	require.NoError(t, err)
215	assert.Equal(t, "target", linkTarget)
216}
217
218func TestMovePathDoesNotOverwriteExisting(t *testing.T) {
219	root := t.TempDir()
220	src := filepath.Join(root, "src")
221	dst := filepath.Join(root, "dst")
222	require.NoError(t, os.WriteFile(src, []byte("new"), 0o600))
223	require.NoError(t, os.WriteFile(dst, []byte("old"), 0o600))
224
225	err := movePath(src, dst)
226	require.Error(t, err)
227	assert.True(t, os.IsExist(err))
228
229	data, err := os.ReadFile(dst)
230	require.NoError(t, err)
231	assert.Equal(t, "old", string(data))
232
233	_, err = os.Stat(src)
234	assert.NoError(t, err)
235}
236
237func TestTrashDirUsesHomeWhenXDGUnset(t *testing.T) {
238	t.Setenv("XDG_DATA_HOME", "")
239	dir, err := trashDir()
240	require.NoError(t, err)
241	home, err := os.UserHomeDir()
242	require.NoError(t, err)
243	assert.Equal(t, filepath.Join(home, ".local", "share", "Trash"), dir)
244}
245
246func TestEscapeTrashPathPercentEncodesUnsafeBytes(t *testing.T) {
247	got := escapeTrashPath("/tmp/has space/%and\n")
248	assert.Equal(t, "/tmp/has%20space/%25and%0A", got)
249}
250
251func TestIsEXDEV(t *testing.T) {
252	assert.True(t, isEXDEV(syscall.EXDEV))
253	assert.True(t, isEXDEV(&os.PathError{Op: "rename", Err: syscall.EXDEV}))
254	assert.False(t, isEXDEV(os.ErrExist))
255}
256
257func TestCopyRecursivelyCopiesRegularFileAndDirectory(t *testing.T) {
258	root := t.TempDir()
259	srcDir := filepath.Join(root, "src")
260	dstDir := filepath.Join(root, "dst")
261	require.NoError(t, os.Mkdir(srcDir, 0o700))
262	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "a.txt"), []byte("hello"), 0o600))
263	require.NoError(t, os.Mkdir(filepath.Join(srcDir, "sub"), 0o700))
264	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "sub", "b.txt"), []byte("world"), 0o600))
265
266	require.NoError(t, copyRecursively(srcDir, dstDir))
267
268	data, err := os.ReadFile(filepath.Join(dstDir, "a.txt"))
269	require.NoError(t, err)
270	assert.Equal(t, "hello", string(data))
271	data, err = os.ReadFile(filepath.Join(dstDir, "sub", "b.txt"))
272	require.NoError(t, err)
273	assert.Equal(t, "world", string(data))
274}
275
276func TestCopyRecursivelyMissingSource(t *testing.T) {
277	err := copyRecursively(filepath.Join(t.TempDir(), "missing"), filepath.Join(t.TempDir(), "dst"))
278	require.Error(t, err)
279}
280
281func TestMovePathFallsBackOnEXDEV(t *testing.T) {
282	mockTrashOS(t, func(ops *trashOSOps) {
283		ops.rename = func(oldpath, newpath string) error {
284			return &os.PathError{Op: "rename", Path: oldpath, Err: syscall.EXDEV}
285		}
286	})
287
288	root := t.TempDir()
289	src := filepath.Join(root, "src")
290	dst := filepath.Join(root, "dst")
291	require.NoError(t, os.WriteFile(src, []byte("payload"), 0o600))
292
293	require.NoError(t, movePath(src, dst))
294
295	data, err := os.ReadFile(dst)
296	require.NoError(t, err)
297	assert.Equal(t, "payload", string(data))
298	_, err = os.Stat(src)
299	assert.True(t, os.IsNotExist(err))
300}
301
302func TestMovePathEXDEVCleanupOnCopyFailure(t *testing.T) {
303	mockTrashOS(t, func(ops *trashOSOps) {
304		ops.rename = func(oldpath, newpath string) error {
305			return &os.PathError{Op: "rename", Path: oldpath, Err: syscall.EXDEV}
306		}
307	})
308
309	root := t.TempDir()
310	src := filepath.Join(root, "missing-src")
311	dst := filepath.Join(root, "dst")
312
313	err := movePath(src, dst)
314	require.Error(t, err)
315	_, err = os.Stat(dst)
316	assert.True(t, os.IsNotExist(err))
317}
318
319func TestMoveItemToTrashRetriesWhenDestinationAppears(t *testing.T) {
320	fin := testdir.CreateTestDir()
321	defer fin()
322
323	xdg := t.TempDir()
324	t.Setenv("XDG_DATA_HOME", xdg)
325
326	attempts := 0
327	mockTrashOS(t, func(ops *trashOSOps) {
328		ops.rename = func(oldpath, newpath string) error {
329			attempts++
330			if attempts == 1 {
331				return os.ErrExist
332			}
333			return renameNoReplace(oldpath, newpath)
334		}
335	})
336
337	dir := &analyze.Dir{
338		File: &analyze.File{
339			Name:  "test_dir",
340			Size:  5,
341			Usage: 12,
342		},
343		ItemCount: 3,
344		BasePath:  ".",
345	}
346	subdir := &analyze.Dir{
347		File: &analyze.File{
348			Name:   "nested",
349			Size:   4,
350			Usage:  8,
351			Parent: dir,
352		},
353		ItemCount: 2,
354	}
355	file := &analyze.File{
356		Name:   "file2",
357		Size:   3,
358		Usage:  4,
359		Parent: subdir,
360	}
361	dir.Files = fs.Files{subdir}
362	subdir.Files = fs.Files{file}
363
364	require.NoError(t, MoveItemToTrash(subdir, file))
365	assert.GreaterOrEqual(t, attempts, 2)
366
367	_, err := os.Stat("test_dir/nested/file2")
368	assert.True(t, os.IsNotExist(err))
369	assert.Equal(t, 0, len(subdir.Files))
370}
371
372func TestReserveTrashInfoSkipsExistingTrashinfo(t *testing.T) {
373	trashRoot := t.TempDir()
374	filesDir := filepath.Join(trashRoot, "files")
375	infoDir := filepath.Join(trashRoot, "info")
376	require.NoError(t, os.MkdirAll(filesDir, 0o700))
377	require.NoError(t, os.MkdirAll(infoDir, 0o700))
378	require.NoError(t, os.WriteFile(filepath.Join(infoDir, "item.trashinfo"), []byte("stale"), 0o600))
379
380	name, infoPath, err := reserveTrashInfo(filesDir, infoDir, "item", "/tmp/item")
381	require.NoError(t, err)
382	assert.Equal(t, "item.2", name)
383	assert.Equal(t, filepath.Join(infoDir, "item.2.trashinfo"), infoPath)
384}
385
386func TestMoveItemToTrashPropagatesMoveErrors(t *testing.T) {
387	fin := testdir.CreateTestDir()
388	defer fin()
389
390	xdg := t.TempDir()
391	t.Setenv("XDG_DATA_HOME", xdg)
392
393	mockTrashOS(t, func(ops *trashOSOps) {
394		ops.rename = func(oldpath, newpath string) error {
395			return os.ErrPermission
396		}
397	})
398
399	dir := &analyze.Dir{
400		File:      &analyze.File{Name: "test_dir", Size: 5, Usage: 12},
401		ItemCount: 3,
402		BasePath:  ".",
403	}
404	subdir := &analyze.Dir{
405		File:      &analyze.File{Name: "nested", Size: 4, Usage: 8, Parent: dir},
406		ItemCount: 2,
407	}
408	file := &analyze.File{Name: "file2", Size: 3, Usage: 4, Parent: subdir}
409	dir.Files = fs.Files{subdir}
410	subdir.Files = fs.Files{file}
411
412	err := MoveItemToTrash(subdir, file)
413	require.Error(t, err)
414	assert.ErrorIs(t, err, os.ErrPermission)
415	assert.FileExists(t, "test_dir/nested/file2")
416	assert.Len(t, subdir.Files, 1)
417}
418
419func TestCopyRecursivelyRejectsExistingDestination(t *testing.T) {
420	root := t.TempDir()
421	src := filepath.Join(root, "src")
422	dst := filepath.Join(root, "dst")
423	require.NoError(t, os.WriteFile(src, []byte("new"), 0o600))
424	require.NoError(t, os.WriteFile(dst, []byte("old"), 0o600))
425
426	err := copyRecursively(src, dst)
427	require.Error(t, err)
428	data, err := os.ReadFile(dst)
429	require.NoError(t, err)
430	assert.Equal(t, "old", string(data))
431}
432
433func TestCopyRecursivelyMkdirFailsWhenDestinationIsFile(t *testing.T) {
434	root := t.TempDir()
435	src := filepath.Join(root, "src")
436	dst := filepath.Join(root, "dst")
437	require.NoError(t, os.Mkdir(src, 0o700))
438	require.NoError(t, os.WriteFile(dst, []byte("file"), 0o600))
439
440	err := copyRecursively(src, dst)
441	require.Error(t, err)
442}