Avoid nondeterministically clearing the build description manager's build description cache in tests

If we've told the build description manager to never evict build descriptions from its cache, ensure that the cache isn't attached to the heavy cache global state, so that it isn't cleared by other tests running concurrently.

Author: jakepetroules

Sources/SWBTaskExecution/BuildDescriptionManager.swift

@@ -57,7 +57,7 @@ package struct BuildDescriptionRetrievalInfo {
 }
 
 /// Controls the non-deterministic eviction policy of the cache. Note that this is distinct from deterministic _pruning_ (due to TTL or size limits).
-package enum BuildDescriptionMemoryCacheEvictionPolicy: Sendable {
+package enum BuildDescriptionMemoryCacheEvictionPolicy: Sendable, Hashable {
     /// Never evict due to memory pressure.
     case never
 
@@ -104,20 +104,22 @@ package final class BuildDescriptionManager: Sendable {
 
     package init(fs: any FSProxy, buildDescriptionMemoryCacheEvictionPolicy: BuildDescriptionMemoryCacheEvictionPolicy, maxCacheSize: (inMemory: Int, onDisk: Int) = (4, 4)) {
         self.fs = fs
-        self.inMemoryCachedBuildDescriptions = HeavyCache(maximumSize: maxCacheSize.inMemory, evictionPolicy: {
-            switch buildDescriptionMemoryCacheEvictionPolicy {
-            case .never:
-                .never
-            case .default(let totalCostLimit):
-                .default(totalCostLimit: totalCostLimit, willEvictCallback: { buildDescription in
-                    // Capture the path to a local variable so that the buildDescription instance isn't retained by OSLog's autoclosure message parameter.
-                    let packagePath = buildDescription.packagePath
-                    #if canImport(os)
-                    OSLog.log("Evicted cached build description at '\(packagePath.str)'")
-                    #endif
-                })
-            }
-        }())
+        self.inMemoryCachedBuildDescriptions = withHeavyCacheGlobalState(isolated: buildDescriptionMemoryCacheEvictionPolicy == .never) {
+            HeavyCache(maximumSize: maxCacheSize.inMemory, evictionPolicy: {
+                switch buildDescriptionMemoryCacheEvictionPolicy {
+                case .never:
+                    .never
+                case .default(let totalCostLimit):
+                    .default(totalCostLimit: totalCostLimit, willEvictCallback: { buildDescription in
+                        // Capture the path to a local variable so that the buildDescription instance isn't retained by OSLog's autoclosure message parameter.
+                        let packagePath = buildDescription.packagePath
+                        #if canImport(os)
+                        OSLog.log("Evicted cached build description at '\(packagePath.str)'")
+                        #endif
+                    })
+                }
+            }())
+        }
         self.maxCacheSize = maxCacheSize
     }
 

Sources/SWBUtil/HeavyCache.swift

@@ -33,8 +33,22 @@ public func clearAllHeavyCaches() {
     }
 }
 
-@_spi(Testing) public func withHeavyCacheGlobalState<T>(_ body: () async throws -> T) async rethrows -> T {
-    try await $allHeavyCaches.withValue(.init([])) {
+public func withHeavyCacheGlobalState<T>(isolated: Bool = true, _ body: () throws -> T) rethrows -> T {
+    if isolated {
+        try $allHeavyCaches.withValue(.init([])) {
+            try body()
+        }
+    } else {
+        try body()
+    }
+}
+
+@_spi(Testing) public func withHeavyCacheGlobalState<T>(isolated: Bool = true, _ body: () async throws -> T) async rethrows -> T {
+    if isolated {
+        try await $allHeavyCaches.withValue(.init([])) {
+            try await body()
+        }
+    } else {
         try await body()
     }
 }

Tests/SWBUtilTests/HeavyCacheTests.swift

@@ -188,16 +188,7 @@ fileprivate struct HeavyCacheTests {
 
 /// Provides a HeavyCache suitable for use in tests (eviction policy disabled to prevent memory pressure interference).
 fileprivate func withHeavyCache<Key, Value>(isolatedGlobalState: Bool = true, maximumSize: Int? = nil, timeToLive: Duration? = nil, _ block: (HeavyCache<Key, Value>) async throws -> Void) async rethrows {
-    func withIsolatedGlobalState(block: () async throws -> Void) async rethrows {
-        if isolatedGlobalState {
-            try await withHeavyCacheGlobalState {
-                try await block()
-            }
-        } else {
-            try await block()
-        }
-    }
-    try await withIsolatedGlobalState {
+    try await withHeavyCacheGlobalState(isolated: isolatedGlobalState) {
         try await block(HeavyCache<Key, Value>(maximumSize: maximumSize, timeToLive: timeToLive, evictionPolicy: .never))
     }
 }