Fix up the tests and system toolchain list output

Author: cmcgee1024

Sources/Swiftly/List.swift

@@ -63,16 +63,6 @@ struct List: SwiftlyCommand {
             )
         }
 
-#if os(macOS)
-        installedToolchainInfos.append(
-            InstallToolchainInfo(
-                version: ToolchainVersion.xcode,
-                inUse: inUse == ToolchainVersion.xcode,
-                isDefault: config.inUse == ToolchainVersion.xcode
-            )
-        )
-#endif
-
         try await ctx.output(InstalledToolchainsListInfo(toolchains: installedToolchainInfos, selector: selector))
     }
 }

Sources/Swiftly/OutputSchema.swift

@@ -320,6 +320,8 @@ struct InstalledToolchainsListInfo: OutputData {
                 "main development snapshot"
             case let .snapshot(.release(major, minor), nil):
                 "\(major).\(minor) development snapshot"
+            case .xcode:
+                "xcode"
             default:
                 "matching"
             }
@@ -340,6 +342,13 @@ struct InstalledToolchainsListInfo: OutputData {
             lines.append("Installed snapshot toolchains")
             lines.append("-----------------------------")
             lines.append(contentsOf: snapshotToolchains.map(\.description))
+
+#if os(macOS)
+            lines.append("")
+            lines.append("Available system toolchains")
+            lines.append("---------------------------")
+            lines.append(ToolchainVersion.xcode.description)
+#endif
         }
 
         return lines.joined(separator: "\n")

Tests/SwiftlyTests/InstallTests.swift

@@ -256,7 +256,7 @@ import Testing
     }
 
     /// Verify that the installed toolchain will be marked as in-use if the --use flag is specified.
-    @Test(.testHomeMockedToolchain()) func installUseFlag() async throws {
+    @Test(.mockedSwiftlyVersion(), .testHomeMockedToolchain()) func installUseFlag() async throws {
         try await SwiftlyTests.installMockedToolchain(toolchain: .oldStable)
         try await SwiftlyTests.runCommand(Use.self, ["use", ToolchainVersion.oldStable.name])
         try await SwiftlyTests.validateInUse(expected: .oldStable)

Tests/SwiftlyTests/ListTests.swift

@@ -51,17 +51,17 @@ import Testing
         let parsedToolchains = lines.compactMap { outputLine in
 #if !os(macOS)
             Set<ToolchainVersion>.allToolchains().first {
-                outputLine.contains(String(describing: $0))
+                outputLine.hasPrefix(String(describing: $0))
             }
 #else
             (Set<ToolchainVersion>.allToolchains() + [.xcodeVersion]).first {
-                outputLine.contains(String(describing: $0))
+                outputLine.hasPrefix(String(describing: $0))
             }
 #endif
         }
 
         // Ensure extra toolchains weren't accidentally included in the output.
-        guard parsedToolchains.count == lines.filter({ $0.hasPrefix("Swift") || $0.contains("-snapshot") || $0.contains("xcode") }).count else {
+        guard parsedToolchains.count == lines.filter({ $0.hasPrefix("Swift") || $0.contains("-snapshot") || $0.hasPrefix("xcode") }).count else {
             throw SwiftlyTestError(message: "unexpected listed toolchains in \(output)")
         }
 
@@ -182,13 +182,18 @@ import Testing
             #expect(toolchains == systemToolchains)
 
             toolchains = try await self.runList(selector: "5")
-            #expect(toolchains == systemToolchains)
+            #expect(toolchains == [])
 
             toolchains = try await self.runList(selector: "main-snapshot")
-            #expect(toolchains == systemToolchains)
+            #expect(toolchains == [])
 
             toolchains = try await self.runList(selector: "5.7-snapshot")
+            #expect(toolchains == [])
+
+#if os(macOS)
+            toolchains = try await self.runList(selector: "xcode")
             #expect(toolchains == systemToolchains)
+#endif
         }
     }
 
@@ -204,7 +209,13 @@ import Testing
                 from: output[0].data(using: .utf8)!
             )
 
