Use structured concurrency in PackageLoadingTests (#7359)

This is a stripped down version of
#6624 that modifies
only the test suite and doesn't make any substantial to
`ManifestLoader.swift` other than providing an `async` overload in
`extension ManifestLoaderProtocol` that uses
`withCheckedThrowingContinuation` to bridge into the existing
implementation.

Author: MaxDesiatov

Package.swift

@@ -608,10 +608,6 @@ let package = Package(
             dependencies: ["PackageLoading", "SPMTestSupport"],
             exclude: ["Inputs", "pkgconfigInputs"]
         ),
-        .testTarget(
-            name: "PackageLoadingPerformanceTests",
-            dependencies: ["PackageLoading", "SPMTestSupport"]
-        ),
         .testTarget(
             name: "PackageModelTests",
             dependencies: ["PackageModel", "SPMTestSupport"]

Sources/PackageLoading/ManifestLoader.swift

@@ -232,6 +232,39 @@ extension ManifestLoaderProtocol {
                 completion(.failure(error))
             }
         }
+    }    
+
+    public func load(
+        packagePath: AbsolutePath,
+        packageIdentity: PackageIdentity,
+        packageKind: PackageReference.Kind,
+        packageLocation: String,
+        packageVersion: (version: Version?, revision: String?)?,
+        currentToolsVersion: ToolsVersion,
+        identityResolver: IdentityResolver,
+        dependencyMapper: DependencyMapper,
+        fileSystem: FileSystem,
+        observabilityScope: ObservabilityScope,
+        delegateQueue: DispatchQueue,
+        callbackQueue: DispatchQueue
+    ) async throws -> Manifest {
+        try await withCheckedThrowingContinuation {
+            self.load(
+                packagePath: packagePath,
+                packageIdentity: packageIdentity,
+                packageKind: packageKind,
+                packageLocation: packageLocation,
+                packageVersion: packageVersion,
+                currentToolsVersion: currentToolsVersion,
+                identityResolver: identityResolver,
+                dependencyMapper: dependencyMapper,
+                fileSystem: fileSystem,
+                observabilityScope: observabilityScope,
+                delegateQueue: delegateQueue,
+                callbackQueue: callbackQueue,
+                completion: $0.resume(with:)
+            )
+        }
     }
 }
 

Sources/SPMTestSupport/MockManifestLoader.swift

@@ -18,6 +18,7 @@ import PackageGraph
 
 import func XCTest.XCTFail
 
