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

Author: cmcgee1024

Tests/SwiftlyTests/InstallTests.swift

@@ -226,10 +226,10 @@ 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 {
-        try await SwiftlyTests.installMockedToolchain(toolchain: SwiftlyTests.oldStable)
-        try await SwiftlyTests.runCommand(Use.self, ["use", SwiftlyTests.oldStable.name])
-        try await SwiftlyTests.validateInUse(expected: SwiftlyTests.oldStable)
-        try await SwiftlyTests.installMockedToolchain(selector: SwiftlyTests.newStable.name, args: ["--use"])
-        try await SwiftlyTests.validateInUse(expected: SwiftlyTests.newStable)
+        try await SwiftlyTests.installMockedToolchain(toolchain: .oldStable)
+        try await SwiftlyTests.runCommand(Use.self, ["use", ToolchainVersion.oldStable.name])
+        try await SwiftlyTests.validateInUse(expected: .oldStable)
+        try await SwiftlyTests.installMockedToolchain(selector: ToolchainVersion.newStable.name, args: ["--use"])
+        try await SwiftlyTests.validateInUse(expected: .newStable)
     }
 }

Tests/SwiftlyTests/ListTests.swift

@@ -7,23 +7,23 @@ import Testing
     static let homeName = "useTests"
 
     static let sortedReleaseToolchains: [ToolchainVersion] = [
-        SwiftlyTests.newStable,
-        SwiftlyTests.oldStableNewPatch,
-        SwiftlyTests.oldStable,
+        .newStable,
+        .oldStableNewPatch,
+        .oldStable,
     ]
 
     static let sortedSnapshotToolchains: [ToolchainVersion] = [
-        SwiftlyTests.newMainSnapshot,
-        SwiftlyTests.oldMainSnapshot,
-        SwiftlyTests.newReleaseSnapshot,
-        SwiftlyTests.oldReleaseSnapshot,
+        .newMainSnapshot,
+        .oldMainSnapshot,
+        .newReleaseSnapshot,
+        .oldReleaseSnapshot,
     ]
 
     /// Constructs a mock home directory with the toolchains listed above installed and runs the provided closure within
     /// the context of that home.
     func runListTest(f: () async throws -> Void) async throws {
         try await SwiftlyTests.withTestHome(name: Self.homeName) {
-            for toolchain in SwiftlyTests.allToolchains {
+            for toolchain in Set<ToolchainVersion>.allToolchains() {
                 try await SwiftlyTests.installMockedToolchain(toolchain: toolchain)
             }
 
@@ -44,7 +44,7 @@ import Testing
         let output = try await SwiftlyTests.runWithMockedIO(List.self, args)
 
         let parsedToolchains = output.compactMap { outputLine in
-            SwiftlyTests.allToolchains.first {
+            Set<ToolchainVersion>.allToolchains().first {
                 outputLine.contains(String(describing: $0))
             }
         }
@@ -73,13 +73,13 @@ import Testing
             var toolchains = try await self.runList(selector: "5")
             #expect(toolchains == Self.sortedReleaseToolchains)
 
-            var selector = "\(SwiftlyTests.newStable.asStableRelease!.major).\(SwiftlyTests.newStable.asStableRelease!.minor)"
+            var selector = "\(ToolchainVersion.newStable.asStableRelease!.major).\(ToolchainVersion.newStable.asStableRelease!.minor)"
             toolchains = try await self.runList(selector: selector)
-            #expect(toolchains == [SwiftlyTests.newStable])
+            #expect(toolchains == [ToolchainVersion.newStable])
 
-            selector = "\(SwiftlyTests.oldStable.asStableRelease!.major).\(SwiftlyTests.oldStable.asStableRelease!.minor)"
+            selector = "\(ToolchainVersion.oldStable.asStableRelease!.major).\(ToolchainVersion.oldStable.asStableRelease!.minor)"
             toolchains = try await self.runList(selector: selector)
-            #expect(toolchains == [SwiftlyTests.oldStableNewPatch, SwiftlyTests.oldStable])
+            #expect(toolchains == [ToolchainVersion.oldStableNewPatch, ToolchainVersion.oldStable])
 
             for toolchain in Self.sortedReleaseToolchains {
                 toolchains = try await self.runList(selector: toolchain.name)
@@ -96,11 +96,11 @@ import Testing
     @Test func listSnapshotToolchains() async throws {
         try await self.runListTest {
             var toolchains = try await self.runList(selector: "main-snapshot")
-            #expect(toolchains == [SwiftlyTests.newMainSnapshot, SwiftlyTests.oldMainSnapshot])
+            #expect(toolchains == [ToolchainVersion.newMainSnapshot, ToolchainVersion.oldMainSnapshot])
 
-            let snapshotBranch = SwiftlyTests.newReleaseSnapshot.asSnapshot!.branch
+            let snapshotBranch = ToolchainVersion.newReleaseSnapshot.asSnapshot!.branch
             toolchains = try await self.runList(selector: "\(snapshotBranch.major!).\(snapshotBranch.minor!)-snapshot")
-            #expect(toolchains == [SwiftlyTests.newReleaseSnapshot, SwiftlyTests.oldReleaseSnapshot])
+            #expect(toolchains == [ToolchainVersion.newReleaseSnapshot, ToolchainVersion.oldReleaseSnapshot])
 
             for toolchain in Self.sortedSnapshotToolchains {
                 toolchains = try await self.runList(selector: toolchain.name)
@@ -129,22 +129,22 @@ import Testing
         }
 
         try await self.runListTest {
-            for toolchain in SwiftlyTests.allToolchains {
+            for toolchain in Set<ToolchainVersion>.allToolchains() {
                 try await inUseTest(toolchain: toolchain, selector: nil)
                 try await inUseTest(toolchain: toolchain, selector: toolchain.name)
             }
 
-            let major = SwiftlyTests.oldStable.asStableRelease!.major
+            let major = ToolchainVersion.oldStable.asStableRelease!.major
             for toolchain in Self.sortedReleaseToolchains.filter({ $0.asStableRelease?.major == major }) {
                 try await inUseTest(toolchain: toolchain, selector: "\(major)")
             }
 
-            for toolchain in SwiftlyTests.allToolchains.filter({ $0.asSnapshot?.branch == .main }) {
+            for toolchain in Set<ToolchainVersion>.allToolchains().filter({ $0.asSnapshot?.branch == .main }) {
                 try await inUseTest(toolchain: toolchain, selector: "main-snapshot")
             }
 
-            let branch = SwiftlyTests.oldReleaseSnapshot.asSnapshot!.branch
-            let releaseSnapshots = SwiftlyTests.allToolchains.filter {
+            let branch = ToolchainVersion.oldReleaseSnapshot.asSnapshot!.branch
+            let releaseSnapshots = Set<ToolchainVersion>.allToolchains().filter {
                 $0.asSnapshot?.branch == branch
             }
             for toolchain in releaseSnapshots {

Tests/SwiftlyTests/RunTests.swift

@@ -10,17 +10,17 @@ import Testing
     @Test(.mockHomeToolchains()) func runSelection() async throws {
         // GIVEN: a set of installed toolchains
         // WHEN: invoking the run command with a selector argument for that toolchain
-        var output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", "swift", "--version", "+\(SwiftlyTests.newStable.name)"])
+        var output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", "swift", "--version", "+\(ToolchainVersion.newStable.name)"])
         // THEN: the output confirms that it ran with the selected toolchain
-        #expect(output.contains(SwiftlyTests.newStable.name))
+        #expect(output.contains(ToolchainVersion.newStable.name))
 
         // GIVEN: a set of installed toolchains and one is selected with a .swift-version file
         let versionFile = SwiftlyTests.ctx.currentDirectory.appendingPathComponent(".swift-version")
-        try SwiftlyTests.oldStable.name.write(to: versionFile, atomically: true, encoding: .utf8)
+        try ToolchainVersion.oldStable.name.write(to: versionFile, atomically: true, encoding: .utf8)
         // WHEN: invoking the run command without any selector arguments for toolchains
         output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", "swift", "--version"])
         // THEN: the output confirms that it ran with the selected toolchain
-        #expect(output.contains(SwiftlyTests.oldStable.name))
+        #expect(output.contains(ToolchainVersion.oldStable.name))
 
         // GIVEN: a set of installed toolchains
         // WHEN: invoking the run command with a selector argument for a toolchain that isn't installed

Tests/SwiftlyTests/SwiftlyTests.swift

@@ -68,6 +68,28 @@ extension SwiftlyCoreContext {
     }
 }
 
+extension ToolchainVersion {
+    public static let oldStable = ToolchainVersion(major: 5, minor: 6, patch: 0)
+    public static let oldStableNewPatch = ToolchainVersion(major: 5, minor: 6, patch: 3)
+    public static let newStable = ToolchainVersion(major: 5, minor: 7, patch: 0)
+    public static let oldMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2025-03-10")
+    public static let newMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2025-03-14")
+    public static let oldReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 6, minor: 0), date: "2025-02-09")
+    public static let newReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 6, minor: 0), date: "2025-02-11")
+}
+
+extension Set where Element == ToolchainVersion {
+    static func allToolchains() -> Set<ToolchainVersion> { [
+        .oldStable,
+        .oldStableNewPatch,
+        .newStable,
+        .oldMainSnapshot,
+        .newMainSnapshot,
+        .oldReleaseSnapshot,
+        .newReleaseSnapshot,
+    ] }
+}
+
 // Convenience test scoping traits
 
 struct TestHomeTrait: TestTrait, TestScoping {
@@ -89,7 +111,7 @@ extension Trait where Self == TestHomeTrait {
 
 struct MockHomeToolchainsTrait: TestTrait, TestScoping {
     var name: String = "testHome"
-    var toolchains: Set<ToolchainVersion> = SwiftlyTests.allToolchains
+    var toolchains: Set<ToolchainVersion> = .allToolchains()
 
     init(_ name: String, toolchains: Set<ToolchainVersion>) {
         self.name = name
@@ -105,7 +127,7 @@ struct MockHomeToolchainsTrait: TestTrait, TestScoping {
 
 extension Trait where Self == MockHomeToolchainsTrait {
     /// Run the test with this trait to get a mocked home directory with a predefined collection of toolchains already installed.
-    static func mockHomeToolchains(_ homeName: String = "testHome", toolchains: Set<ToolchainVersion> = SwiftlyTests.allToolchains) -> Self { Self(homeName, toolchains: toolchains) }
+    static func mockHomeToolchains(_ homeName: String = "testHome", toolchains: Set<ToolchainVersion> = .allToolchains()) -> Self { Self(homeName, toolchains: toolchains) }
 }
 
 struct TestHomeMockedToolchainTrait: TestTrait, TestScoping {
@@ -136,25 +158,6 @@ public enum SwiftlyTests {
         inputProvider: InputProviderFail()
     )
 
-    // Below are some constants that can be used to write test cases.
-    public static let oldStable = ToolchainVersion(major: 5, minor: 6, patch: 0)
-    public static let oldStableNewPatch = ToolchainVersion(major: 5, minor: 6, patch: 3)
-    public static let newStable = ToolchainVersion(major: 5, minor: 7, patch: 0)
-    public static let oldMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2025-03-10")
-    public static let newMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2025-03-14")
-    public static let oldReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 6, minor: 0), date: "2025-02-09")
-    public static let newReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 6, minor: 0), date: "2025-02-11")
-
-    static let allToolchains: Set<ToolchainVersion> = [
-        oldStable,
-        oldStableNewPatch,
-        newStable,
-        oldMainSnapshot,
-        newMainSnapshot,
-        oldReleaseSnapshot,
-        newReleaseSnapshot,
-    ]
-
     static func baseTestConfig() async throws -> Config {
         guard let pd = try? await Swiftly.currentPlatform.detectPlatform(Self.ctx, disableConfirmation: true, platform: nil) else {
             throw SwiftlyTestError(message: "Unable to detect the current platform.")
@@ -515,9 +518,9 @@ public class MockToolchainDownloader: HTTPRequestExecutor {
         executables: [String]? = nil,
         latestSwiftlyVersion: SwiftlyVersion = SwiftlyCore.version,
         releaseToolchains: [ToolchainVersion.StableRelease] = [
-            SwiftlyTests.oldStable.asStableRelease!,
-            SwiftlyTests.newStable.asStableRelease!,
-            SwiftlyTests.oldStableNewPatch.asStableRelease!,
+            ToolchainVersion.oldStable.asStableRelease!,
+            ToolchainVersion.newStable.asStableRelease!,
+            ToolchainVersion.oldStableNewPatch.asStableRelease!,
             ToolchainVersion.StableRelease(major: 5, minor: 7, patch: 4), // Some tests look for a patch in the 5.7.x series larger than 5.0.3
             ToolchainVersion.StableRelease(major: 5, minor: 9, patch: 0), // Some tests try to update from 5.9.0
             ToolchainVersion.StableRelease(major: 5, minor: 9, patch: 1),
@@ -526,10 +529,10 @@ public class MockToolchainDownloader: HTTPRequestExecutor {
             ToolchainVersion.StableRelease(major: 6, minor: 0, patch: 2), // Some tests try to update from 6.0.1
         ],
         snapshotToolchains: [ToolchainVersion.Snapshot] = [
-            SwiftlyTests.oldMainSnapshot.asSnapshot!,
-            SwiftlyTests.newMainSnapshot.asSnapshot!,
-            SwiftlyTests.oldReleaseSnapshot.asSnapshot!,
-            SwiftlyTests.newReleaseSnapshot.asSnapshot!,
+            ToolchainVersion.oldMainSnapshot.asSnapshot!,
+            ToolchainVersion.newMainSnapshot.asSnapshot!,
+            ToolchainVersion.oldReleaseSnapshot.asSnapshot!,
+            ToolchainVersion.newReleaseSnapshot.asSnapshot!,
         ]
     ) {
         self.executables = executables ?? ["swift"]