Migrate swiftly to swift testing (#304)

Streamline passing of test contexts to common Swiftly API

Remove extraneous HTTP requests during most testing

Fully sandbox and mock GPG key import and verification so that it never pollutes the
user's configuration.

Introduce test scoping traits to remove many of the with... closures needed for mocking

Move the toolchain constants into ToolchainVersion and Set for shorter lists and static references

Introduce test parameters and test scoping traits to reduce nesting within test cases

Increase HTTP timeouts to help with timeouts in CI

Improve test temporary file cleanup

Run HTTPClientTests serially to avoid network contention and add retries.

Create OpenAPI client in a single place for better consistency and remove unused Response

Author: cmcgee1024

Sources/LinuxPlatform/Linux.swift

@@ -1,8 +1,6 @@
 import Foundation
 import SwiftlyCore
 
-var swiftGPGKeysRefreshed = false
-
 /// `Platform` implementation for Linux systems.
 /// This implementation can be reused for any supported Linux platform.
 /// TODO: replace dummy implementations
@@ -29,25 +27,21 @@ public struct Linux: Platform {
         }
     }
 
-    public var swiftlyBinDir: URL {
-        SwiftlyCore.mockedHomeDir.map { $0.appendingPathComponent("bin", isDirectory: true) }
+    public func swiftlyBinDir(_ ctx: SwiftlyCoreContext) -> URL {
+        ctx.mockedHomeDir.map { $0.appendingPathComponent("bin", isDirectory: true) }
             ?? ProcessInfo.processInfo.environment["SWIFTLY_BIN_DIR"].map { URL(fileURLWithPath: $0) }
             ?? FileManager.default.homeDirectoryForCurrentUser
             .appendingPathComponent(".local/share/swiftly/bin", isDirectory: true)
     }
 
-    public var swiftlyToolchainsDir: URL {
-        self.swiftlyHomeDir.appendingPathComponent("toolchains", isDirectory: true)
+    public func swiftlyToolchainsDir(_ ctx: SwiftlyCoreContext) -> URL {
+        self.swiftlyHomeDir(ctx).appendingPathComponent("toolchains", isDirectory: true)
     }
 
     public var toolchainFileExtension: String {
         "tar.gz"
     }
 
-    public func isSystemDependencyPresent(_: SystemDependency) -> Bool {
-        true
-    }
-
     private static let skipVerificationMessage: String = "To skip signature verification, specify the --no-verify flag."
 
     public func verifySwiftlySystemPrerequisites() throws {
@@ -73,7 +67,7 @@ public struct Linux: Platform {
         }
     }
 
-    public func verifySystemPrerequisitesForInstall(httpClient: SwiftlyHTTPClient, platformName: String, version _: ToolchainVersion, requireSignatureValidation: Bool) async throws -> String? {
+    public func verifySystemPrerequisitesForInstall(_ ctx: SwiftlyCoreContext, platformName: String, version _: ToolchainVersion, requireSignatureValidation: Bool) async throws -> String? {
         // TODO: these are hard-coded until we have a place to query for these based on the toolchain version
         // These lists were copied from the dockerfile sources here: https://github.com/apple/swift-docker/tree/ea035798755cce4ec41e0c6dbdd320904cef0421/5.10
         let packages: [String] = switch platformName {
@@ -264,22 +258,21 @@ public struct Linux: Platform {
                 throw SwiftlyError(message: msg)
             }
 
-            // Import the latest swift keys, but only once per session, which will help with the performance in tests
-            if !swiftGPGKeysRefreshed {
-                let tmpFile = self.getTempFilePath()
-                let _ = FileManager.default.createFile(atPath: tmpFile.path, contents: nil, attributes: [.posixPermissions: 0o600])
-                defer {
-                    try? FileManager.default.removeItem(at: tmpFile)
-                }
+            let tmpFile = self.getTempFilePath()
+            let _ = FileManager.default.createFile(atPath: tmpFile.path, contents: nil, attributes: [.posixPermissions: 0o600])
+            defer {
+                try? FileManager.default.removeItem(at: tmpFile)
+            }
 
-                guard let url = URL(string: "https://www.swift.org/keys/all-keys.asc") else {
-                    throw SwiftlyError(message: "malformed URL to the swift gpg keys")
-                }
+            guard let url = URL(string: "https://www.swift.org/keys/all-keys.asc") else {
+                throw SwiftlyError(message: "malformed URL to the swift gpg keys")
+            }
 
-                try await httpClient.downloadFile(url: url, to: tmpFile)
+            try await ctx.httpClient.downloadFile(url: url, to: tmpFile)
+            if let mockedHomeDir = ctx.mockedHomeDir {
+                try self.runProgram("gpg", "--import", tmpFile.path, quiet: true, env: ["GNUPGHOME": mockedHomeDir.appendingPathComponent(".gnupg").path])
+            } else {
                 try self.runProgram("gpg", "--import", tmpFile.path, quiet: true)
-
-                swiftGPGKeysRefreshed = true
             }
         }
 
@@ -330,17 +323,17 @@ public struct Linux: Platform {
         }
     }
 
-    public func install(from tmpFile: URL, version: ToolchainVersion, verbose: Bool) throws {
+    public func install(_ ctx: SwiftlyCoreContext, from tmpFile: URL, version: ToolchainVersion, verbose: Bool) throws {
         guard tmpFile.fileExists() else {
             throw SwiftlyError(message: "\(tmpFile) doesn't exist")
         }
 
-        if !self.swiftlyToolchainsDir.fileExists() {
-            try FileManager.default.createDirectory(at: self.swiftlyToolchainsDir, withIntermediateDirectories: false)
+        if !self.swiftlyToolchainsDir(ctx).fileExists() {
+            try FileManager.default.createDirectory(at: self.swiftlyToolchainsDir(ctx), withIntermediateDirectories: false)
         }
 
-        SwiftlyCore.print("Extracting toolchain...")
-        let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent(version.name)
+        ctx.print("Extracting toolchain...")
+        let toolchainDir = self.swiftlyToolchainsDir(ctx).appendingPathComponent(version.name)
 
         if toolchainDir.fileExists() {
             try FileManager.default.removeItem(at: toolchainDir)
@@ -354,23 +347,26 @@ public struct Linux: Platform {
             let destination = toolchainDir.appendingPathComponent(String(relativePath))
 
             if verbose {
-                SwiftlyCore.print("\(destination.path)")
+                ctx.print("\(destination.path)")
             }
 
             // prepend /path/to/swiftlyHomeDir/toolchains/<toolchain> to each file name
             return destination
         }
     }
 
-    public func extractSwiftlyAndInstall(from archive: URL) throws {
+    public func extractSwiftlyAndInstall(_ ctx: SwiftlyCoreContext, from archive: URL) throws {
         guard archive.fileExists() else {
             throw SwiftlyError(message: "\(archive) doesn't exist")
         }
 
         let tmpDir = self.getTempFilePath()
+        defer {
+            try? FileManager.default.removeItem(at: tmpDir)
+        }
         try FileManager.default.createDirectory(atPath: tmpDir.path, withIntermediateDirectories: true)
 
-        SwiftlyCore.print("Extracting new swiftly...")
+        ctx.print("Extracting new swiftly...")
         try extractArchive(atPath: archive) { name in
             // Extract to the temporary directory
             tmpDir.appendingPathComponent(String(name))
@@ -379,8 +375,8 @@ public struct Linux: Platform {
         try self.runProgram(tmpDir.appendingPathComponent("swiftly").path, "init")
     }
 
-    public func uninstall(_ toolchain: ToolchainVersion, verbose _: Bool) throws {
-        let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent(toolchain.name)
+    public func uninstall(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, verbose _: Bool) throws {
+        let toolchainDir = self.swiftlyToolchainsDir(ctx).appendingPathComponent(toolchain.name)
         try FileManager.default.removeItem(at: toolchainDir)
     }
 
@@ -394,9 +390,9 @@ public struct Linux: Platform {
         FileManager.default.temporaryDirectory.appendingPathComponent("swiftly-\(UUID())")
     }
 
-    public func verifySignature(httpClient: SwiftlyHTTPClient, archiveDownloadURL: URL, archive: URL, verbose: Bool) async throws {
+    public func verifySignature(_ ctx: SwiftlyCoreContext, archiveDownloadURL: URL, archive: URL, verbose: Bool) async throws {
         if verbose {
-            SwiftlyCore.print("Downloading toolchain signature...")
+            ctx.print("Downloading toolchain signature...")
         }
 
         let sigFile = self.getTempFilePath()
@@ -405,20 +401,24 @@ public struct Linux: Platform {
             try? FileManager.default.removeItem(at: sigFile)
         }
 
-        try await httpClient.downloadFile(
+        try await ctx.httpClient.downloadFile(
             url: archiveDownloadURL.appendingPathExtension("sig"),
             to: sigFile
         )
 
-        SwiftlyCore.print("Verifying toolchain signature...")
+        ctx.print("Verifying toolchain signature...")
         do {
-            try self.runProgram("gpg", "--verify", sigFile.path, archive.path, quiet: !verbose)
+            if let mockedHomeDir = ctx.mockedHomeDir {
+                try self.runProgram("gpg", "--verify", sigFile.path, archive.path, quiet: false, env: ["GNUPGHOME": mockedHomeDir.appendingPathComponent(".gnupg").path])
+            } else {
+                try self.runProgram("gpg", "--verify", sigFile.path, archive.path, quiet: !verbose)
+            }
         } catch {
             throw SwiftlyError(message: "Signature verification failed: \(error).")
         }
     }
 
-    private func manualSelectPlatform(_ platformPretty: String?) async -> PlatformDefinition {
+    private func manualSelectPlatform(_ ctx: SwiftlyCoreContext, _ platformPretty: String?) async -> PlatformDefinition {
         if let platformPretty {
             print("\(platformPretty) is not an officially supported platform, but the toolchains for another platform may still work on it.")
         } else {
@@ -434,7 +434,7 @@ public struct Linux: Platform {
         \(selections)
         """)
 
-        let choice = SwiftlyCore.readLine(prompt: "Pick one of the available selections [0-\(self.linuxPlatforms.count)] ") ?? "0"
+        let choice = ctx.readLine(prompt: "Pick one of the available selections [0-\(self.linuxPlatforms.count)] ") ?? "0"
 
         guard let choiceNum = Int(choice) else {
             fatalError("Installation canceled")
@@ -447,7 +447,7 @@ public struct Linux: Platform {
         return self.linuxPlatforms[choiceNum - 1]
     }
 
-    public func detectPlatform(disableConfirmation: Bool, platform: String?) async throws -> PlatformDefinition {
+    public func detectPlatform(_ ctx: SwiftlyCoreContext, disableConfirmation: Bool, platform: String?) async throws -> PlatformDefinition {
         // We've been given a hint to use
         if let platform {
             guard let pd = linuxPlatforms.first(where: { $0.nameFull == platform }) else {
@@ -475,7 +475,7 @@ public struct Linux: Platform {
             } else {
                 print(message)
             }
-            return await self.manualSelectPlatform(platformPretty)
+            return await self.manualSelectPlatform(ctx, platformPretty)
         }
 
         let releaseInfo = try String(contentsOfFile: releaseFile, encoding: .utf8)
@@ -502,7 +502,7 @@ public struct Linux: Platform {
             } else {
                 print(message)
             }
-            return await self.manualSelectPlatform(platformPretty)
+            return await self.manualSelectPlatform(ctx, platformPretty)
         }
 
         if (id + (idlike ?? "")).contains("amzn") {
@@ -513,7 +513,7 @@ public struct Linux: Platform {
                 } else {
                     print(message)
                 }
-                return await self.manualSelectPlatform(platformPretty)
+                return await self.manualSelectPlatform(ctx, platformPretty)
             }
 
             return .amazonlinux2
@@ -525,7 +525,7 @@ public struct Linux: Platform {
                 } else {
                     print(message)
                 }
-                return await self.manualSelectPlatform(platformPretty)
+                return await self.manualSelectPlatform(ctx, platformPretty)
             }
 
             return .rhel9
@@ -539,7 +539,7 @@ public struct Linux: Platform {
         } else {
             print(message)
         }
-        return await self.manualSelectPlatform(platformPretty)
+        return await self.manualSelectPlatform(ctx, platformPretty)
     }
 
     public func getShell() async throws -> String {
@@ -559,8 +559,8 @@ public struct Linux: Platform {
         return "/bin/bash"
     }
 
-    public func findToolchainLocation(_ toolchain: ToolchainVersion) -> URL {
-        self.swiftlyToolchainsDir.appendingPathComponent("\(toolchain.name)")
+    public func findToolchainLocation(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) -> URL {
+        self.swiftlyToolchainsDir(ctx).appendingPathComponent("\(toolchain.name)")
     }
 
     public static let currentPlatform: any Platform = Linux()