Make test scoping traits more versatile and fewer by adding functions to Trait instead of var

Author: cmcgee1024

Tests/SwiftlyTests/InitTests.swift

@@ -4,7 +4,7 @@ import Foundation
 import Testing
 
 @Suite struct InitTests {
-    @Test(.testHome) func initFresh() async throws {
+    @Test(.testHome()) func initFresh() async throws {
         // GIVEN: a fresh user account without Swiftly installed
         try? FileManager.default.removeItem(at: Swiftly.currentPlatform.swiftlyConfigFile(SwiftlyTests.ctx))
 
@@ -62,7 +62,7 @@ import Testing
         }
     }
 
-    @Test(.testHome) func initOverwrite() async throws {
+    @Test(.testHome()) func initOverwrite() async throws {
         // GIVEN: a user account with swiftly already installed
         try? FileManager.default.removeItem(at: Swiftly.currentPlatform.swiftlyConfigFile(SwiftlyTests.ctx))
 
@@ -86,7 +86,7 @@ import Testing
         #expect(!Swiftly.currentPlatform.swiftlyToolchainsDir(SwiftlyTests.ctx).appendingPathComponent("foo.txt").fileExists())
     }
 
-    @Test(.testHome) func initTwice() async throws {
+    @Test(.testHome()) func initTwice() async throws {
         // GIVEN: a user account with swiftly already installed
         try? FileManager.default.removeItem(at: Swiftly.currentPlatform.swiftlyConfigFile(SwiftlyTests.ctx))
 

Tests/SwiftlyTests/InstallTests.swift

@@ -9,7 +9,7 @@ import Testing
     /// It stops short of verifying that it actually installs the _most_ recently released version, which is the intended
     /// behavior, since determining which version is the latest is non-trivial and would require duplicating code
     /// from within swiftly itself.
-    @Test(.testHomeMockedToolchain) func installLatest() async throws {
+    @Test(.testHomeMockedToolchain()) func installLatest() async throws {
         try await SwiftlyTests.runCommand(Install.self, ["install", "latest", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
 
         let config = try Config.load()
@@ -33,7 +33,7 @@ import Testing
     }
 
     /// Tests that `swiftly install a.b` installs the latest patch version of Swift a.b.
-    @Test(.testHomeMockedToolchain) func installLatestPatchVersion() async throws {
+    @Test(.testHomeMockedToolchain()) func installLatestPatchVersion() async throws {
         try await SwiftlyTests.runCommand(Install.self, ["install", "5.7", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
 
         let config = try Config.load()
@@ -57,7 +57,7 @@ import Testing
     }
 
     /// Tests that swiftly can install different stable release versions by their full a.b.c versions.
-    @Test(.testHomeMockedToolchain) func installReleases() async throws {
+    @Test(.testHomeMockedToolchain()) func installReleases() async throws {
         var installedToolchains: Set<ToolchainVersion> = []
 
         try await SwiftlyTests.runCommand(Install.self, ["install", "5.7.0", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
@@ -78,7 +78,7 @@ import Testing
     }
 
     /// Tests that swiftly can install main and release snapshots by their full snapshot names.
-    @Test(.testHomeMockedToolchain) func installSnapshots() async throws {
+    @Test(.testHomeMockedToolchain()) func installSnapshots() async throws {
         var installedToolchains: Set<ToolchainVersion> = []
 
         try await SwiftlyTests.runCommand(Install.self, ["install", "main-snapshot-2023-04-01", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
@@ -100,7 +100,7 @@ import Testing
     }
 
     /// Tests that `swiftly install main-snapshot` installs the latest available main snapshot.
-    @Test(.testHomeMockedToolchain) func installLatestMainSnapshot() async throws {
+    @Test(.testHomeMockedToolchain()) func installLatestMainSnapshot() async throws {
         try await SwiftlyTests.runCommand(Install.self, ["install", "main-snapshot", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
 
         let config = try Config.load()
@@ -127,7 +127,7 @@ import Testing
     }
 
     /// Tests that `swiftly install a.b-snapshot` installs the latest available a.b release snapshot.
-    @Test(.testHomeMockedToolchain) func installLatestReleaseSnapshot() async throws {
+    @Test(.testHomeMockedToolchain()) func installLatestReleaseSnapshot() async throws {
         try await SwiftlyTests.runCommand(Install.self, ["install", "6.0-snapshot", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
 
         let config = try Config.load()
@@ -154,7 +154,7 @@ import Testing
     }
 
     /// Tests that swiftly can install both stable release toolchains and snapshot toolchains.
-    @Test(.testHomeMockedToolchain) func installReleaseAndSnapshots() async throws {
+    @Test(.testHomeMockedToolchain()) func installReleaseAndSnapshots() async throws {
         try await SwiftlyTests.runCommand(Install.self, ["install", "main-snapshot-2023-04-01", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
 
         try await SwiftlyTests.runCommand(Install.self, ["install", "5.9-snapshot-2023-03-28", "--post-install-file=\(Swiftly.currentPlatform.getTempFilePath().path)"])
@@ -209,7 +209,7 @@ import Testing
     }
 
     /// Verify that the installed toolchain will be used if no toolchains currently are installed.
-    @Test(.testHomeMockedToolchain) func installUsesFirstToolchain() async throws {
+    @Test(.testHomeMockedToolchain()) func installUsesFirstToolchain() async throws {
         let config = try Config.load()
         #expect(config.inUse == nil)
         try await SwiftlyTests.validateInUse(expected: nil)
@@ -225,7 +225,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(.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)

Tests/SwiftlyTests/ListTests.swift

@@ -154,7 +154,7 @@ import Testing
     }
 
     /// Tests that `list` properly handles the case where no toolchains have been installed yet.
-    @Test(.testHome) func listEmpty() async throws {
+    @Test(.testHome(Self.homeName)) func listEmpty() async throws {
         var toolchains = try await self.runList(selector: nil)
         #expect(toolchains == [])
 

Tests/SwiftlyTests/PlatformTests.swift

@@ -17,7 +17,7 @@ import Testing
         return (mockedToolchainFile, version)
     }
 
-    @Test(.testHome) func install() async throws {
+    @Test(.testHome()) func install() async throws {
         // GIVEN: a toolchain has been downloaded
         var (mockedToolchainFile, version) = try await self.mockToolchainDownload(version: "5.7.1")
         // WHEN: the platform installs the toolchain
@@ -43,7 +43,7 @@ import Testing
         #expect(2 == toolchains.count)
     }
 
-    @Test(.testHome) func uninstall() async throws {
+    @Test(.testHome()) func uninstall() async throws {
         // GIVEN: toolchains have been downloaded, and installed
         var (mockedToolchainFile, version) = try await self.mockToolchainDownload(version: "5.8.0")
         try Swiftly.currentPlatform.install(SwiftlyTests.ctx, from: mockedToolchainFile, version: version, verbose: true)

Tests/SwiftlyTests/RunTests.swift

@@ -7,7 +7,7 @@ import Testing
     static let homeName = "runTests"
 
     /// Tests that the `run` command can switch between installed toolchains.
-    @Test(.mockHomeAllToolchains) func runSelection() async throws {
+    @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)"])
@@ -34,7 +34,7 @@ import Testing
     }
 
     /// Tests the `run` command verifying that the environment is as expected
-    @Test(.mockHomeAllToolchains) func runEnvironment() async throws {
+    @Test(.mockHomeToolchains()) func runEnvironment() async throws {
         // The toolchains directory should be the fist entry on the path
         let output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", try await Swiftly.currentPlatform.getShell(), "-c", "echo $PATH"])
         #expect(output.count == 1)

Tests/SwiftlyTests/SwiftlyTests.swift

@@ -71,47 +71,50 @@ extension SwiftlyCoreContext {
 // Convenience test scoping traits
 
 struct TestHomeTrait: TestTrait, TestScoping {
+    var name: String = "testHome"
+
+    init(_ name: String) { self.name = name }
+
     func provideScope(for _: Test, testCase _: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
-        try await SwiftlyTests.withTestHome {
+        try await SwiftlyTests.withTestHome(name: self.name) {
             try await function()
         }
     }
 }
 
 extension Trait where Self == TestHomeTrait {
     /// Run the test with a test home directory.
-    static var testHome: Self { Self() }
+    static func testHome(_ name: String = "testHome") -> Self { Self(name) }
 }
 
-struct MockHomeAllToolchainsTrait: TestTrait, TestScoping {
-    func provideScope(for _: Test, testCase _: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
-        try await SwiftlyTests.withMockedHome(homeName: "testHome", toolchains: SwiftlyTests.allToolchains) {
-            try await function()
-        }
-    }
-}
+struct MockHomeToolchainsTrait: TestTrait, TestScoping {
+    var name: String = "testHome"
+    var toolchains: Set<ToolchainVersion> = SwiftlyTests.allToolchains
 
-extension Trait where Self == MockHomeAllToolchainsTrait {
-    /// Run the test with this trait to get a mocked home directory with a predefined collection of toolchains already installed.
-    static var mockHomeAllToolchains: Self { Self() }
-}
+    init(_ name: String, toolchains: Set<ToolchainVersion>) {
+        self.name = name
+        self.toolchains = toolchains
+    }
 
-struct MockHomeNoToolchainsTrait: TestTrait, TestScoping {
     func provideScope(for _: Test, testCase _: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
-        try await SwiftlyTests.withMockedHome(homeName: UseTests.homeName, toolchains: []) {
+        try await SwiftlyTests.withMockedHome(homeName: self.name, toolchains: self.toolchains) {
             try await function()
         }
     }
 }
 
-extension Trait where Self == MockHomeNoToolchainsTrait {
-    /// Run the test with this trait to get a mocked home directory without any toolchains installed there yet.
-    static var mockHomeNoToolchains: Self { Self() }
+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) }
 }
 
 struct TestHomeMockedToolchainTrait: TestTrait, TestScoping {
+    var name: String = "testHome"
+
+    init(_ name: String) { self.name = name }
+
     func provideScope(for _: Test, testCase _: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
-        try await SwiftlyTests.withTestHome {
+        try await SwiftlyTests.withTestHome(name: self.name) {
             try await SwiftlyTests.withMockedToolchain {
                 try await function()
             }
@@ -122,7 +125,7 @@ struct TestHomeMockedToolchainTrait: TestTrait, TestScoping {
 extension Trait where Self == TestHomeMockedToolchainTrait {
     /// Run the test with this trait to get a test home directory and a mocked
     /// toolchain can be installed by request, at any version.
-    static var testHomeMockedToolchain: Self { Self() }
+    static func testHomeMockedToolchain(_ name: String = "testHome") -> Self { Self(name) }
 }
 
 public enum SwiftlyTests {