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