fork/gdu

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

Julia RyanDan's preferred ignore behavior04c9958

ignore
35.1 KiB1199 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/sh"
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 should include directory overhead + file sizes: 4096*3 + 7 bytes
889	assert.Equal(t, int64(7+4096*3), dir.GetSize())
890
891	// Test dir tree
892	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
893	assert.Equal(t, 1, len(files))
894	assert.Equal(t, "nested", files[0].GetName())
895
896	nested := files[0].(*SqliteItem)
897	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
898	assert.Equal(t, 2, len(nestedFiles))
899	assert.Equal(t, "file2", nestedFiles[0].GetName())
900	assert.Equal(t, "subnested", nestedFiles[1].GetName())
901
902	// Test file
903	assert.Equal(t, int64(2), nestedFiles[0].GetSize())
904
905	subnested := nestedFiles[1].(*SqliteItem)
906	subnestedFiles := slices.Collect(subnested.GetFiles(fs.SortByName, fs.SortAsc))
907	assert.Equal(t, "file", subnestedFiles[0].GetName())
908	assert.Equal(t, int64(5), subnestedFiles[0].GetSize())
909}
910
911func TestSqliteAnalyzerPropagatesChildPermissionError(t *testing.T) {
912	if runtime.GOOS == "windows" {
913		t.Skip("chmod does not make directories unreadable on Windows")
914	}
915
916	rootPath := t.TempDir()
917	outerPath := filepath.Join(rootPath, "outer")
918	restrictedPath := filepath.Join(outerPath, "data")
919
920	err := os.MkdirAll(restrictedPath, 0o755)
921	assert.NoError(t, err)
922	err = os.WriteFile(filepath.Join(restrictedPath, "file.txt"), []byte("x"), 0o600)
923	assert.NoError(t, err)
924
925	err = os.Chmod(restrictedPath, 0)
926	assert.NoError(t, err)
927	defer os.Chmod(restrictedPath, 0o700)
928
929	if _, err := os.ReadDir(restrictedPath); err == nil {
930		t.Skip("test user can still read chmod 000 directory")
931	}
932
933	dbPath := filepath.Join(t.TempDir(), "test.db")
934	analyzer, err := CreateSqliteAnalyzer(dbPath)
935	assert.NoError(t, err)
936	defer analyzer.storage.Close()
937
938	dir := analyzer.AnalyzeDir(
939		rootPath, func(_, _ string) bool { return false }, func(_ string) bool { return false },
940	).(*SqliteItem)
941
942	analyzer.GetDone().Wait()
943
944	files := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))
945	assert.Len(t, files, 1)
946	outer := files[0].(*SqliteItem)
947	assert.Equal(t, "outer", outer.GetName())
948	assert.Equal(t, '.', outer.GetFlag())
949
950	children := slices.Collect(outer.GetFiles(fs.SortByName, fs.SortAsc))
951	assert.Len(t, children, 1)
952	assert.Equal(t, "data", children[0].GetName())
953	assert.Equal(t, '!', children[0].GetFlag())
954}
955
956func TestSqliteAnalyzerIgnoreDir(t *testing.T) {
957	fin := testdir.CreateTestDir()
958	defer fin()
959
960	dbPath := filepath.Join(t.TempDir(), "test.db")
961	analyzer, err := CreateSqliteAnalyzer(dbPath)
962	assert.NoError(t, err)
963	defer analyzer.storage.Close()
964
965	dir := analyzer.AnalyzeDir(
966		"test_dir", func(_, _ string) bool { return true }, func(_ string) bool { return false },
967	).(*SqliteItem)
968
969	analyzer.GetDone().Wait()
970
971	assert.Equal(t, "test_dir", dir.GetName())
972	assert.Equal(t, int64(1), dir.GetItemCount())
973}
974
975func TestSqliteAnalyzerIgnoreFileType(t *testing.T) {
976	fin := testdir.CreateTestDir()
977	defer fin()
978
979	dbPath := filepath.Join(t.TempDir(), "test.db")
980	analyzer, err := CreateSqliteAnalyzer(dbPath)
981	assert.NoError(t, err)
982	defer analyzer.storage.Close()
983
984	// Ignore all files
985	dir := analyzer.AnalyzeDir(
986		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return true },
987	).(*SqliteItem)
988
989	analyzer.GetDone().Wait()
990
991	// Only directories should remain
992	assert.Equal(t, "test_dir", dir.GetName())
993	assert.Equal(t, int64(3), dir.GetItemCount()) // test_dir, nested, subnested
994}
995
996func TestSqliteAnalyzerHardlinks(t *testing.T) {
997	fin := testdir.CreateTestDir()
998	defer fin()
999
1000	// Create hard link
1001	err := os.Link("test_dir/nested/file2", "test_dir/nested/file3")
1002	assert.NoError(t, err)
1003
1004	dbPath := filepath.Join(t.TempDir(), "test.db")
1005	analyzer, err := CreateSqliteAnalyzer(dbPath)
1006	assert.NoError(t, err)
1007	defer analyzer.storage.Close()
1008
1009	dir := analyzer.AnalyzeDir(
1010		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1011	).(*SqliteItem)
1012
1013	analyzer.GetDone().Wait()
1014
1015	// file2 and file3 are counted just once for size but twice for item count
1016	assert.Equal(t, int64(7+4096*3), dir.GetSize())
1017	assert.Equal(t, int64(6), dir.GetItemCount())
1018
1019	// Check hard link flag
1020	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1021	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1022
1023	var file3 *SqliteItem
1024	for _, f := range nestedFiles {
1025		if f.GetName() == "file3" {
1026			file3 = f.(*SqliteItem)
1027			break
1028		}
1029	}
1030	assert.NotNil(t, file3)
1031	assert.Equal(t, 'H', file3.GetFlag())
1032}
1033
1034func TestSqliteAnalyzerSymlink(t *testing.T) {
1035	fin := testdir.CreateTestDir()
1036	defer fin()
1037
1038	// Create symlink
1039	err := os.Symlink("test_dir/nested/file2", "test_dir/nested/file3")
1040	assert.NoError(t, err)
1041
1042	dbPath := filepath.Join(t.TempDir(), "test.db")
1043	analyzer, err := CreateSqliteAnalyzer(dbPath)
1044	assert.NoError(t, err)
1045	defer analyzer.storage.Close()
1046
1047	dir := analyzer.AnalyzeDir(
1048		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1049	).(*SqliteItem)
1050
1051	analyzer.GetDone().Wait()
1052
1053	// Check symlink flag
1054	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1055	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1056
1057	var file3 *SqliteItem
1058	for _, f := range nestedFiles {
1059		if f.GetName() == "file3" {
1060			file3 = f.(*SqliteItem)
1061			break
1062		}
1063	}
1064	assert.NotNil(t, file3)
1065	assert.Equal(t, '@', file3.GetFlag())
1066}
1067
1068func TestSqliteAnalyzerFollowSymlink(t *testing.T) {
1069	fin := testdir.CreateTestDir()
1070	defer fin()
1071
1072	// Create symlink to file2
1073	err := os.Symlink("./file2", "test_dir/nested/file3")
1074	assert.NoError(t, err)
1075
1076	dbPath := filepath.Join(t.TempDir(), "test.db")
1077	analyzer, err := CreateSqliteAnalyzer(dbPath)
1078	assert.NoError(t, err)
1079	defer analyzer.storage.Close()
1080
1081	analyzer.SetFollowSymlinks(true)
1082
1083	dir := analyzer.AnalyzeDir(
1084		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1085	).(*SqliteItem)
1086
1087	analyzer.GetDone().Wait()
1088
1089	// With followSymlinks, file3 should have same size as file2
1090	nested := slices.Collect(dir.GetFiles(fs.SortByName, fs.SortAsc))[0].(*SqliteItem)
1091	nestedFiles := slices.Collect(nested.GetFiles(fs.SortByName, fs.SortAsc))
1092
1093	var file3 *SqliteItem
1094	for _, f := range nestedFiles {
1095		if f.GetName() == "file3" {
1096			file3 = f.(*SqliteItem)
1097			break
1098		}
1099	}
1100	assert.NotNil(t, file3)
1101	assert.Equal(t, int64(2), file3.GetSize())
1102	assert.Equal(t, ' ', file3.GetFlag()) // Not a symlink flag when followed
1103}
1104
1105func TestSqliteAnalyzerTimeFilter(t *testing.T) {
1106	fin := testdir.CreateTestDir()
1107	defer fin()
1108
1109	dbPath := filepath.Join(t.TempDir(), "test.db")
1110	analyzer, err := CreateSqliteAnalyzer(dbPath)
1111	assert.NoError(t, err)
1112	defer analyzer.storage.Close()
1113
1114	// Filter out all files (mtime filter that always returns false)
1115	analyzer.SetTimeFilter(func(mtime time.Time) bool { return false })
1116
1117	dir := analyzer.AnalyzeDir(
1118		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1119	).(*SqliteItem)
1120
1121	analyzer.GetDone().Wait()
1122
1123	// Only directories should remain
1124	assert.Equal(t, int64(3), dir.GetItemCount()) // test_dir, nested, subnested
1125}
1126
1127func TestSqliteAnalyzerLoadFromExisting(t *testing.T) {
1128	fin := testdir.CreateTestDir()
1129	defer fin()
1130
1131	dbPath := filepath.Join(t.TempDir(), "test.db")
1132
1133	// First analysis
1134	analyzer1, err := CreateSqliteAnalyzer(dbPath)
1135	assert.NoError(t, err)
1136
1137	dir1 := analyzer1.AnalyzeDir(
1138		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1139	).(*SqliteItem)
1140	analyzer1.GetDone().Wait()
1141
1142	assert.Equal(t, "test_dir", dir1.GetName())
1143	assert.Equal(t, int64(5), dir1.GetItemCount())
1144
1145	analyzer1.storage.Close()
1146
1147	// Second analysis should load from existing data
1148	analyzer2, err := CreateSqliteAnalyzer(dbPath)
1149	assert.NoError(t, err)
1150	defer analyzer2.storage.Close()
1151
1152	dir2 := analyzer2.AnalyzeDir(
1153		"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1154	).(*SqliteItem)
1155	analyzer2.GetDone().Wait()
1156
1157	assert.Equal(t, "test_dir", dir2.GetName())
1158	assert.Equal(t, int64(5), dir2.GetItemCount())
1159}
1160
1161func TestSqliteAnalyzerProgress(t *testing.T) {
1162	fin := testdir.CreateTestDir()
1163	defer fin()
1164
1165	dbPath := filepath.Join(t.TempDir(), "test.db")
1166	analyzer, err := CreateSqliteAnalyzer(dbPath)
1167	assert.NoError(t, err)
1168	defer analyzer.storage.Close()
1169
1170	// Start analysis in goroutine
1171	go func() {
1172		analyzer.AnalyzeDir(
1173			"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1174		)
1175	}()
1176
1177	// Wait for analysis to make some progress
1178	time.Sleep(200 * time.Millisecond)
1179
1180	progress := analyzer.GetProgress()
1181	assert.GreaterOrEqual(t, progress.TotalUsage, int64(0))
1182
1183	analyzer.GetDone().Wait()
1184}
1185
1186func BenchmarkSqliteAnalyzeDir(b *testing.B) {
1187	fin := testdir.CreateTestDir()
1188	defer fin()
1189
1190	for i := 0; i < b.N; i++ {
1191		dbPath := filepath.Join(b.TempDir(), "test.db")
1192		analyzer, _ := CreateSqliteAnalyzer(dbPath)
1193		analyzer.AnalyzeDir(
1194			"test_dir", func(_, _ string) bool { return false }, func(_ string) bool { return false },
1195		)
1196		analyzer.GetDone().Wait()
1197		analyzer.storage.Close()
1198	}
1199}