-            #expect(listInfo.toolchains.count == Set<ToolchainVersion>.allToolchains().count)
+#if !os(macOS)
+            let systemToolchains: [ToolchainVersion] = []
+#else
+            let systemToolchains: [ToolchainVersion] = [.xcodeVersion]
+#endif
+
+            #expect(listInfo.toolchains.count == Set<ToolchainVersion>.allToolchains().count + systemToolchains.count)
 
             for toolchain in listInfo.toolchains {
                 #expect(toolchain.version.name.isEmpty == false)

Tests/SwiftlyTests/PlatformTests.swift

@@ -88,7 +88,7 @@ import Testing
     }
 
 #if os(macOS)
-    @Test(.testHome()) func findXcodeToolchainLocation() async throws {
+    @Test(.mockedSwiftlyVersion(), .testHome()) func findXcodeToolchainLocation() async throws {
         // GIVEN: the xcode toolchain
         // AND there is xcode installed
         guard let xcodeLocation = try? await Swiftly.currentPlatform.runProgramOutput("xcode-select", "-p"), xcodeLocation != "" else {

Tests/SwiftlyTests/SwiftlyTests.swift

@@ -61,15 +61,15 @@ actor InputProviderFail: InputProvider {
 }
 
 struct HTTPRequestExecutorFail: HTTPRequestExecutor {
-    func getCurrentSwiftlyRelease() async throws -> SwiftlyWebsiteAPI.Components.Schemas.SwiftlyRelease { fatalError(unmockedMsg + "3") }
-    func getReleaseToolchains() async throws -> [Components.Schemas.Release] { fatalError(unmockedMsg + "4") }
-    func getSnapshotToolchains(branch _: SwiftlyWebsiteAPI.Components.Schemas.SourceBranch, platform _: SwiftlyWebsiteAPI.Components.Schemas.PlatformIdentifier) async throws -> SwiftlyWebsiteAPI.Components.Schemas.DevToolchains { fatalError(unmockedMsg + "5") }
-    func getGpgKeys() async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg + "6") }
-    func getSwiftlyRelease(url _: URL) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg + "7") }
-    func getSwiftlyReleaseSignature(url _: URL) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg + "8") }
-    func getSwiftToolchainFile(_: ToolchainFile) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg + "9") }
+    func getCurrentSwiftlyRelease() async throws -> SwiftlyWebsiteAPI.Components.Schemas.SwiftlyRelease { fatalError(unmockedMsg) }
+    func getReleaseToolchains() async throws -> [Components.Schemas.Release] { fatalError(unmockedMsg) }
+    func getSnapshotToolchains(branch _: SwiftlyWebsiteAPI.Components.Schemas.SourceBranch, platform _: SwiftlyWebsiteAPI.Components.Schemas.PlatformIdentifier) async throws -> SwiftlyWebsiteAPI.Components.Schemas.DevToolchains { fatalError(unmockedMsg) }
+    func getGpgKeys() async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg) }
+    func getSwiftlyRelease(url _: URL) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg) }
+    func getSwiftlyReleaseSignature(url _: URL) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg) }
+    func getSwiftToolchainFile(_: ToolchainFile) async throws -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg) }
     func getSwiftToolchainFileSignature(_: ToolchainFile) async throws
-        -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg + "10") }
+        -> OpenAPIRuntime.HTTPBody { fatalError(unmockedMsg) }
 }
 
 // Convenience extensions to common Swiftly and SwiftlyCore types to set the correct context

Tests/SwiftlyTests/UninstallTests.swift

@@ -281,7 +281,7 @@ import Testing
         )
     }
 
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [])) func uninstallXcode() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: [])) func uninstallXcode() async throws {
         let output = try await SwiftlyTests.runWithMockedIO(Uninstall.self, ["uninstall", "-y", ToolchainVersion.xcodeVersion.name])
         #expect(!output.filter { $0.contains("No toolchains can be uninstalled that match \"xcode\"") }.isEmpty)
     }

Tests/SwiftlyTests/UseTests.swift

@@ -193,9 +193,9 @@ import Testing
 
 #if os(macOS)
     /// Tests that the xcode toolchain can be used on macOS
-    /*@Test(.mockHomeToolchains()) func useXcode() async throws {
-        try await self.useAndValidate(argument: ToolchainVersion.xcodeVersion.name, expectedVersion: .xcode)
-    }*/
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains()) func useXcode() async throws {
+         try await self.useAndValidate(argument: ToolchainVersion.xcodeVersion.name, expectedVersion: .xcode)
+     }
 #endif
 
     /// Tests that the `use` command gracefully exits when executed before any toolchains have been installed.