fork/gdu

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

Daniel Mildefix: StoreDir fixes (#644)35cba00

master
35.4 KiB1204 linesraw
1//go:build (linux && !mips64 && !mipsle && !mips && !mips64le && !ppc64) || darwin || windows || (freebsd && !arm && !386) || (openbsd && !386) || (netbsd && !arm && !386 && !amd64)
2
3package analyze
4
5import (
6	"bytes"
7	"os"
8	"os/exec"
9	"path/filepath"
10	"runtime"
11	"slices"
12	"testing"
13	"time"
14
15	"github.com/dundee/gdu/v5/internal/testdir"
16	"github.com/dundee/gdu/v5/pkg/fs"
17	"github.com/stretchr/testify/assert"
18	"github.com/stretchr/testify/require"
19)
20
21func TestNewSqliteStorage(t *testing.T) {
22	dbPath := filepath.Join(t.TempDir(), "test.db")
23	storage, err := NewSqliteStorage(dbPath)
24	assert.NoError(t, err)
25	assert.NotNil(t, storage)
26	defer storage.Close()
27
28	// Test that the database is created
29	_, err = os.Stat(dbPath)
30	assert.NoError(t, err)
31}
32
33func TestNewSqliteStorageNestedDir(t *testing.T) {
34	dbPath := filepath.Join(t.TempDir(), "nested", "dir", "test.db")
35	storage, err := NewSqliteStorage(dbPath)
36	assert.NoError(t, err)
37	assert.NotNil(t, storage)
38	defer storage.Close()
39
40	// Test that the database is created
41	_, err = os.Stat(dbPath)
42	assert.NoError(t, err)
43}
44
45func TestSqliteStorageClose(t *testing.T) {
46	dbPath := filepath.Join(t.TempDir(), "test.db")
47	storage, err := NewSqliteStorage(dbPath)
48	assert.NoError(t, err)
49
50	err = storage.Close()
51	assert.NoError(t, err)
52
53	// Closing again should not error
54	err = storage.Close()
55	assert.NoError(t, err)
56}
57
58func TestSqliteStorageHasData(t *testing.T) {
59	dbPath := filepath.Join(t.TempDir(), "test.db")
60	storage, err := NewSqliteStorage(dbPath)
61	assert.NoError(t, err)
62	defer storage.Close()
63
64	// Initially no data
65	assert.False(t, storage.HasData())
66
67	// Insert an item
68	_, err = storage.InsertItem(nil, "root", true, 100, 100, time.Now(), 1, 0, ' ')
69	assert.NoError(t, err)
70
71	// Now has data
72	assert.True(t, storage.HasData())
73}
74
75func TestSqliteStorageClearItems(t *testing.T) {
76	dbPath := filepath.Join(t.TempDir(), "test.db")
77	storage, err := NewSqliteStorage(dbPath)
78	assert.NoError(t, err)
79	defer storage.Close()
80
81	// Insert an item
82	_, err = storage.InsertItem(nil, "root", true, 100, 100, time.Now(), 1, 0, ' ')
83	assert.NoError(t, err)
84	assert.True(t, storage.HasData())
85
86	// Clear items
87	err = storage.ClearItems()
88	assert.NoError(t, err)
89	assert.False(t, storage.HasData())
90}
91
92func TestSqliteStorageMetadata(t *testing.T) {
93	dbPath := filepath.Join(t.TempDir(), "test.db")
94	storage, err := NewSqliteStorage(dbPath)
95	assert.NoError(t, err)
96	defer storage.Close()
97
98	// Set metadata
99	err = storage.SetMetadata("key1", "value1")
100	assert.NoError(t, err)
101
102	// Get metadata
103	value, err := storage.GetMetadata("key1")
104	assert.NoError(t, err)
105	assert.Equal(t, "value1", value)
106
107	// Update metadata
108	err = storage.SetMetadata("key1", "value2")
109	assert.NoError(t, err)
110
111	value, err = storage.GetMetadata("key1")
112	assert.NoError(t, err)
113	assert.Equal(t, "value2", value)
114
115	// Get non-existent metadata
116	_, err = storage.GetMetadata("nonexistent")
117	assert.Error(t, err)
118}
119
120func TestSqliteStorageInsertAndGetItem(t *testing.T) {
121	dbPath := filepath.Join(t.TempDir(), "test.db")
122	storage, err := NewSqliteStorage(dbPath)
123	assert.NoError(t, err)
124	defer storage.Close()
125
126	mtime := time.Now().Truncate(time.Second)
127
128	// Insert root directory
129	rootID, err := storage.InsertItem(nil, "root", true, 1000, 2000, mtime, 5, 0, ' ')
130	assert.NoError(t, err)
131	assert.Greater(t, rootID, int64(0))
132
133	// Get root item
134	root, err := storage.GetRootItem()
135	assert.NoError(t, err)
136	assert.Equal(t, "root", root.GetName())
137	assert.True(t, root.IsDir())
138	assert.Equal(t, int64(1000), root.GetSize())
139	assert.Equal(t, int64(2000), root.GetUsage())
140	assert.Equal(t, int64(5), root.GetItemCount())
141	assert.Equal(t, ' ', root.GetFlag())
142	assert.Equal(t, mtime, root.GetMtime())
143}
144
145func TestSqliteStorageInsertAndGetChildren(t *testing.T) {
146	dbPath := filepath.Join(t.TempDir(), "test.db")
147	storage, err := NewSqliteStorage(dbPath)
148	assert.NoError(t, err)
149	defer storage.Close()
150
151	mtime := time.Now().Truncate(time.Second)
152
153	// Insert root
154	rootID, err := storage.InsertItem(nil, "root", true, 0, 0, mtime, 1, 0, ' ')
155	assert.NoError(t, err)
156
157	// Insert children
158	_, err = storage.InsertItem(&rootID, "file1.txt", false, 100, 4096, mtime, 1, 0, ' ')
159	assert.NoError(t, err)
160	_, err = storage.InsertItem(&rootID, "file2.txt", false, 200, 4096, mtime, 1, 12345, 'H')
161	assert.NoError(t, err)
162	_, err = storage.InsertItem(&rootID, "subdir", true, 500, 8192, mtime, 3, 0, ' ')
163	assert.NoError(t, err)
164
165	// Get children
166	children, err := storage.GetChildren(rootID)
167	assert.NoError(t, err)
168	assert.Len(t, children, 3)
169
170	// Verify children names
171	names := make([]string, len(children))
172	for i, child := range children {
173		names[i] = child.GetName()
174	}
175	assert.Contains(t, names, "file1.txt")
176	assert.Contains(t, names, "file2.txt")
177	assert.Contains(t, names, "subdir")
178}
179
180func TestSqliteStorageUpdateItem(t *testing.T) {
181	dbPath := filepath.Join(t.TempDir(), "test.db")
182	storage, err := NewSqliteStorage(dbPath)
183	assert.NoError(t, err)
184	defer storage.Close()
185
186	// Insert item
187	id, err := storage.InsertItem(nil, "dir", true, 100, 200, time.Now(), 1, 0, ' ')
188	assert.NoError(t, err)
189
190	// Update item
191	err = storage.UpdateItem(id, 500, 1000, 10, ' ')
192	assert.NoError(t, err)
193
194	// Verify update
195	item, err := storage.GetItemByID(id)
196	assert.NoError(t, err)
197	assert.Equal(t, int64(500), item.GetSize())
198	assert.Equal(t, int64(1000), item.GetUsage())
199	assert.Equal(t, int64(10), item.GetItemCount())
200}
201
202func TestSqliteStorageBulkInsert(t *testing.T) {
203	dbPath := filepath.Join(t.TempDir(), "test.db")
204	storage, err := NewSqliteStorage(dbPath)
205	assert.NoError(t, err)
206	defer storage.Close()
207
208	// Begin bulk insert
209	err = storage.BeginBulkInsert()
210	assert.NoError(t, err)
211
212	// Insert many items
213	rootID, err := storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
214	assert.NoError(t, err)
215
216	for i := 0; i < 100; i++ {
217		_, err = storage.InsertItem(&rootID, "file", false, 100, 4096, time.Now(), 1, 0, ' ')
218		assert.NoError(t, err)
219	}
220
221	// Update during bulk mode
222	err = storage.UpdateItem(rootID, 10000, 20000, 101, ' ')
223	assert.NoError(t, err)
224
225	// End bulk insert
226	err = storage.EndBulkInsert()
227	assert.NoError(t, err)
228
229	// Verify
230	children, err := storage.GetChildren(rootID)
231	assert.NoError(t, err)
232	assert.Len(t, children, 100)
233}
234
235func TestSqliteStorageHasInode(t *testing.T) {
236	dbPath := filepath.Join(t.TempDir(), "test.db")
237	storage, err := NewSqliteStorage(dbPath)
238	assert.NoError(t, err)
239	defer storage.Close()
240
241	// No inode initially
242	assert.False(t, storage.HasInode(12345))
243
244	// Insert item with inode
245	_, err = storage.InsertItem(nil, "file", false, 100, 4096, time.Now(), 1, 12345, 'H')
246	assert.NoError(t, err)
247
248	// Now inode exists
249	assert.True(t, storage.HasInode(12345))
250	assert.False(t, storage.HasInode(99999))
251}
252
253func TestSqliteStorageHasInodeBulkMode(t *testing.T) {
254	dbPath := filepath.Join(t.TempDir(), "test.db")
255	storage, err := NewSqliteStorage(dbPath)
256	assert.NoError(t, err)
257	defer storage.Close()
258
259	err = storage.BeginBulkInsert()
260	assert.NoError(t, err)
261
262	// Insert item with inode in bulk mode
263	_, err = storage.InsertItem(nil, "file", false, 100, 4096, time.Now(), 1, 12345, 'H')
264	assert.NoError(t, err)
265
266	// Check inode during bulk mode (uses prepared statement)
267	assert.True(t, storage.HasInode(12345))
268	assert.False(t, storage.HasInode(99999))
269
270	err = storage.EndBulkInsert()
271	assert.NoError(t, err)
272}
273
274func TestSqliteItemGetPath(t *testing.T) {
275	dbPath := filepath.Join(t.TempDir(), "test.db")
276	storage, err := NewSqliteStorage(dbPath)
277	assert.NoError(t, err)
278	defer storage.Close()
279
280	// Set up metadata for path resolution
281	err = storage.SetMetadata("top_dir_path", "/home/user/testdir")
282	assert.NoError(t, err)
283
284	// Insert root
285	rootID, err := storage.InsertItem(nil, "testdir", true, 0, 0, time.Now(), 1, 0, ' ')
286	assert.NoError(t, err)
287
288	// Insert child
289	childID, err := storage.InsertItem(&rootID, "file.txt", false, 100, 4096, time.Now(), 1, 0, ' ')
290	assert.NoError(t, err)
291
292	// Get root item
293	root, err := storage.GetItemByID(rootID)
294	assert.NoError(t, err)
295	assert.Equal(t, "/home/user/testdir", root.GetPath())
296
297	// Get child and set parent
298	child, err := storage.GetItemByID(childID)
299	assert.NoError(t, err)
300	child.SetParent(root)
301	assert.Equal(t, "/home/user/testdir/file.txt", child.GetPath())
302}
303
304func TestSqliteItemGetPathLazy(t *testing.T) {
305	dbPath := filepath.Join(t.TempDir(), "test.db")
306	storage, err := NewSqliteStorage(dbPath)
307	assert.NoError(t, err)
308	defer storage.Close()
309
310	// Set up metadata for path resolution
311	err = storage.SetMetadata("top_dir_path", "/home/user/testdir")
312	assert.NoError(t, err)
313
314	// Insert root
315	rootID, err := storage.InsertItem(nil, "testdir", true, 0, 0, time.Now(), 1, 0, ' ')
316	assert.NoError(t, err)
317
318	// Insert child
319	childID, err := storage.InsertItem(&rootID, "file.txt", false, 100, 4096, time.Now(), 1, 0, ' ')
320	assert.NoError(t, err)
321
322	// Get child without explicitly loading parent
323	child, err := storage.GetItemByID(childID)
324	assert.NoError(t, err)
325
326	// GetPath should lazy load parent and reconstruct correct path
327	assert.Equal(t, "/home/user/testdir/file.txt", child.GetPath())
328}
329
330func TestSqliteItemGetType(t *testing.T) {
331	dbPath := filepath.Join(t.TempDir(), "test.db")
332	storage, err := NewSqliteStorage(dbPath)
333	assert.NoError(t, err)
334	defer storage.Close()
335
336	// Directory
337	dirID, err := storage.InsertItem(nil, "dir", true, 0, 0, time.Now(), 1, 0, ' ')
338	assert.NoError(t, err)
339	dir, _ := storage.GetItemByID(dirID)
340	assert.Equal(t, "Directory", dir.GetType())
341
342	// File
343	fileID, err := storage.InsertItem(nil, "file", false, 100, 4096, time.Now(), 1, 0, ' ')
344	assert.NoError(t, err)
345	file, _ := storage.GetItemByID(fileID)
346	assert.Equal(t, "File", file.GetType())
347
348	// Other (symlink flag)
349	otherID, err := storage.InsertItem(nil, "symlink", false, 100, 4096, time.Now(), 1, 0, '@')
350	assert.NoError(t, err)
351	other, _ := storage.GetItemByID(otherID)
352	assert.Equal(t, "Other", other.GetType())
353}
354
355func TestSqliteItemGetParent(t *testing.T) {
356	dbPath := filepath.Join(t.TempDir(), "test.db")
357	storage, err := NewSqliteStorage(dbPath)
358	assert.NoError(t, err)
359	defer storage.Close()
360
361	// Insert root and child
362	rootID, err := storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
363	assert.NoError(t, err)
364	childID, err := storage.InsertItem(&rootID, "child", false, 100, 4096, time.Now(), 1, 0, ' ')
365	assert.NoError(t, err)
366
367	// Get child
368	child, err := storage.GetItemByID(childID)
369	assert.NoError(t, err)
370
371	// Get parent (lazy loaded)
372	parent := child.GetParent()
373	assert.NotNil(t, parent)
374	assert.Equal(t, "root", parent.GetName())
375
376	// Second call should use cached parent
377	parent2 := child.GetParent()
378	assert.Equal(t, parent, parent2)
379
380	// Root item has no parent
381	root, err := storage.GetItemByID(rootID)
382	assert.NoError(t, err)
383	assert.Nil(t, root.GetParent())
384}
385
386func TestSqliteItemGetMultiLinkedInode(t *testing.T) {
387	dbPath := filepath.Join(t.TempDir(), "test.db")
388	storage, err := NewSqliteStorage(dbPath)
389	assert.NoError(t, err)
390	defer storage.Close()
391
392	// Insert item with inode
393	id, err := storage.InsertItem(nil, "file", false, 100, 4096, time.Now(), 1, 12345, 'H')
394	assert.NoError(t, err)
395
396	item, err := storage.GetItemByID(id)
397	assert.NoError(t, err)
398	assert.Equal(t, uint64(12345), item.GetMultiLinkedInode())
399}
400
401func TestSqliteItemGetFiles(t *testing.T) {
402	dbPath := filepath.Join(t.TempDir(), "test.db")
403	storage, err := NewSqliteStorage(dbPath)
404	assert.NoError(t, err)
405	defer storage.Close()
406
407	// Insert root and children with different usages (SortBySize sorts by usage)
408	rootID, err := storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
409	assert.NoError(t, err)
410	_, err = storage.InsertItem(&rootID, "small.txt", false, 100, 1000, time.Now(), 1, 0, ' ')
411	assert.NoError(t, err)
412	_, err = storage.InsertItem(&rootID, "large.txt", false, 1000, 9000, time.Now(), 1, 0, ' ')
413	assert.NoError(t, err)
414	_, err = storage.InsertItem(&rootID, "medium.txt", false, 500, 5000, time.Now(), 1, 0, ' ')
415	assert.NoError(t, err)
416
417	root, err := storage.GetItemByID(rootID)
418	assert.NoError(t, err)
419
420	// Sort by name ascending (alphabetical)
421	files := slices.Collect(root.GetFiles(fs.SortByName, fs.SortAsc))
422	assert.Len(t, files, 3)
423	assert.Equal(t, "large.txt", files[0].GetName())
424	assert.Equal(t, "medium.txt", files[1].GetName())
425	assert.Equal(t, "small.txt", files[2].GetName())
426
427	// Sort by size descending (largest usage first)
428	files = slices.Collect(root.GetFiles(fs.SortBySize, fs.SortDesc))
429	assert.Len(t, files, 3)
430	assert.Equal(t, "large.txt", files[0].GetName())
431	assert.Equal(t, "medium.txt", files[1].GetName())
432	assert.Equal(t, "small.txt", files[2].GetName())
433}
434
435func TestSqliteItemGetFilesLocked(t *testing.T) {
436	dbPath := filepath.Join(t.TempDir(), "test.db")
437	storage, err := NewSqliteStorage(dbPath)
438	assert.NoError(t, err)
439	defer storage.Close()
440
441	rootID, err := storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
442	assert.NoError(t, err)
443	_, err = storage.InsertItem(&rootID, "file.txt", false, 100, 4096, time.Now(), 1, 0, ' ')
444	assert.NoError(t, err)
445
446	root, err := storage.GetItemByID(rootID)
447	assert.NoError(t, err)
448
449	// GetFilesLocked should work same as GetFiles
450	files := slices.Collect(root.GetFilesLocked(fs.SortByName, fs.SortAsc))
451	assert.Len(t, files, 1)
452	assert.Equal(t, "file.txt", files[0].GetName())
453}
454
455func TestSnapshotSqliteItemTree(t *testing.T) {
456	dbPath := filepath.Join(t.TempDir(), "test.db")
457	storage, err := NewSqliteStorage(dbPath)
458	require.NoError(t, err)
459	t.Cleanup(func() { require.NoError(t, storage.Close()) })
460
461	rootID, err := storage.InsertItem(nil, "root", true, 100, 200, time.Now(), 2, 0, ' ')
462	require.NoError(t, err)
463	_, err = storage.InsertItem(&rootID, "file.txt", false, 10, 20, time.Now(), 1, 0, ' ')
464	require.NoError(t, err)
465	root, err := storage.GetItemByID(rootID)
466	require.NoError(t, err)
467
468	snapshot, ok := snapshotItem(root, nil).(*Dir)
469	require.True(t, ok)
470	require.Len(t, snapshot.Files, 1)
471	assert.Equal(t, "root", snapshot.GetName())
472	assert.Equal(t, "file.txt", snapshot.Files[0].GetName())
473	assert.Same(t, snapshot, snapshot.Files[0].GetParent())
474}
475
476func TestSqliteAnalyzerCancellationStopsArchivePersistence(t *testing.T) {
477	analyzer, err := CreateSqliteAnalyzer(filepath.Join(t.TempDir(), "test.db"))
478	require.NoError(t, err)
479	t.Cleanup(func() { require.NoError(t, analyzer.storage.Close()) })
480
481	parentID, err := analyzer.storage.InsertItem(nil, "archive.zip", true, 0, 0, time.Now(), 1, 0, ' ')
482	require.NoError(t, err)
483	archive := &Dir{
484		File:  &File{Name: "archive.zip"},
485		Files: fs.Files{&File{Name: "must-not-be-persisted"}},
486	}
487
488	analyzer.Cancel()
489	analyzer.persistArchive(archive, parentID)
490
491	children, err := analyzer.storage.GetChildren(parentID)
492	require.NoError(t, err)
493	assert.Empty(t, children)
494}
495
496func TestSqliteAnalyzerPreemptiveCancellationSkipsChildDirectory(t *testing.T) {
497	analyzer, err := CreateSqliteAnalyzer(filepath.Join(t.TempDir(), "test.db"))
498	require.NoError(t, err)
499	t.Cleanup(func() { require.NoError(t, analyzer.storage.Close()) })
500
501	parentID, err := analyzer.storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
502	require.NoError(t, err)
503	childPath := filepath.Join(t.TempDir(), "unscanned")
504	require.NoError(t, os.Mkdir(childPath, 0o700))
505
506	analyzer.Cancel()
507	assert.Nil(t, analyzer.processDir(childPath, &parentID))
508
509	children, err := analyzer.storage.GetChildren(parentID)
510	require.NoError(t, err)
511	assert.Empty(t, children)
512}
513
514func TestSqliteItemRLock(t *testing.T) {
515	dbPath := filepath.Join(t.TempDir(), "test.db")
516	storage, err := NewSqliteStorage(dbPath)
517	assert.NoError(t, err)
518	defer storage.Close()
519
520	id, err := storage.InsertItem(nil, "root", true, 0, 0, time.Now(), 1, 0, ' ')
521	assert.NoError(t, err)
522
523	item, err := storage.GetItemByID(id)
524	assert.NoError(t, err)
525
526	// RLock should return unlock function
527	unlock := item.RLock()
528	assert.NotNil(t, unlock)
529	unlock()
530}
531
532func TestSqliteItemGetItemStats(t *testing.T) {
533	dbPath := filepath.Join(t.TempDir(), "test.db")
534	storage, err := NewSqliteStorage(dbPath)
535	assert.NoError(t, err)
536	defer storage.Close()
537
538	id, err := storage.InsertItem(nil, "dir", true, 1000, 2000, time.Now(), 5, 0, ' ')
539	assert.NoError(t, err)
540
541	item, err := storage.GetItemByID(id)
542	assert.NoError(t, err)
543
544	count, size, usage := item.GetItemStats(make(fs.HardLinkedItems), false)
545	assert.Equal(t, int64(5), count)
546	assert.Equal(t, int64(1000), size)
547	assert.Equal(t, int64(2000), usage)
548}
549
550func TestSqliteItemUpdateStats(t *testing.T) {
551	dbPath := filepath.Join(t.TempDir(), "test.db")
552	storage, err := NewSqliteStorage(dbPath)
553	assert.NoError(t, err)
554	defer storage.Close()
555
556	id, err := storage.InsertItem(nil, "dir", true, 1000, 2000, time.Now(), 5, 0, ' ')
557	assert.NoError(t, err)
558
559	item, err := storage.GetItemByID(id)
560	assert.NoError(t, err)
561
562	// UpdateStats is a no-op for SqliteItem
563	item.UpdateStats(make(fs.HardLinkedItems))
564	// Just verify it doesn't panic
565}
566
567func TestSqliteItemAddFile(t *testing.T) {
568	dbPath := filepath.Join(t.TempDir(), "test.db")
569	storage, err := NewSqliteStorage(dbPath)
570	assert.NoError(t, err)
571	defer storage.Close()
572
573	id, err := storage.InsertItem(nil, "dir", true, 0, 0, time.Now(), 1, 0, ' ')
574	assert.NoError(t, err)
575
576	item, err := storage.GetItemByID(id)
577	assert.NoError(t, err)
578
579	// AddFile is a no-op for SqliteItem
580	item.AddFile(nil)
581	// Just verify it doesn't panic
582}
583
584func TestSqliteItemRemoveFile(t *testing.T) {
585	dbPath := filepath.Join(t.TempDir(), "test.db")
586	storage, err := NewSqliteStorage(dbPath)
587	assert.NoError(t, err)
588	defer storage.Close()
589
590	// root -> subdir -> file
591	rootID, _ := storage.InsertItem(nil, "root", true, 5000, 10000, time.Now(), 3, 0, ' ')
592	subdirID, _ := storage.InsertItem(&rootID, "subdir", true, 2000, 5000, time.Now(), 2, 0, ' ')
593	fileID, _ := storage.InsertItem(&subdirID, "file.txt", false, 1000, 4000, time.Now(), 1, 0, ' ')
594
595	root, _ := storage.GetItemByID(rootID)
596	subdir, _ := storage.GetItemByID(subdirID)
597	file, _ := storage.GetItemByID(fileID)
598	subdir.SetParent(root)
599	file.SetParent(subdir)
600
601	// Remove file from subdir
602	subdir.RemoveFile(file)
603
604	// Check local stats for subdir
605	assert.Equal(t, int64(1000), subdir.GetSize())
606	assert.Equal(t, int64(1000), subdir.GetUsage())
607	assert.Equal(t, int64(1), subdir.GetItemCount())
608
609	// Check memory-state propagation for root
610	assert.Equal(t, int64(4000), root.GetSize())
611	assert.Equal(t, int64(6000), root.GetUsage())
612	assert.Equal(t, int64(2), root.GetItemCount())
613
614	// Check database stats for root
615	rootFromDB, _ := storage.GetItemByID(rootID)
616	assert.Equal(t, int64(4000), rootFromDB.GetSize())
617	assert.Equal(t, int64(6000), rootFromDB.GetUsage())
618	assert.Equal(t, int64(2), rootFromDB.GetItemCount())
619
620	// Check that file is gone from DB
621	_, err = storage.GetItemByID(fileID)
622	assert.Error(t, err)
623}
624
625func TestSqliteItemRemoveFileByName(t *testing.T) {
626	dbPath := filepath.Join(t.TempDir(), "test.db")
627	storage, err := NewSqliteStorage(dbPath)
628	assert.NoError(t, err)
629	defer storage.Close()
630
631	rootID, _ := storage.InsertItem(nil, "root", true, 100, 200, time.Now(), 2, 0, ' ')
632	storage.InsertItem(&rootID, "file.txt", false, 10, 20, time.Now(), 1, 0, ' ')
633
634	root, _ := storage.GetItemByID(rootID)
635	root.RemoveFileByName("file.txt")
636
637	assert.Equal(t, int64(90), root.GetSize())
638	assert.Equal(t, int64(180), root.GetUsage())
639	assert.Equal(t, int64(1), root.GetItemCount())
640
641	children, _ := storage.GetChildren(rootID)
642	assert.Empty(t, children)
643}
644
645func TestSqliteItemEncodeJSON(t *testing.T) {
646	dbPath := filepath.Join(t.TempDir(), "test.db")
647	storage, err := NewSqliteStorage(dbPath)
648	assert.NoError(t, err)
649	defer storage.Close()
650
651	mtime := time.Unix(1600000000, 0)
652	rootID, _ := storage.InsertItem(nil, "root", true, 100, 200, mtime, 2, 0, ' ')
653	storage.InsertItem(&rootID, "file.txt", false, 10, 20, mtime, 1, 0, ' ')
654
655	root, _ := storage.GetItemByID(rootID)
656
657	var buf bytes.Buffer
658	err = root.EncodeJSON(&buf, false, nil)
659	assert.NoError(t, err)
660
661	expected := `[{"name":"root","asize":100,"dsize":200,"items":2,"mtime":1600000000},
662{"name":"file.txt","asize":10,"dsize":20,"mtime":1600000000}]`
663	assert.Equal(t, expected, buf.String())
664}
665
666func TestSqliteItemEncodeEmptyDirJSON(t *testing.T) {
667	dbPath := filepath.Join(t.TempDir(), "test.db")
668	storage, err := NewSqliteStorage(dbPath)
669	assert.NoError(t, err)
670	defer storage.Close()
671
672	rootID, _ := storage.InsertItem(nil, "empty", true, 0, 0, time.Time{}, 0, 0, ' ')
673	root, _ := storage.GetItemByID(rootID)
674
675	var buf bytes.Buffer
676	err = root.EncodeJSON(&buf, false, nil)
677	assert.NoError(t, err)
678	assert.Equal(t, "[{\"name\":\"empty\",\"asize\":0,\"dsize\":0,\"items\":0}\n]", buf.String())
679}
680
681func TestSqliteItemEncodeJSONWithSelectedAttributes(t *testing.T) {
682	dbPath := filepath.Join(t.TempDir(), "test.db")
683	storage, err := NewSqliteStorage(dbPath)
684	assert.NoError(t, err)
685	defer storage.Close()
686
687	mtime := time.Unix(1600000000, 0)
688	rootID, _ := storage.InsertItem(nil, "root", true, 100, 200, mtime, 2, 0, ' ')
689	storage.InsertItem(&rootID, "file.txt", false, 10, 20, mtime, 1, 0, ' ')
690
691	root, _ := storage.GetItemByID(rootID)
692	var buf bytes.Buffer
693	err = root.EncodeJSON(&buf, false, fs.JSONAttributes{"asize": {}, "dsize": {}})
694
695	assert.NoError(t, err)
696	assert.Equal(t, `[{"name":"root","asize":100,"dsize":200},
697{"name":"file.txt","asize":10,"dsize":20}]`, buf.String())
698}
699
700func TestSqliteItemEncodeJSONWithSpecialAttributes(t *testing.T) {
701	dbPath := filepath.Join(t.TempDir(), "test.db")
702	storage, err := NewSqliteStorage(dbPath)
703	assert.NoError(t, err)
704	defer storage.Close()
705
706	mtime := time.Unix(1600000000, 0)
707	rootID, _ := storage.InsertItem(nil, "root", true, 0, 0, mtime, 3, 0, ' ')
708	storage.InsertItem(&rootID, "other", false, 0, 0, mtime, 1, 0, '@')
709	storage.InsertItem(&rootID, "link", false, 0, 0, mtime, 1, 123, 'H')
710
711	root, _ := storage.GetItemByID(rootID)
712	var buf bytes.Buffer
713	err = root.EncodeJSON(&buf, false, nil)
714	assert.NoError(t, err)
715	assert.Contains(t, buf.String(), `"notreg":true`)
716	assert.Contains(t, buf.String(), `"ino":123,"hlnkc":true`)
717
718	buf.Reset()
719	err = root.EncodeJSON(&buf, false, fs.JSONAttributes{"notreg": {}})
720	assert.NoError(t, err)
721	assert.Contains(t, buf.String(), `"notreg":true`)
722	assert.NotContains(t, buf.String(), `"ino"`)
723	assert.NotContains(t, buf.String(), `"mtime"`)
724}
725
726func TestCreateSqliteAnalyzer(t *testing.T) {
727	dbPath := filepath.Join(t.TempDir(), "test.db")
728	analyzer, err := CreateSqliteAnalyzer(dbPath)
729	assert.NoError(t, err)
730	assert.NotNil(t, analyzer)
731	defer analyzer.storage.Close()
732}
733
734func TestSqliteAnalyzerSetFollowSymlinks(t *testing.T) {
735	dbPath := filepath.Join(t.TempDir(), "test.db")
736	analyzer, err := CreateSqliteAnalyzer(dbPath)
737	assert.NoError(t, err)
738	defer analyzer.storage.Close()
739
740	analyzer.SetFollowSymlinks(true)
741	assert.True(t, analyzer.followSymlinks)
742	analyzer.SetFollowSymlinks(false)
743	assert.False(t, analyzer.followSymlinks)
744}
745
746func TestSqliteAnalyzerSetShowAnnexedSize(t *testing.T) {
747	dbPath := filepath.Join(t.TempDir(), "test.db")
748	analyzer, err := CreateSqliteAnalyzer(dbPath)
749	assert.NoError(t, err)
750	defer analyzer.storage.Close()
751
752	analyzer.SetShowAnnexedSize(true)
753	assert.True(t, analyzer.gitAnnexedSize)
754	analyzer.SetShowAnnexedSize(false)
755	assert.False(t, analyzer.gitAnnexedSize)
756}
757
758func TestSqliteAnalyzerSetArchiveBrowsing(t *testing.T) {
759	dbPath := filepath.Join(t.TempDir(), "test.db")
760	analyzer, err := CreateSqliteAnalyzer(dbPath)
761	assert.NoError(t, err)
762	defer analyzer.storage.Close()
763
764	analyzer.SetArchiveBrowsing(true)
765	assert.True(t, analyzer.archiveBrowsing)
766	analyzer.SetArchiveBrowsing(false)
767	assert.False(t, analyzer.archiveBrowsing)
768}
769
770func TestSqliteAnalyzerSetTimeFilter(t *testing.T) {
771	dbPath := filepath.Join(t.TempDir(), "test.db")
772	analyzer, err := CreateSqliteAnalyzer(dbPath)
773	assert.NoError(t, err)
774	defer analyzer.storage.Close()
775
776	filter := func(mtime time.Time) bool { return true }
777	analyzer.SetTimeFilter(filter)
778	assert.NotNil(t, analyzer.matchesTimeFilterFn)
779}
780
781func TestSqliteAnalyzerSetFileTypeFilter(t *testing.T) {
782	dbPath := filepath.Join(t.TempDir(), "test.db")
783	analyzer, err := CreateSqliteAnalyzer(dbPath)
784	assert.NoError(t, err)
785	defer analyzer.storage.Close()
786
787	filter := func(name string) bool { return false }
788	analyzer.SetFileTypeFilter(filter)
789	assert.NotNil(t, analyzer.ignoreFileType)
790}
791
792func TestSqliteAnalyzerGetProgress(t *testing.T) {
793	dbPath := filepath.Join(t.TempDir(), "test.db")
794	analyzer, err := CreateSqliteAnalyzer(dbPath)
795	assert.NoError(t, err)
796	defer analyzer.storage.Close()
797
798	progress := analyzer.GetProgress()
799	assert.Equal(t, int64(0), progress.ItemCount)
800}
801
802func TestSqliteAnalyzerGetDone(t *testing.T) {
803	dbPath := filepath.Join(t.TempDir(), "test.db")
804	analyzer, err := CreateSqliteAnalyzer(dbPath)
805	assert.NoError(t, err)
806	defer analyzer.storage.Close()
807
808	doneChan := analyzer.GetDone()
809	assert.NotNil(t, doneChan)
810}
811
812func TestSqliteAnalyzerArchiveBrowsing(t *testing.T) {
813	fin := testdir.CreateTestDir()
814	defer fin()
815
816	// Create a zip file
817	err := runInBash("zip -r test_dir/test.zip test_dir/nested")
818	if err != nil {
819		t.Skip("zip command not available")
820	}
821
822	dbPath := filepath.Join(t.TempDir(), "test.db")
823	analyzer, err := CreateSqliteAnalyzer(dbPath)
824	assert.NoError(t, err)
825	defer analyzer.storage.Close()
826
827	analyzer.SetArchiveBrowsing(true)
828
829	dir := analyzer.AnalyzeDir(
830		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
831	).(*SqliteItem)
832
833	analyzer.GetDone().Wait()
834
835	// Find the zip file in the results
836	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
837	var zipItem *SqliteItem
838	for _, f := range files {
839		if f.GetName() == "test.zip" {
840			zipItem = f.(*SqliteItem)
841			break
842		}
843	}
844
845	assert.NotNil(t, zipItem)
846	assert.True(t, zipItem.IsDir()) // It should be treated as a directory
847
848	// Check zip contents
849	zipFiles := slices.Collect(zipItem.GetFiles(fs.SortByName, fs.SortAsc))
850	assert.NotEmpty(t, zipFiles)
851}
852
853func runInBash(cmd string) error {
854	const shell = "/bin/bash"
855	return exec.Command(shell, "-c", cmd).Run()
856}
857
858func TestSqliteAnalyzerResetProgress(t *testing.T) {
859	dbPath := filepath.Join(t.TempDir(), "test.db")
860	analyzer, err := CreateSqliteAnalyzer(dbPath)
861	assert.NoError(t, err)
862	defer analyzer.storage.Close()
863
864	analyzer.ResetProgress()
865	assert.NotNil(t, analyzer.progressOutChan)
866	assert.NotNil(t, analyzer.doneChan)
867}
868
869func TestSqliteAnalyzerAnalyzeDir(t *testing.T) {
870	fin := testdir.CreateTestDir()
871	defer fin()
872
873	dbPath := filepath.Join(t.TempDir(), "test.db")
874	analyzer, err := CreateSqliteAnalyzer(dbPath)
875	assert.NoError(t, err)
876	defer analyzer.storage.Close()
877
878	dir := analyzer.AnalyzeDir(
879		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
880	).(*SqliteItem)
881
882	analyzer.GetDone().Wait()
883
884	// Test dir info
885	assert.Equal(t, "test_dir", dir.GetName())
886	assert.True(t, dir.IsDir())
887	assert.Equal(t, int64(5), dir.GetItemCount())
888	// Size is the sum of the file sizes; gdu does not charge a directory for
889	// its own block. Must match the parallel analyzer (see dir_test.go).
890	assert.Equal(t, int64(7), dir.GetSize())
891
892	// Test dir tree
893	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
894	assert.Equal(t, 1, len(files))
895	assert.Equal(t, "nested", files[0].GetName())
896
897	nested := files[0].(*SqliteItem)
898	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
899	assert.Equal(t, 2, len(nestedFiles))
900	assert.Equal(t, "file2", nestedFiles[0].GetName())
901	assert.Equal(t, "subnested", nestedFiles[1].GetName())
902
903	// Test file
904	assert.Equal(t, int64(2), nestedFiles[0].GetSize())
905
906	subnested := nestedFiles[1].(*SqliteItem)
907	subnestedFiles := slices.Collect(subnested.GetFiles(fs.SortByName, fs.SortAsc))
908	assert.Equal(t, "file", subnestedFiles[0].GetName())
909	assert.Equal(t, int64(5), subnestedFiles[0].GetSize())
910}
911
912func TestSqliteAnalyzerPropagatesChildPermissionError(t *testing.T) {
913	if runtime.GOOS == "windows" {
914		t.Skip("chmod does not make directories unreadable on Windows")
915	}
916
917	rootPath := t.TempDir()
918	outerPath := filepath.Join(rootPath, "outer")
919	restrictedPath := filepath.Join(outerPath, "data")
920
921	err := os.MkdirAll(restrictedPath, 0o755)
922	assert.NoError(t, err)
923	err = os.WriteFile(filepath.Join(restrictedPath, "file.txt"), []byte("x"), 0o600)
924	assert.NoError(t, err)
925
926	err = os.Chmod(restrictedPath, 0)
927	assert.NoError(t, err)
928	defer os.Chmod(restrictedPath, 0o700)
929
930	if _, err := os.ReadDir(restrictedPath); err == nil {
931		t.Skip("test user can still read chmod 000 directory")
932	}
933
934	dbPath := filepath.Join(t.TempDir(), "test.db")
935	analyzer, err := CreateSqliteAnalyzer(dbPath)
936	assert.NoError(t, err)
937	defer analyzer.storage.Close()
938
939	dir := analyzer.AnalyzeDir(
940		rootPath, func(_, _ string) bool { return false }, func(_ string) bool { return false },
941	).(*SqliteItem)
942
943	analyzer.GetDone().Wait()
944
945	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
946	assert.Len(t, files, 1)
947	outer := files[0].(*SqliteItem)
948	assert.Equal(t, "outer", outer.GetName())
949	assert.Equal(t, '.', outer.GetFlag())
950
951	children := slices.Collect(outer.GetFiles(fs.SortByName, fs.SortAsc))
952	assert.Len(t, children, 1)
953	assert.Equal(t, "data", children[0].GetName())
954	assert.Equal(t, '!', children[0].GetFlag())
955}
956
957func TestSqliteAnalyzerIgnoreDir(t *testing.T) {
958	fin := testdir.CreateTestDir()
959	defer fin()
960
961	dbPath := filepath.Join(t.TempDir(), "test.db")
962	analyzer, err := CreateSqliteAnalyzer(dbPath)
963	assert.NoError(t, err)
964	defer analyzer.storage.Close()
965
966	dir := analyzer.AnalyzeDir(
967		"test_dir", func(_, _ string) bool { return true }, func(_ string) bool { return false },
968	).(*SqliteItem)
969
970	analyzer.GetDone().Wait()
971
972	assert.Equal(t, "test_dir", dir.GetName())
973	assert.Equal(t, int64(1), dir.GetItemCount())
974}
975
976func TestSqliteAnalyzerIgnoreFileType(t *testing.T) {
977	fin := testdir.CreateTestDir()
978	defer fin()
979
980	dbPath := filepath.Join(t.TempDir(), "test.db")
981	analyzer, err := CreateSqliteAnalyzer(dbPath)
982	assert.NoError(t, err)
983	defer analyzer.storage.Close()
984
985	// Ignore all files
986	dir := analyzer.AnalyzeDir(
987		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return true },
988	).(*SqliteItem)
989
990	analyzer.GetDone().Wait()
991
992	// Every file was filtered out, so the whole tree is nothing but empty
993	// directories and collapses to a single item, exactly as
994	// Dir.UpdateStatsWithFileFiltering does (see resolveDirStats).
995	assert.Equal(t, "test_dir", dir.GetName())
996	assert.Equal(t, int64(1), dir.GetItemCount())
997	assert.Equal(t, int64(0), dir.GetUsage())
998}
999
1000func TestSqliteAnalyzerHardlinks(t *testing.T) {
1001	fin := testdir.CreateTestDir()
1002	defer fin()
1003
1004	// Create hard link
1005	err := os.Link("test_dir/nested/file2", "test_dir/nested/file3")
1006	assert.NoError(t, err)
1007
1008	dbPath := filepath.Join(t.TempDir(), "test.db")
1009	analyzer, err := CreateSqliteAnalyzer(dbPath)
1010	assert.NoError(t, err)
1011	defer analyzer.storage.Close()
1012
1013	dir := analyzer.AnalyzeDir(
1014		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1015	).(*SqliteItem)
1016
1017	analyzer.GetDone().Wait()
1018
1019	// file2 and file3 are counted just once for size but twice for item count
1020	assert.Equal(t, int64(7), dir.GetSize())
1021	assert.Equal(t, int64(6), dir.GetItemCount())
1022
1023	// Check hard link flag
1024	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1025	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1026
1027	var file3 *SqliteItem
1028	for _, f := range nestedFiles {
1029		if f.GetName() == "file3" {
1030			file3 = f.(*SqliteItem)
1031			break
1032		}
1033	}
1034	assert.NotNil(t, file3)
1035	assert.Equal(t, 'H', file3.GetFlag())
1036}
1037
1038func TestSqliteAnalyzerSymlink(t *testing.T) {
1039	fin := testdir.CreateTestDir()
1040	defer fin()
1041
1042	// Create symlink
1043	err := os.Symlink("test_dir/nested/file2", "test_dir/nested/file3")
1044	assert.NoError(t, err)
1045
1046	dbPath := filepath.Join(t.TempDir(), "test.db")
1047	analyzer, err := CreateSqliteAnalyzer(dbPath)
1048	assert.NoError(t, err)
1049	defer analyzer.storage.Close()
1050
1051	dir := analyzer.AnalyzeDir(
1052		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1053	).(*SqliteItem)
1054
1055	analyzer.GetDone().Wait()
1056
1057	// Check symlink flag
1058	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1059	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1060
1061	var file3 *SqliteItem
1062	for _, f := range nestedFiles {
1063		if f.GetName() == "file3" {
1064			file3 = f.(*SqliteItem)
1065			break
1066		}
1067	}
1068	assert.NotNil(t, file3)
1069	assert.Equal(t, '@', file3.GetFlag())
1070}
1071
1072func TestSqliteAnalyzerFollowSymlink(t *testing.T) {
1073	fin := testdir.CreateTestDir()
1074	defer fin()
1075
1076	// Create symlink to file2
1077	err := os.Symlink("./file2", "test_dir/nested/file3")
1078	assert.NoError(t, err)
1079
1080	dbPath := filepath.Join(t.TempDir(), "test.db")
1081	analyzer, err := CreateSqliteAnalyzer(dbPath)
1082	assert.NoError(t, err)
1083	defer analyzer.storage.Close()
1084
1085	analyzer.SetFollowSymlinks(true)
1086
1087	dir := analyzer.AnalyzeDir(
1088		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1089	).(*SqliteItem)
1090
1091	analyzer.GetDone().Wait()
1092
1093	// With followSymlinks, file3 should have same size as file2
1094	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1095	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1096
1097	var file3 *SqliteItem
1098	for _, f := range nestedFiles {
1099		if f.GetName() == "file3" {
1100			file3 = f.(*SqliteItem)
1101			break
1102		}
1103	}
1104	assert.NotNil(t, file3)
1105	assert.Equal(t, int64(2), file3.GetSize())
1106	assert.Equal(t, ' ', file3.GetFlag()) // Not a symlink flag when followed
1107}
1108
1109func TestSqliteAnalyzerTimeFilter(t *testing.T) {
1110	fin := testdir.CreateTestDir()
1111	defer fin()
1112
1113	dbPath := filepath.Join(t.TempDir(), "test.db")
1114	analyzer, err := CreateSqliteAnalyzer(dbPath)
1115	assert.NoError(t, err)
1116	defer analyzer.storage.Close()
1117
1118	// Filter out all files (mtime filter that always returns false)
1119	analyzer.SetTimeFilter(func(mtime time.Time) bool { return false })
1120
1121	dir := analyzer.AnalyzeDir(
1122		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1123	).(*SqliteItem)
1124
1125	analyzer.GetDone().Wait()
1126
1127	// As above: nothing survives the filter, so the tree collapses to one item.
1128	assert.Equal(t, int64(1), dir.GetItemCount())
1129	assert.Equal(t, int64(0), dir.GetUsage())
1130}
1131
1132func TestSqliteAnalyzerLoadFromExisting(t *testing.T) {
1133	fin := testdir.CreateTestDir()
1134	defer fin()
1135
1136	dbPath := filepath.Join(t.TempDir(), "test.db")
1137
1138	// First analysis
1139	analyzer1, err := CreateSqliteAnalyzer(dbPath)
1140	assert.NoError(t, err)
1141
1142	dir1 := analyzer1.AnalyzeDir(
1143		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1144	).(*SqliteItem)
1145	analyzer1.GetDone().Wait()
1146
1147	assert.Equal(t, "test_dir", dir1.GetName())
1148	assert.Equal(t, int64(5), dir1.GetItemCount())
1149
1150	analyzer1.storage.Close()
1151
1152	// Second analysis should load from existing data
1153	analyzer2, err := CreateSqliteAnalyzer(dbPath)
1154	assert.NoError(t, err)
1155	defer analyzer2.storage.Close()
1156
1157	dir2 := analyzer2.AnalyzeDir(
1158		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1159	).(*SqliteItem)
1160	analyzer2.GetDone().Wait()
1161
1162	assert.Equal(t, "test_dir", dir2.GetName())
1163	assert.Equal(t, int64(5), dir2.GetItemCount())
1164}
1165
1166func TestSqliteAnalyzerProgress(t *testing.T) {
1167	fin := testdir.CreateTestDir()
1168	defer fin()
1169
1170	dbPath := filepath.Join(t.TempDir(), "test.db")
1171	analyzer, err := CreateSqliteAnalyzer(dbPath)
1172	assert.NoError(t, err)
1173	defer analyzer.storage.Close()
1174
1175	// Start analysis in goroutine
1176	go func() {
1177		analyzer.AnalyzeDir(
1178			"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1179		)
1180	}()
1181
1182	// Wait for analysis to make some progress
1183	time.Sleep(200 * time.Millisecond)
1184
1185	progress := analyzer.GetProgress()
1186	assert.GreaterOrEqual(t, progress.TotalUsage, int64(0))
1187
1188	analyzer.GetDone().Wait()
1189}
1190
1191func BenchmarkSqliteAnalyzeDir(b *testing.B) {
1192	fin := testdir.CreateTestDir()
1193	defer fin()
1194
1195	for i := 0; i < b.N; i++ {
1196		dbPath := filepath.Join(b.TempDir(), "test.db")
1197		analyzer, _ := CreateSqliteAnalyzer(dbPath)
1198		analyzer.AnalyzeDir(
1199			"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1200		)
1201		analyzer.GetDone().Wait()
1202		analyzer.storage.Close()
1203	}
1204}