Write run command and proxy tests

Sources/Swiftly/Run.swift

@@ -46,11 +46,11 @@ internal struct Run: SwiftlyCommand {
             $ swiftly run ./myscript.sh ++abcde
 
         The script will receive the argument as '+abcde'. If there are multiple arguments with the '+' prefix \
-        that should be escaped you can disable the selection using a '++++' argument, which turns off any \
+        that should be escaped you can disable the selection using a '++' argument, which turns off any \
         selector argument processing for subsequent arguments. This is anologous to the '--' that turns off \
         flag and option processing for subsequent arguments in many argument parsers.
 
-            $ swiftly run ./myscript.sh ++++ +abcde +xyz
+            $ swiftly run ./myscript.sh ++ +abcde +xyz
 
         The script will receive the argument '+abcde' followed by '+xyz'.
         """
@@ -60,40 +60,10 @@ internal struct Run: SwiftlyCommand {
     internal mutating func run() async throws {
         try validateSwiftly()
 
-        var escapedCommand: [String] = []
-        var selector: ToolchainSelector?
-        var install = false
-        var disableEscaping = false
-        for c in self.command {
-            if !disableEscaping && c == "++++" {
-                disableEscaping = true
-                continue
-            }
-
-            if !disableEscaping && c.hasPrefix("++") {
-                escapedCommand.append("+\(String(c.dropFirst(2)))")
-                continue
-            }
-
-            if !disableEscaping && c == "+install" {
-                install = true
-                continue
-            }
-
-            if !disableEscaping && c.hasPrefix("+") {
-                selector = try ToolchainSelector(parsing: String(c.dropFirst()))
-                continue
-            }
-
-            escapedCommand.append(c)
-        }
-
-        guard escapedCommand.count > 0 else {
-            throw Error(message: "Provide at least one command to run")
-        }
-
         var config = try Config.load()
 
+        let (command, selector, install) = try extractProxyArguments(command: self.command)
+
         let toolchain: ToolchainVersion?
 
         if let selector = selector {
@@ -115,7 +85,7 @@ internal struct Run: SwiftlyCommand {
             } else {
                 let matchedToolchain = config.listInstalledToolchains(selector: selector).max()
                 guard let matchedToolchain = matchedToolchain else {
-                    throw Error(message: "The selected toolchain \(selector.description) didn't matched any of the installed toolchains. You can install it by adding '+install' to your command, or `swiftly install \(selector.description)`")
+                    throw Error(message: "The selected toolchain \(selector.description) didn't match any of the installed toolchains. You can install it by adding '+install' to your command, or `swiftly install \(selector.description)`")
                 }
 
                 toolchain = matchedToolchain
@@ -136,11 +106,56 @@ internal struct Run: SwiftlyCommand {
         }
 
         do {
-            try await Swiftly.currentPlatform.proxy(toolchain, escapedCommand[0], [String](escapedCommand[1...]))
+            if let outputHandler = SwiftlyCore.outputHandler {
+                if let output = try await Swiftly.currentPlatform.proxyOutput(toolchain, command[0], [String](command[1...])) {
+                    for line in output.split(separator: "\n") {
+                        outputHandler.handleOutputLine(String(line))
+                    }
+                }
+                return
+            }
+
+            try await Swiftly.currentPlatform.proxy(toolchain, command[0], [String](command[1...]))
         } catch let terminated as RunProgramError {
             Foundation.exit(terminated.exitCode)
         } catch {
             throw error
         }
     }
 }
+
+public func extractProxyArguments(command: [String]) throws -> (command: [String], selector: ToolchainSelector?, install: Bool) {
+    var args: (command: [String], selector: ToolchainSelector?, install: Bool) = (command: [], nil, false)
+
+    var disableEscaping = false
+
+    for c in command {
+        if !disableEscaping && c == "++" {
+            disableEscaping = true
+            continue
+        }
+
+        if !disableEscaping && c.hasPrefix("++") {
+            args.command.append("+\(String(c.dropFirst(2)))")
+            continue
+        }
+
+        if !disableEscaping && c == "+install" {
+            args.install = true
+            continue
+        }
+
+        if !disableEscaping && c.hasPrefix("+") {
+            args.selector = try ToolchainSelector(parsing: String(c.dropFirst()))
+            continue
+        }
+
+        args.command.append(c)
+    }
+
+    guard args.command.count > 0 else {
+        throw Error(message: "Provide at least one command to run.")
+    }
+
+    return args
+}

Sources/SwiftlyCore/Platform.swift

@@ -129,13 +129,7 @@ extension Platform {
     }
 
 #if os(macOS) || os(Linux)
-    /// Proxy the invocation of the provided command to the chosen toolchain.
-    ///
-    /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
-    /// the exit code and program information.
-    ///
-    public func proxy(_ toolchain: ToolchainVersion, _ command: String, _ arguments: [String]) async throws {
-        // The toolchain goes to the beginning of the path, and the SWIFTLY_BIN_DIR is removed from it
+    internal func proxyEnv(_ toolchain: ToolchainVersion) throws -> [String: String] {
         let tcPath = self.findToolchainLocation(toolchain).appendingPathComponent("usr/bin")
         var newEnv = ProcessInfo.processInfo.environment
 
@@ -145,21 +139,36 @@ extension Platform {
         }
         newEnv["SWIFTLY_PROXY_IN_PROGRESS"] = "1"
 
+        // The toolchain goes to the beginning of the PATH
         var newPath = newEnv["PATH"] ?? ""
         if !newPath.hasPrefix(tcPath.path + ":") {
-            newPath = ([tcPath.path] + newPath.split(separator: ":").map { String($0) }.filter { $0 != swiftlyBinDir.path }).joined(separator: ":")
+            newPath = ([tcPath.path] + newPath.split(separator: ":").map { String($0) }).joined(separator: ":")
         }
         newEnv["PATH"] = newPath
 
-        // Remove traces of swiftly environment variables
-        newEnv.removeValue(forKey: "SWIFTLY_BIN_DIR")
-        newEnv.removeValue(forKey: "SWIFTLY_HOME_DIR")
-
         // Add certain common environment variables that can be used to proxy to the toolchain
         newEnv["CC"] = tcPath.appendingPathComponent("clang").path
         newEnv["CXX"] = tcPath.appendingPathComponent("clang++").path
 
-        try self.runProgram([command] + arguments, env: newEnv)
+        return newEnv
+    }
+
+    /// Proxy the invocation of the provided command to the chosen toolchain.
+    ///
+    /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
+    /// the exit code and program information.
+    ///
+    public func proxy(_ toolchain: ToolchainVersion, _ command: String, _ arguments: [String]) async throws {
+        try self.runProgram([command] + arguments, env: self.proxyEnv(toolchain))
+    }
+
+    /// Proxy the invocation of the provided command to the chosen toolchain and capture the output.
+    ///
+    /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
+    /// the exit code and program information.
+    ///
+    public func proxyOutput(_ toolchain: ToolchainVersion, _ command: String, _ arguments: [String]) async throws -> String? {
+        try await self.runProgramOutput(command, arguments, env: self.proxyEnv(toolchain))
     }
 
     /// Run a program.
@@ -208,20 +217,24 @@ extension Platform {
     /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
     /// the exit code and program information.
     ///
-    public func runProgramOutput(_ program: String, _ args: String...) async throws -> String? {
-        try await self.runProgramOutput(program, [String](args))
+    public func runProgramOutput(_ program: String, _ args: String..., env: [String: String]? = nil) async throws -> String? {
+        try await self.runProgramOutput(program, [String](args), env: env)
     }
 
     /// Run a program and capture its output.
     ///
     /// In the case where the command exit with a non-zero exit code a RunProgramError is thrown with
     /// the exit code and program information.
     ///
-    public func runProgramOutput(_ program: String, _ args: [String]) async throws -> String? {
+    public func runProgramOutput(_ program: String, _ args: [String], env: [String: String]? = nil) async throws -> String? {
         let process = Process()
         process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
         process.arguments = [program] + args
 
+        if let env = env {
+            process.environment = env
+        }
+
         let outPipe = Pipe()
         process.standardInput = FileHandle.nullDevice
         process.standardError = FileHandle.nullDevice

Tests/SwiftlyTests/RunTests.swift

@@ -0,0 +1,101 @@
+import Foundation
+@testable import Swiftly
+@testable import SwiftlyCore
+import XCTest
+
+final class RunTests: SwiftlyTests {
+    static let homeName = "runTests"
+
+    /// Tests that the `run` command can switch between installed toolchains.
+    func testRunSelection() async throws {
+        try await self.withMockedHome(homeName: Self.homeName, toolchains: Self.allToolchains) {
+            // GIVEN: a set of installed toolchains
+            // WHEN: invoking the run command with a selector argument for that toolchain
+            var run = try self.parseCommand(Run.self, ["run", "swift", "--version", "+\(Self.newStable.name)"])
+            var output = try await run.runWithMockedIO()
+            // THEN: the output confirms that it ran with the selected toolchain
+            XCTAssert(output.contains(Self.newStable.name))
+
+            // GIVEN: a set of installed toolchains and one is selected with a .swift-version file
+            let versionFile = URL(fileURLWithPath: FileManager.default.currentDirectoryPath).appendingPathComponent(".swift-version")
+            try Self.oldStable.name.write(to: versionFile, atomically: true, encoding: .utf8)
+            // WHEN: invoking the run command without any selector arguments for toolchains
+            run = try self.parseCommand(Run.self, ["run", "swift", "--version"])
+            output = try await run.runWithMockedIO()
+            // THEN: the output confirms that it ran with the selected toolchain
+            XCTAssert(output.contains(Self.oldStable.name))
+
+            // GIVEN: a set of installed toolchains
+            // WHEN: invoking the run command with a selector argument for a toolchain that isn't installed
+            run = try self.parseCommand(Run.self, ["run", "swift", "+1.2.3", "--version"])
+            do {
+                try await run.run()
+                XCTAssert(false)
+            } catch let e as Error {
+                XCTAssert(e.message.contains("didn't match any of the installed toolchains"))
+            }
+            // THEN: an error is shown because there is no matching toolchain that is installed
+        }
+    }
+
+    /// Tests the `run` command verifying that the environment is as expected
+    func testRunEnvironment() async throws {
+        try await self.withMockedHome(homeName: Self.homeName, toolchains: Self.allToolchains) {
+            // The toolchains directory should be the fist entry on the path
+            var run = try self.parseCommand(Run.self, ["run", try await Swiftly.currentPlatform.getShell(), "-c", "echo $PATH"])
+            var output = try await run.runWithMockedIO()
+            XCTAssert(output[0].contains(Swiftly.currentPlatform.swiftlyToolchainsDir.path))
+
+            // The CC and CXX variables should be set to clang/clang++ in the toolchains
+            run = try self.parseCommand(Run.self, ["run", try await Swiftly.currentPlatform.getShell(), "-c", "echo $CC; echo $CXX"])
+            output = try await run.runWithMockedIO()
+            XCTAssert(output[0].hasPrefix(Swiftly.currentPlatform.swiftlyToolchainsDir.path))
+            XCTAssert(output[0].hasSuffix("clang"))
+            XCTAssert(output[1].hasPrefix(Swiftly.currentPlatform.swiftlyToolchainsDir.path))
+            XCTAssert(output[1].hasSuffix("clang++"))
+        }
+    }
+
+    /// Tests the extraction of proxy arguments from the run command arguments.
+    func testExtractProxyArguments() throws {
+        var (command, selector, install) = try extractProxyArguments(command: ["swift", "build"])
+        XCTAssertEqual(["swift", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(nil, selector)
+
+        (command, selector, install) = try extractProxyArguments(command: ["swift", "+1.2.3", "build"])
+        XCTAssertEqual(["swift", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(try! ToolchainSelector(parsing: "1.2.3"), selector)
+
+        (command, selector, install) = try extractProxyArguments(command: ["swift", "build", "+latest"])
+        XCTAssertEqual(["swift", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(try! ToolchainSelector(parsing: "latest"), selector)
+
+        (command, selector, install) = try extractProxyArguments(command: ["+5.6", "swift", "build"])
+        XCTAssertEqual(["swift", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(try! ToolchainSelector(parsing: "5.6"), selector)
+
+        (command, selector, install) = try extractProxyArguments(command: ["swift", "++1.2.3", "build"])
+        XCTAssertEqual(["swift", "+1.2.3", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(nil, selector)
+
+        (command, selector, install) = try extractProxyArguments(command: ["swift", "++", "+1.2.3", "build"])
+        XCTAssertEqual(["swift", "+1.2.3", "build"], command)
+        XCTAssertEqual(false, install)
+        XCTAssertEqual(nil, selector)
+
+        do {
+            let _ = try extractProxyArguments(command: ["+1.2.3"])
+            XCTAssert(false)
+        } catch {}
+
+        do {
+            let _ = try extractProxyArguments(command: [])
+            XCTAssert(false)
+        } catch {}
+    }
+}