swift-package-migrate: Add tests for feature resolution errors

This change also extracts feature resolution into a method and removes
a superfluous colon from the 'unsupported feature' error message.

Author: AnthonyLatsis

Sources/Commands/PackageCommands/Migrate.swift

@@ -64,31 +64,8 @@ extension SwiftPackageCommand {
         var options: MigrateOptions
 
         public func run(_ swiftCommandState: SwiftCommandState) async throws {
-            let toolchain = try swiftCommandState.productsBuildParameters.toolchain
-
-            let supportedFeatures = try Dictionary(
-                uniqueKeysWithValues: toolchain.swiftCompilerSupportedFeatures
-                    .map { ($0.name, $0) }
-            )
-
-            // First, let's validate that all of the features are supported
-            // by the compiler and are migratable.
-
-            var features: [SwiftCompilerFeature] = []
-            for name in self.options.features {
-                guard let feature = supportedFeatures[name] else {
-                    let migratableFeatures = supportedFeatures.map(\.value).filter(\.migratable).map(\.name)
-                    throw ValidationError(
-                        "Unsupported feature: \(name). Available features: \(migratableFeatures.joined(separator: ", "))"
-                    )
-                }
-
-                guard feature.migratable else {
-                    throw ValidationError("Feature '\(name)' is not migratable")
-                }
-
-                features.append(feature)
-            }
+            // First, validate and resolve the requested feature names.
+            let features = try self.resolveRequestedFeatures(swiftCommandState)
 
             let buildSystem = try await createBuildSystem(
                 swiftCommandState,
@@ -188,6 +165,44 @@ extension SwiftPackageCommand {
             }
         }
 
+        /// Resolves the requested feature names.
+        private func resolveRequestedFeatures(
+            _ swiftCommandState: SwiftCommandState
+        ) throws -> [SwiftCompilerFeature] {
+            let toolchain = try swiftCommandState.productsBuildParameters.toolchain
+
+            // Query the compiler for supported features.
+            let supportedFeatures = try toolchain.swiftCompilerSupportedFeatures
+
+            var resolvedFeatures: [SwiftCompilerFeature] = []
+
+            // Resolve the requested feature names, validating that they are
+            // supported by the compiler and migratable.
+            for name in self.options.features {
+                let feature = supportedFeatures.first { $0.name == name }
+
+                guard let feature else {
+                    let migratableCommaSeparatedFeatures = supportedFeatures
+                        .filter(\.migratable)
+                        .map(\.name)
+                        .sorted()
+                        .joined(separator: ", ")
+
+                    throw ValidationError(
+                        "Unsupported feature '\(name)'. Available features: \(migratableCommaSeparatedFeatures)"
+                    )
+                }
+
+                guard feature.migratable else {
+                    throw ValidationError("Feature '\(name)' is not migratable")
+                }
+
+                resolvedFeatures.append(feature)
+            }
+
+            return resolvedFeatures
+        }
+
         private func createBuildSystem(
             _ swiftCommandState: SwiftCommandState,
             targets: OrderedSet<String>,

Tests/CommandsTests/PackageCommandTests.swift

@@ -2117,6 +2117,49 @@ class PackageCommandTestCase: CommandsBuildProviderTestCase {
         XCTAssertNoMatch(stdout, .contains("--package-path"))
     }
 
+    func testMigrateCommandNoFeatures() async throws {
+        try await XCTAssertThrowsCommandExecutionError(
+            await self.execute(["migrate"])
+        ) { error in
+            XCTAssertMatch(
+                error.stderr,
+                .contains("error: Missing expected argument '--to-feature <to-feature>'")
+            )
+        }
+    }
+
+    func testMigrateCommandUnknownFeature() async throws {
+        try XCTSkipIf(
+            !UserToolchain.default.supportesSupportedFeatures,
+            "skipping because test environment compiler doesn't support `-print-supported-features`"
+        )
+
+        try await XCTAssertThrowsCommandExecutionError(
+            await self.execute(["migrate", "--to-feature", "X"])
+        ) { error in
+            XCTAssertMatch(
+                error.stderr,
+                .contains("error: Unsupported feature 'X'. Available features:")
+            )
+        }
+    }
+
+    func testMigrateCommandNonMigratableFeature() async throws {
+        try XCTSkipIf(
+            !UserToolchain.default.supportesSupportedFeatures,
+            "skipping because test environment compiler doesn't support `-print-supported-features`"
+        )
+
+        try await XCTAssertThrowsCommandExecutionError(
+            await self.execute(["migrate", "--to-feature", "StrictConcurrency"])
+        ) { error in
+            XCTAssertMatch(
+                error.stderr,
+                .contains("error: Feature 'StrictConcurrency' is not migratable")
+            )
+        }
+    }
+
     func testMigrateCommand() async throws {
         try XCTSkipIf(
             !UserToolchain.default.supportesSupportedFeatures,