fix tests

Author: AnakinRaW

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/FileExistsStrategyTestBase.cs

@@ -22,18 +22,36 @@ protected override IFileSystem CreateFileSystem()
     protected abstract override void ConfigureStrategy(PetroglyphFileSystem fs);
 
     /// <summary>
-    /// Constructs a fresh, undisposed instance of the strategy under test, so generic suite
-    /// tests (<see cref="Dispose_CalledTwice_DoesNotThrow"/>) can exercise it directly without
+    /// Constructs a fresh instance of the strategy under test, so generic suite
+    /// tests (<see cref="Cleanup_CalledTwice_DoesNotThrow"/>) can exercise it directly without
     /// fighting the <see cref="PetroglyphFileSystem"/>'s ownership of the active strategy.
     /// </summary>
-    private protected abstract FileExistsStrategy CreateStrategyForDisposeTest();
+    private protected abstract FileExistsStrategy CreateStrategyForCleanupTest();
 
     [Fact]
-    public void Dispose_CalledTwice_DoesNotThrow()
+    public void Cleanup_CalledTwice_DoesNotThrow()
     {
-        var strategy = CreateStrategyForDisposeTest();
-        strategy.Dispose();
-        strategy.Dispose();
+        var strategy = CreateStrategyForCleanupTest();
+        strategy.Cleanup();
+        strategy.Cleanup();
+    }
+
+    [Fact]
+    public void FileExists_AfterCleanup_RemainsUsable()
+    {
+        var dir = NewTempDir();
+        var file = FileSystem.Path.Combine(dir, "test.txt");
+        FileSystem.File.WriteAllText(file, "x");
+
+        // Warm up the strategy.
+        Assert.True(FileExists("test.txt".AsSpan(), dir.AsSpan()));
+
+        // Cleanup must not permanently break the strategy.
+        PgFileSystem.Strategy.Cleanup();
+
+        // Must still serve correct lookups after Cleanup.
+        Assert.True(FileExists("test.txt".AsSpan(), dir.AsSpan()));
+        Assert.False(FileExists("missing.txt".AsSpan(), dir.AsSpan()));
     }
 
     protected virtual void AssertResolvedPath(string expectedOnDiskPath, string actualResult)

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/LiveVirtualFileExistsStrategyTests.cs

@@ -1,5 +1,5 @@
 using System;
-using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Abstractions;
@@ -43,7 +43,7 @@ public abstract class LiveVirtualFileExistsStrategyTests : VirtualFileExistsStra
     private protected override void ConfigureStrategy(PetroglyphFileSystem fs, FileExistsStrategy underlying)
         => fs.UseLiveVirtualStrategy(underlying);
 
-    private protected override FileExistsStrategy CreateStrategyForDisposeTest()
+    private protected override FileExistsStrategy CreateStrategyForCleanupTest()
         => new LiveVirtualFileExistsStrategy(FileSystem, new WineFileExistsStrategy(FileSystem));
 
     [Fact]
@@ -317,19 +317,46 @@ await AwaitCacheInvalidationAsync(
             "gameDir snapshot to invalidate after g.xml deleted (post-Error rebuild)");
     }
 
+    [Fact]
+    public async Task Cleanup_RemovesWatchersAndClearsCache_WatchersReinstalledOnNextLookup()
+    {
+        var dir = NewTempDir();
+        var dataDir = FileSystem.Path.Combine(dir, "Data");
+        FileSystem.Directory.CreateDirectory(dataDir);
+        var file = FileSystem.Path.Combine(dataDir, "foo.xml");
+        FileSystem.File.WriteAllText(file, "x");
+
+        // Prime: install a watcher and warm the snapshot.
+        Assert.True(FileExists("Data/foo.xml".AsSpan(), dir.AsSpan()));
+
+        var strategyBefore = GetActiveLiveStrategy();
+        Assert.True(GetWatchers(strategyBefore).ContainsKey(dir));
+
+        // Cleanup: teardown watchers and clear the snapshot cache.
+        strategyBefore.Cleanup();
+
+        // Lookups must still work after Cleanup — the strategy re-snapshots lazily.
+        Assert.True(FileExists("Data/foo.xml".AsSpan(), dir.AsSpan()));
+
+        // After the first post-cleanup lookup the watcher must be re-armed: disk changes are tracked again.
+        await AwaitCacheInvalidationAsync(
+            () => FileSystem.File.Delete(file),
+            () => !FileExists("Data/foo.xml".AsSpan(), dir.AsSpan()),
+            "snapshot to invalidate after Data/foo.xml deleted (post-Cleanup re-arm)");
+    }
+
     private LiveVirtualFileExistsStrategy GetActiveLiveStrategy()
     {
-        var field = typeof(PetroglyphFileSystem).GetField("_strategy", BindingFlags.NonPublic | BindingFlags.Instance)!;
-        return (LiveVirtualFileExistsStrategy)field.GetValue(PgFileSystem)!;
+        return (LiveVirtualFileExistsStrategy)PgFileSystem.Strategy;
     }
 
     // GetWatchers / InvokeOnWatcherError exist only to *synthesize* an Error event (no portable
     // way to make a real FSW fire one). The Error tests themselves assert observable behavior,
     // not the watcher dictionary's contents.