+import enum TSCBasic.ProcessEnv
 import struct TSCUtility.Version
 
 public enum MockManifestLoaderError: Swift.Error {
@@ -88,7 +89,7 @@ extension ManifestLoader {
         dependencyMapper: DependencyMapper? = .none,
         fileSystem: FileSystem,
         observabilityScope: ObservabilityScope
-    ) throws -> Manifest{
+    ) async throws -> Manifest{
         let packageIdentity: PackageIdentity
         let packageLocation: String
         switch packageKind {
@@ -109,27 +110,23 @@ extension ManifestLoader {
             // FIXME: placeholder
             packageLocation = identity.description
         }
-        return try temp_await {
-            self.load(
-                manifestPath: manifestPath,
-                manifestToolsVersion: manifestToolsVersion,
-                packageIdentity: packageIdentity,
-                packageKind: packageKind,
-                packageLocation: packageLocation,
-                packageVersion: nil,
-                identityResolver: identityResolver,
-                dependencyMapper: dependencyMapper ?? DefaultDependencyMapper(identityResolver: identityResolver),
-                fileSystem: fileSystem,
-                observabilityScope: observabilityScope,
-                delegateQueue: .sharedConcurrent,
-                callbackQueue: .sharedConcurrent,
-                completion: $0
-            )
-        }
+        return try await self.load(
+            manifestPath: manifestPath,
+            manifestToolsVersion: manifestToolsVersion,
+            packageIdentity: packageIdentity,
+            packageKind: packageKind,
+            packageLocation: packageLocation,
+            packageVersion: nil,
+            identityResolver: identityResolver,
+            dependencyMapper: dependencyMapper ?? DefaultDependencyMapper(identityResolver: identityResolver),
+            fileSystem: fileSystem,
+            observabilityScope: observabilityScope,
+            delegateQueue: .sharedConcurrent,
+            callbackQueue: .sharedConcurrent
+        )
     }
 }
 
-
 extension ManifestLoader {
     public func load(
         packagePath: AbsolutePath,
@@ -139,7 +136,7 @@ extension ManifestLoader {
         dependencyMapper: DependencyMapper? = .none,
         fileSystem: FileSystem,
         observabilityScope: ObservabilityScope
-    ) throws -> Manifest{
+    ) async throws -> Manifest{
         let packageIdentity: PackageIdentity
         let packageLocation: String
         switch packageKind {
@@ -160,22 +157,44 @@ extension ManifestLoader {
             // FIXME: placeholder
             packageLocation = identity.description
         }
-        return try temp_await {
-            self.load(
-                packagePath: packagePath,
-                packageIdentity: packageIdentity,
-                packageKind: packageKind,
-                packageLocation: packageLocation,
-                packageVersion: nil,
-                currentToolsVersion: currentToolsVersion,
-                identityResolver: identityResolver,
-                dependencyMapper: dependencyMapper ?? DefaultDependencyMapper(identityResolver: identityResolver),
-                fileSystem: fileSystem,
-                observabilityScope: observabilityScope,
-                delegateQueue: .sharedConcurrent,
-                callbackQueue: .sharedConcurrent,
-                completion: $0
-            )
+        return try await self.load(
+            packagePath: packagePath,
+            packageIdentity: packageIdentity,
+            packageKind: packageKind,
+            packageLocation: packageLocation,
+            packageVersion: nil,
+            currentToolsVersion: currentToolsVersion,
+            identityResolver: identityResolver,
+            dependencyMapper: dependencyMapper ?? DefaultDependencyMapper(identityResolver: identityResolver),
+            fileSystem: fileSystem,
+            observabilityScope: observabilityScope,
+            delegateQueue: .sharedConcurrent,
+            callbackQueue: .sharedConcurrent
+        )
+    }
+}
+
+/// Temporary override environment variables
+///
+/// WARNING! This method is not thread-safe. POSIX environments are shared
+/// between threads. This means that when this method is called simultaneously
+/// from different threads, the environment will neither be setup nor restored
+/// correctly.
+public func withCustomEnv(_ env: [String: String], body: () async throws -> Void) async throws {
+    let state = env.map { ($0, $1) }
+    let restore = {
+        for (key, value) in state {
+            try ProcessEnv.setVar(key, value: value)
+        }
+    }
+    do {
+        for (key, value) in env {
+            try ProcessEnv.setVar(key, value: value)
         }
+        try await body()
+    } catch {
+        try? restore()
+        throw error
     }
+    try restore()
 }

Sources/SPMTestSupport/XCTAssertHelpers.swift

@@ -187,6 +187,35 @@ public func XCTAssertThrowsCommandExecutionError<T>(
     }
 }
 
+public func XCTAssertAsyncEqual<T: Equatable>(
+    _ expression1: @autoclosure () async throws -> T,
+    _ expression2: @autoclosure () async throws -> T,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #file,
+    line: UInt = #line
+) async rethrows {
+    let value1 = try await expression1()
+    let value2 = try await expression2()
+
+    XCTAssertEqual(value1, value2, message(), file: file, line: line)
+}
+
+struct XCAsyncTestErrorWhileUnwrappingOptional: Error {}
+
+public func XCTAsyncUnwrap<T>(
+    _ expression: @autoclosure () async throws -> T?,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #filePath,
+    line: UInt = #line
+) async throws -> T {
+    guard let result = try await expression() else {
+        throw XCAsyncTestErrorWhileUnwrappingOptional()
+    }
+
+    return result
+}
+
+
 public struct CommandExecutionError: Error {
     public let result: ProcessResult
     public let stdout: String