Replace some uses of temp_await with await in tests (#7102)

Start using `async`/`await` in testing

### Motivation:

This should start to make easier to adopt `async`/`await` by reducing the number of non-async callers

### Modifications:

1 commit which adds `async`/`await` bridges
1 commit which adopts the bridges in a test target (`BasicTests`)

### Result:

reduce usage of `temp_await`

---------

Co-authored-by: Max Desiatov <[email protected]>

Author: AndrewHoos

Sources/Basics/Archiver/Archiver.swift

@@ -23,6 +23,7 @@ public protocol Archiver {
     ///   - archivePath: The `AbsolutePath` to the archive to extract.
     ///   - destinationPath: The `AbsolutePath` to the directory to extract to.
     ///   - completion: The completion handler that will be called when the operation finishes to notify of its success.
+    @available(*, noasync, message: "Use the async alternative")
     func extract(
         from archivePath: AbsolutePath,
         to destinationPath: AbsolutePath,
@@ -35,6 +36,7 @@ public protocol Archiver {
     ///   - directory: The `AbsolutePath` to the archive to extract.
     ///   - destinationPath: The `AbsolutePath` to the directory to extract to.
     ///   - completion: The completion handler that will be called when the operation finishes to notify of its success.
+    @available(*, noasync, message: "Use the async alternative")
     func compress(
         directory: AbsolutePath,
         to destinationPath: AbsolutePath,
@@ -46,6 +48,7 @@ public protocol Archiver {
     /// - Parameters:
     ///   - path: The `AbsolutePath` to the archive to validate.
     ///   - completion: The completion handler that will be called when the operation finishes to notify of its success.
+    @available(*, noasync, message: "Use the async alternative")
     func validate(
         path: AbsolutePath,
         completion: @escaping (Result<Bool, Error>) -> Void
@@ -57,8 +60,25 @@ extension Archiver {
         from archivePath: AbsolutePath,
         to destinationPath: AbsolutePath
     ) async throws {
-        try await withCheckedThrowingContinuation {
-            self.extract(from: archivePath, to: destinationPath, completion: $0.resume(with:))
+        try await safe_async {
+            self.extract(from: archivePath, to: destinationPath, completion: $0)
+        }
+    }
+
+    public func compress(
+        directory: AbsolutePath,
+        to: AbsolutePath
+    ) async throws {
+        try await safe_async {
+            self.compress(directory: directory, to: to, completion: $0)
+        }
+    }
+
+    public func validate(
+        path: AbsolutePath
+    ) async throws -> Bool {
+        try await safe_async {
+            self.validate(path: path, completion: $0)
         }
     }
 }

Sources/Basics/AuthorizationProvider.swift

@@ -23,6 +23,7 @@ public protocol AuthorizationProvider {
 }
 
 public protocol AuthorizationWriter {
+    @available(*, noasync, message: "Use the async alternative")
     func addOrUpdate(
         for url: URL,
         user: String,
@@ -31,9 +32,34 @@ public protocol AuthorizationWriter {
         callback: @escaping (Result<Void, Error>) -> Void
     )
 
+    @available(*, noasync, message: "Use the async alternative")
     func remove(for url: URL, callback: @escaping (Result<Void, Error>) -> Void)
 }
 
+public extension AuthorizationWriter {
+    func addOrUpdate(
+        for url: URL,
+        user: String,
+        password: String,
+        persist: Bool = true
+    ) async throws {
+        try await safe_async {
+            self.addOrUpdate(
+                for: url,
+                user: user,
+                password: password, 
+                persist: persist,
+                callback: $0)
+        }
+    }
+
+    func remove(for url: URL) async throws {
+        try await safe_async {
+            self.remove(for: url, callback: $0)
+        }
+    }
+}
+
 public enum AuthorizationProviderError: Error {
     case invalidURLHost
     case notFound

Sources/Basics/Concurrency/ConcurrencyHelpers.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import _Concurrency
 import Dispatch
 import class Foundation.NSLock
 import class Foundation.ProcessInfo
@@ -46,6 +47,34 @@ extension DispatchQueue {
     )
 }
 
+/// Bridges between potentially blocking methods that take a result completion closure and async/await
+public func safe_async<T, ErrorType: Error>(_ body: @escaping (@escaping (Result<T, ErrorType>) -> Void) -> Void) async throws -> T {
+    try await withCheckedThrowingContinuation { continuation in
+        // It is possible that body make block indefinitely on a lock, sempahore,
+        // or similar then synchrously call the completion handler. For full safety
+        // it is essential to move the execution off the swift concurrency pool
+        DispatchQueue.sharedConcurrent.async {
+            body {
+                continuation.resume(with: $0)
+            }
+        }
+    }
+}
+
+/// Bridges between potentially blocking methods that take a result completion closure and async/await
+public func safe_async<T>(_ body: @escaping (@escaping (Result<T, Never>) -> Void) -> Void) async -> T {
+    await withCheckedContinuation { continuation in
+        // It is possible that body make block indefinitely on a lock, sempahore,
+        // or similar then synchrously call the completion handler. For full safety
+        // it is essential to move the execution off the swift concurrency pool
+        DispatchQueue.sharedConcurrent.async {
+            body {
+                continuation.resume(with: $0)
+            }
+        }
+    }
+}
+
 #if !canImport(Darwin)
 // As of Swift 5.7 and 5.8 swift-corelibs-foundation doesn't have `Sendable` annotations yet.
 extension URL: @unchecked Sendable {}

Sources/SPMTestSupport/XCTAssertHelpers.swift

@@ -49,6 +49,23 @@ public func XCTSkipIfCI(file: StaticString = #filePath, line: UInt = #line) thro
     }
 }
 
+/// An `async`-friendly replacement for `XCTAssertThrowsError`.
+public func XCTAssertAsyncThrowsError<T>(
+    _ expression: @autoclosure () async throws -> T,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #filePath,
+    line: UInt = #line,
+    _ errorHandler: (_ error: any Error) -> Void = { _ in }
+) async {
+    do {
+        _ = try await expression()
+        XCTFail(message(), file: file, line: line)
+    } catch {
+        errorHandler(error)
+    }
+}
+
+
 public func XCTAssertBuilds(
     _ path: AbsolutePath,
     configurations: Set<Configuration> = [.Debug, .Release],
@@ -133,6 +150,26 @@ public func XCTAssertEqual<T: CustomStringConvertible>(
     XCTAssertEqual(actual, expected, file: file, line: line)
 }
 
+public func XCTAssertAsyncTrue(
+    _ expression: @autoclosure () async throws -> Bool,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #filePath,
+    line: UInt = #line
+) async rethrows {
+    let result = try await expression()
+    XCTAssertTrue(result, message(), file: file, line: line)
+}
+
+public func XCTAssertAsyncFalse(
+    _ expression: @autoclosure () async throws -> Bool,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #filePath,
+    line: UInt = #line
+) async rethrows {
+    let result = try await expression()
+    XCTAssertFalse(result, message(), file: file, line: line)
+}
+
 public func XCTAssertThrowsCommandExecutionError<T>(
     _ expression: @autoclosure () throws -> T,
     _ message: @autoclosure () -> String = "",

Tests/BasicsTests/Archiver/TarArchiverTests.swift

@@ -19,51 +19,51 @@ import class TSCBasic.InMemoryFileSystem
 import struct TSCBasic.FileSystemError
 
 final class TarArchiverTests: XCTestCase {
-    func testSuccess() throws {
-        try testWithTemporaryDirectory { tmpdir in
+    func testSuccess() async throws {
+        try await testWithTemporaryDirectory { tmpdir in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let inputArchivePath = AbsolutePath(#file).parentDirectory
                 .appending(components: "Inputs", "archive.tar.gz")
-            try archiver.extract(from: inputArchivePath, to: tmpdir)
+            try await archiver.extract(from: inputArchivePath, to: tmpdir)
             let content = tmpdir.appending("file")
             XCTAssert(localFileSystem.exists(content))
             XCTAssertEqual((try? localFileSystem.readFileContents(content))?.cString, "Hello World!")
         }
     }
 
-    func testArchiveDoesntExist() {
+    func testArchiveDoesntExist() async {
         let fileSystem = InMemoryFileSystem()
         let archiver = TarArchiver(fileSystem: fileSystem)
         let archive = AbsolutePath("/archive.tar.gz")
-        XCTAssertThrowsError(try archiver.extract(from: archive, to: "/")) { error in
+        await XCTAssertAsyncThrowsError(try await archiver.extract(from: archive, to: "/")) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, archive))
         }
     }
 
-    func testDestinationDoesntExist() throws {
+    func testDestinationDoesntExist() async throws {
         let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.tar.gz")
         let archiver = TarArchiver(fileSystem: fileSystem)
         let destination = AbsolutePath("/destination")
-        XCTAssertThrowsError(try archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
+        await XCTAssertAsyncThrowsError(try await archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
         }
     }
 
-    func testDestinationIsFile() throws {
+    func testDestinationIsFile() async {
         let fileSystem = InMemoryFileSystem(emptyFiles: "/archive.tar.gz", "/destination")
         let archiver = TarArchiver(fileSystem: fileSystem)
         let destination = AbsolutePath("/destination")
-        XCTAssertThrowsError(try archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
+        await XCTAssertAsyncThrowsError(try await archiver.extract(from: "/archive.tar.gz", to: destination)) { error in
             XCTAssertEqual(error as? FileSystemError, FileSystemError(.notDirectory, destination))
         }
     }
 
-    func testInvalidArchive() throws {
-        try testWithTemporaryDirectory { tmpdir in
+    func testInvalidArchive() async throws {
+        try await testWithTemporaryDirectory { tmpdir in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let inputArchivePath = AbsolutePath(#file).parentDirectory
                 .appending(components: "Inputs", "invalid_archive.tar.gz")
-            XCTAssertThrowsError(try archiver.extract(from: inputArchivePath, to: tmpdir)) { error in
+            await XCTAssertAsyncThrowsError(try await archiver.extract(from: inputArchivePath, to: tmpdir)) { error in
                 #if os(Linux)
                 XCTAssertMatch((error as? StringError)?.description, .contains("not in gzip format"))
                 #else
@@ -73,39 +73,39 @@ final class TarArchiverTests: XCTestCase {
         }
     }
 
-    func testValidation() throws {
+    func testValidation() async throws {
         // valid
-        try testWithTemporaryDirectory { _ in
+        try await testWithTemporaryDirectory { _ in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let path = AbsolutePath(#file).parentDirectory
                 .appending(components: "Inputs", "archive.tar.gz")
-            XCTAssertTrue(try archiver.validate(path: path))
+            try await XCTAssertAsyncTrue(try await archiver.validate(path: path))
         }
         // invalid
-        try testWithTemporaryDirectory { _ in
+        try await testWithTemporaryDirectory { _ in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let path = AbsolutePath(#file).parentDirectory
                 .appending(components: "Inputs", "invalid_archive.tar.gz")
-            XCTAssertFalse(try archiver.validate(path: path))
+            try await XCTAssertAsyncFalse(try await archiver.validate(path: path))
         }
         // error
-        try testWithTemporaryDirectory { _ in
+        try await  testWithTemporaryDirectory { _ in
             let archiver = TarArchiver(fileSystem: localFileSystem)
             let path = AbsolutePath.root.appending("does_not_exist.tar.gz")
-            XCTAssertThrowsError(try archiver.validate(path: path)) { error in
+            await XCTAssertAsyncThrowsError(try await archiver.validate(path: path)) { error in
                 XCTAssertEqual(error as? FileSystemError, FileSystemError(.noEntry, path))
             }
         }
     }
 
-    func testCompress() throws {
+    func testCompress() async throws {
         #if os(Linux)
         guard SPM_posix_spawn_file_actions_addchdir_np_supported() else {
             throw XCTSkip("working directory not supported on this platform")
         }
         #endif
 
-        try testWithTemporaryDirectory { tmpdir in
+        try await testWithTemporaryDirectory { tmpdir in
             let archiver = TarArchiver(fileSystem: localFileSystem)
 
             let rootDir = tmpdir.appending(component: UUID().uuidString)
@@ -122,12 +122,12 @@ final class TarArchiverTests: XCTestCase {
             try localFileSystem.writeFileContents(dir2.appending("file4.txt"), string: "Hello World 4!")
 
             let archivePath = tmpdir.appending(component: UUID().uuidString + ".tar.gz")
-            try archiver.compress(directory: rootDir, to: archivePath)
+            try await archiver.compress(directory: rootDir, to: archivePath)
             XCTAssertFileExists(archivePath)
 
             let extractRootDir = tmpdir.appending(component: UUID().uuidString)
             try localFileSystem.createDirectory(extractRootDir)
-            try archiver.extract(from: archivePath, to: extractRootDir)
+            try await archiver.extract(from: archivePath, to: extractRootDir)
             try localFileSystem.stripFirstLevel(of: extractRootDir)
 
             XCTAssertFileExists(extractRootDir.appending("file1.txt"))