-    private static Dictionary<string, IFileSystemWatcher> GetWatchers(LiveVirtualFileExistsStrategy strategy)
+    private static ConcurrentDictionary<string, IFileSystemWatcher> GetWatchers(LiveVirtualFileExistsStrategy strategy)
     {
         var field = typeof(LiveVirtualFileExistsStrategy).GetField("_watchers", BindingFlags.NonPublic | BindingFlags.Instance)!;
-        return (Dictionary<string, IFileSystemWatcher>)field.GetValue(strategy)!;
+        return (ConcurrentDictionary<string, IFileSystemWatcher>)field.GetValue(strategy)!;
     }
 
     private static void InvokeOnWatcherError(LiveVirtualFileExistsStrategy strategy, IFileSystemWatcher sender, ErrorEventArgs args)

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/VirtualFileExistsStrategyBaseTests.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Concurrent;
+using System.Reflection;
 using PG.StarWarsGame.Engine.IO;
 using PG.StarWarsGame.Engine.IO.FileExistStrategies;
 using PG.StarWarsGame.Engine.Utilities;
@@ -119,4 +121,41 @@ public void FileExists_MissingSubdirectoryUnderGameRoot_DoesNotDelegate()
 
         Assert.Equal(0, tracking.CallCount);
     }
+
+    [Fact]
+    public void Cleanup_ClearsSnapshotCache_FreshSnapshotOnNextLookup()
+    {
+        var dir = NewTempDir();
+        var dataDir = FileSystem.Path.Combine(dir, "Data");
+        FileSystem.Directory.CreateDirectory(dataDir);
+        FileSystem.File.WriteAllText(FileSystem.Path.Combine(dataDir, "foo.xml"), "x");
+
+        // Prime the snapshot — foo.xml is in cache.
+        Assert.True(FileExists("Data/foo.xml".AsSpan(), dir.AsSpan()));
+        Assert.NotEmpty(GetSnapshotStore());
+
+        // Cleanup evicts the snapshot cache.
+        GetActiveVirtualStrategy().Cleanup();
+        Assert.Empty(GetSnapshotStore());
+
+        // Add a file to disk after cleanup; the post-cleanup re-snapshot must pick it up.
+        FileSystem.File.WriteAllText(FileSystem.Path.Combine(dataDir, "bar.xml"), "y");
+
+        // Post-cleanup: fresh snapshot taken on next lookup — both files visible.
+        Assert.True(FileExists("Data/foo.xml".AsSpan(), dir.AsSpan()));
+        Assert.True(FileExists("Data/bar.xml".AsSpan(), dir.AsSpan()));
+    }
+
+    private VirtualFileExistsStrategyBase GetActiveVirtualStrategy()
+    {
+        var field = typeof(PetroglyphFileSystem).GetField("_strategy", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        return (VirtualFileExistsStrategyBase)field.GetValue(PgFileSystem)!;
+    }
+
+    private ConcurrentDictionary<string, VirtualDirectory?> GetSnapshotStore()
+    {
+        var strategy = GetActiveVirtualStrategy();
+        var field = typeof(VirtualFileExistsStrategyBase).GetField("Store", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        return (ConcurrentDictionary<string, VirtualDirectory?>)field.GetValue(strategy)!;
+    }
 }

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/VirtualFileExistsStrategyTests.cs

@@ -26,7 +26,7 @@ public abstract class VirtualFileExistsStrategyTests : VirtualFileExistsStrategy
     private protected override void ConfigureStrategy(PetroglyphFileSystem fs, FileExistsStrategy underlying)
         => fs.UseVirtualStrategy(underlying);
 
-    private protected override FileExistsStrategy CreateStrategyForDisposeTest()
+    private protected override FileExistsStrategy CreateStrategyForCleanupTest()
         => new VirtualFileExistsStrategy(FileSystem, new WineFileExistsStrategy(FileSystem));
 
     [Fact]

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/WindowsFileExistsStrategyTests.cs

@@ -19,7 +19,7 @@ protected override void ConfigureStrategy(PetroglyphFileSystem fs)
         fs.UseWindowsStrategy();
     }
 
-    private protected override FileExistsStrategy CreateStrategyForDisposeTest()
+    private protected override FileExistsStrategy CreateStrategyForCleanupTest()
     {
         if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             Assert.Skip("Windows strategy requires a Windows host.");

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/WineFileExistsStrategyTests.cs

@@ -8,6 +8,6 @@ public sealed class WineFileExistsStrategyTests : FileExistsStrategyTestBase
     protected override void ConfigureStrategy(PetroglyphFileSystem fs)
         => fs.UseWineStrategy();
 
-    private protected override FileExistsStrategy CreateStrategyForDisposeTest()
+    private protected override FileExistsStrategy CreateStrategyForCleanupTest()
         => new WineFileExistsStrategy(FileSystem);
 }