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