Adjust error messages

Add test cases

Control verbosity of uninstall operation on macOS and other platforms

Author: cmcgee1024

Sources/LinuxPlatform/Linux.swift

@@ -376,7 +376,7 @@ public struct Linux: Platform {
         try self.runProgram(tmpDir.appendingPathComponent("swiftly").path, "init")
     }
 
-    public func uninstall(_ toolchain: ToolchainVersion) throws {
+    public func uninstall(_ toolchain: ToolchainVersion, verbose _: Bool) throws {
         let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent(toolchain.name)
         try FileManager.default.removeItem(at: toolchainDir)
     }

Sources/MacOSPlatform/MacOS.swift

@@ -120,7 +120,7 @@ public struct MacOS: Platform {
         try self.runProgram(homeDir.appendingPathComponent("usr/local/bin/swiftly").path, "init")
     }
 
-    public func uninstall(_ toolchain: ToolchainVersion) throws {
+    public func uninstall(_ toolchain: ToolchainVersion, verbose: Bool) throws {
         SwiftlyCore.print("Uninstalling package in user home directory...")
 
         let toolchainDir = self.swiftlyToolchainsDir.appendingPathComponent("\(toolchain.identifier).xctoolchain", isDirectory: true)
@@ -138,7 +138,7 @@ public struct MacOS: Platform {
         try FileManager.default.removeItem(at: toolchainDir)
 
         let homedir = ProcessInfo.processInfo.environment["HOME"]!
-        try? runProgram("pkgutil", "--volume", homedir, "--forget", pkgInfo.CFBundleIdentifier)
+        try? runProgram("pkgutil", "--volume", homedir, "--forget", pkgInfo.CFBundleIdentifier, quiet: !verbose)
     }
 
     public func getExecutableName() -> String {

Sources/Swiftly/Proxy.swift

@@ -53,7 +53,7 @@ public enum Proxy {
             }
 
             guard let toolchain = toolchain else {
-                throw SwiftlyError(message: "No swift toolchain could be selected from either from a .swift-version file, or the default. You can try using `swiftly install <toolchain version>` to install one.")
+                throw SwiftlyError(message: "No installed swift toolchain is selected from either from a .swift-version file, or the default. You can try using one that's already installed with `swiftly use <toolchain version>` or install a new toolchain to use with `swiftly install --use <toolchain version>`.")
             }
 
             // Prevent circularities with a memento environment variable

Sources/Swiftly/Run.swift

@@ -86,7 +86,7 @@ internal struct Run: SwiftlyCommand {
         }
 
         guard let toolchain = toolchain else {
-            throw SwiftlyError(message: "No swift toolchain could be selected from either from a .swift-version file, or the default. You can try using `swiftly install <toolchain version>` to install one.")
+            throw SwiftlyError(message: "No installed swift toolchain is selected from either from a .swift-version file, or the default. You can try using one that's already installed with `swiftly use <toolchain version>` or install a new toolchain to use with `swiftly install --use <toolchain version>`.")
         }
 
         do {

Sources/Swiftly/Uninstall.swift

@@ -113,14 +113,14 @@ struct Uninstall: SwiftlyCommand {
                 }
             }
 
-            try await Self.execute(toolchain, &config)
+            try await Self.execute(toolchain, &config, verbose: self.root.verbose)
         }
 
         SwiftlyCore.print()
         SwiftlyCore.print("\(toolchains.count) toolchain(s) successfully uninstalled")
     }
 
-    static func execute(_ toolchain: ToolchainVersion, _ config: inout Config) async throws {
+    static func execute(_ toolchain: ToolchainVersion, _ config: inout Config, verbose: Bool) async throws {
         SwiftlyCore.print("Uninstalling \(toolchain)...", terminator: "")
         config.installedToolchains.remove(toolchain)
         // This is here to prevent the inUse from referencing a toolchain that is not installed
@@ -129,7 +129,7 @@ struct Uninstall: SwiftlyCommand {
         }
         try config.save()
 
-        try Swiftly.currentPlatform.uninstall(toolchain)
+        try Swiftly.currentPlatform.uninstall(toolchain, verbose: verbose)
         SwiftlyCore.print("done")
     }
 }

Sources/Swiftly/Update.swift

@@ -117,7 +117,7 @@ struct Update: SwiftlyCommand {
             assumeYes: self.root.assumeYes
         )
 
-        try await Uninstall.execute(parameters.oldToolchain, &config)
+        try await Uninstall.execute(parameters.oldToolchain, &config, verbose: self.root.verbose)
         SwiftlyCore.print("Successfully updated \(parameters.oldToolchain) ⟶ \(newToolchain)")
 
         if let postInstallScript = postInstallScript {

Sources/SwiftlyCore/Platform.swift

@@ -72,7 +72,7 @@ public protocol Platform {
 
     /// Uninstalls a toolchain associated with the given version.
     /// If this version is in use, the next latest version will be used afterwards.
-    func uninstall(_ version: ToolchainVersion) throws
+    func uninstall(_ version: ToolchainVersion, verbose: Bool) throws
 
     /// Get the name of the swiftly release binary.
     func getExecutableName() -> String

Tests/SwiftlyTests/PlatformTests.swift

@@ -53,21 +53,21 @@ final class PlatformTests: SwiftlyTests {
             (mockedToolchainFile, version) = try await self.mockToolchainDownload(version: "5.6.3")
             try Swiftly.currentPlatform.install(from: mockedToolchainFile, version: version, verbose: true)
             // WHEN: one of the toolchains is uninstalled
-            try Swiftly.currentPlatform.uninstall(version)
+            try Swiftly.currentPlatform.uninstall(version, verbose: true)
             // THEN: there is only one remaining toolchain installed
             var toolchains = try FileManager.default.contentsOfDirectory(at: Swiftly.currentPlatform.swiftlyToolchainsDir, includingPropertiesForKeys: nil)
             XCTAssertEqual(1, toolchains.count)
 
             // GIVEN; there is only one toolchain installed
             // WHEN: a non-existent toolchain is uninstalled
-            try? Swiftly.currentPlatform.uninstall(ToolchainVersion(parsing: "5.9.1"))
+            try? Swiftly.currentPlatform.uninstall(ToolchainVersion(parsing: "5.9.1"), verbose: true)
             // THEN: there is the one remaining toolchain that is still installed
             toolchains = try FileManager.default.contentsOfDirectory(at: Swiftly.currentPlatform.swiftlyToolchainsDir, includingPropertiesForKeys: nil)
             XCTAssertEqual(1, toolchains.count)
 
             // GIVEN: there is only one toolchain installed
             // WHEN: the last toolchain is uninstalled
-            try Swiftly.currentPlatform.uninstall(ToolchainVersion(parsing: "5.8.0"))
+            try Swiftly.currentPlatform.uninstall(ToolchainVersion(parsing: "5.8.0"), verbose: true)
             // THEN: there are no toolchains installed
             toolchains = try FileManager.default.contentsOfDirectory(at: Swiftly.currentPlatform.swiftlyToolchainsDir, includingPropertiesForKeys: nil)
             XCTAssertEqual(0, toolchains.count)

Tests/SwiftlyTests/UninstallTests.swift

@@ -296,4 +296,22 @@ final class UninstallTests: SwiftlyTests {
             )
         }
     }
+
+    /// Tests that uninstalling a toolchain that is the global default, but is not in the list of installed toolchains.
+    func testUninstallNotInstalled() async throws {
+        let toolchains = Set([Self.oldStable, Self.newStable, Self.newMainSnapshot, Self.oldReleaseSnapshot])
+        try await self.withMockedHome(homeName: Self.homeName, toolchains: toolchains, inUse: Self.newMainSnapshot) {
+            var config = try await Config.load()
+            config.inUse = Self.newMainSnapshot
+            config.installedToolchains.remove(Self.newMainSnapshot)
+            try await config.save()
+
+            var uninstall = try self.parseCommand(Uninstall.self, ["uninstall", "-y", Self.newMainSnapshot.name])
+            _ = try await uninstall.run()
+            try await self.validateInstalledToolchains(
+                [Self.oldStable, Self.newStable, Self.oldReleaseSnapshot],
+                description: "uninstall did not uninstall all toolchains"
+            )
+        }
+    }
 }

Tests/SwiftlyTests/UpdateTests.swift

@@ -109,9 +109,9 @@ final class UpdateTests: SwiftlyTests {
         }
     }
 
-    /// Verifies that updating the currently in-use toolchain can be updated, and that after update the new toolchain
-    /// will be in-use instead.
-    func testUpdateInUse() async throws {
+    /// Verifies that updating the currently global default toolchain can be updated, and that after update the new toolchain
+    /// will be the global default instead.
+    func testUpdateGlobalDefault() async throws {
         try await self.withTestHome {
             try await self.withMockedToolchain {
                 try await self.installMockedToolchain(selector: "6.0.0")
@@ -136,6 +136,34 @@ final class UpdateTests: SwiftlyTests {
         }
     }
 
+    /// Verifies that updating the currently in-use toolchain can be updated, and that after update the new toolchain
+    /// will be in-use with the swift version file updated.
+    func testUpdateInUse() async throws {
+        try await self.withTestHome {
+            try await self.withMockedToolchain {
+                try await self.installMockedToolchain(selector: "6.0.0")
+
+                let versionFile = URL(fileURLWithPath: FileManager.default.currentDirectoryPath).appendingPathComponent(".swift-version")
+                try "6.0.0".write(to: versionFile, atomically: true, encoding: .utf8)
+
+                var update = try self.parseCommand(Update.self, ["update", "-y", "--no-verify", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
+                try await update.run()
+
+                let versionFileContents = try String(contentsOf: versionFile, encoding: .utf8)
+                let inUse = try ToolchainVersion(parsing: versionFileContents)
+                XCTAssertGreaterThan(inUse, .init(major: 6, minor: 0, patch: 0))
+
+                // Since the global default was set to 6.0.0, and that toolchain is no longer installed
+                // the update should have unset it to prevent the config from going into a bad state.
+                let config = try Config.load()
+                XCTAssertTrue(config.inUse == nil)
+
+                // The new toolchain should be installed
+                XCTAssertTrue(config.installedToolchains.contains(inUse))
+            }
+        }
+    }
+
     /// Verifies that snapshots, both from the main branch and from development branches, can be updated.
     func testUpdateSnapshot() async throws {
         let snapshotsAvailable = try await self.snapshotsAvailable()