test(macos): cover root command dispatch

markoub · markoub · commit cc869d709899 · 2026-06-16T18:29:49.000+02:00
diff --git a/apps/macos/Sources/OpenClawMacCLI/EntryPoint.swift b/apps/macos/Sources/OpenClawMacCLI/EntryPoint.swift
@@ -1,41 +1,68 @@
 import Foundation
 
-private struct RootCommand {
+struct RootCommand: Equatable {
     var name: String
     var args: [String]
 }
 
+enum RootCommandAction: Equatable {
+    case usage
+    case connect([String])
+    case configureRemote([String])
+    case discover([String])
+    case wizard([String])
+    case unknown(exitCode: Int32)
+}
+
 @main
 struct OpenClawMacCLI {
     static func main() async {
         let args = Array(CommandLine.arguments.dropFirst())
-        let command = parseRootCommand(args)
-        switch command?.name {
-        case nil:
+        switch resolveRootCommandAction(args) {
+        case .usage:
             printUsage()
-        case "-h", "--help", "help":
-            printUsage()
-        case "connect":
-            await runConnect(command?.args ?? [])
-        case "configure-remote":
-            runConfigureRemote(command?.args ?? [])
-        case "discover":
-            await runDiscover(command?.args ?? [])
-        case "wizard":
-            await runWizardCommand(command?.args ?? [])
-        default:
+        case .connect(let commandArgs):
+            await runConnect(commandArgs)
+        case .configureRemote(let commandArgs):
+            runConfigureRemote(commandArgs)
+        case .discover(let commandArgs):
+            await runDiscover(commandArgs)
+        case .wizard(let commandArgs):
+            await runWizardCommand(commandArgs)
+        case .unknown(let exitCode):
             fputs("openclaw-mac: unknown command\n", stderr)
             printUsage()
-            exit(1)
+            exit(exitCode)
         }
     }
 }
 
-private func parseRootCommand(_ args: [String]) -> RootCommand? {
+func parseRootCommand(_ args: [String]) -> RootCommand? {
     guard let first = args.first else { return nil }
     return RootCommand(name: first, args: Array(args.dropFirst()))
 }
 
+func resolveRootCommandAction(_ args: [String]) -> RootCommandAction {
+    guard let command = parseRootCommand(args) else {
+        return .usage
+    }
+
+    switch command.name {
+    case "-h", "--help", "help":
+        return .usage
+    case "connect":
+        return .connect(command.args)
+    case "configure-remote":
+        return .configureRemote(command.args)
+    case "discover":
+        return .discover(command.args)
+    case "wizard":
+        return .wizard(command.args)
+    default:
+        return .unknown(exitCode: 1)
+    }
+}
+
 private func printUsage() {
     print("""
     openclaw-mac
diff --git a/apps/macos/Tests/OpenClawIPCTests/RootCommandParserTests.swift b/apps/macos/Tests/OpenClawIPCTests/RootCommandParserTests.swift
@@ -0,0 +1,39 @@
+import Testing
+@testable import OpenClawMacCLI
+
+struct RootCommandParserTests {
+    @Test func `parse root command returns nil for empty args`() {
+        #expect(parseRootCommand([]) == nil)
+    }
+
+    @Test func `parse root command splits command name and args`() throws {
+        let command = try #require(parseRootCommand(["connect", "--json", "--timeout", "3000"]))
+
+        #expect(command.name == "connect")
+        #expect(command.args == ["--json", "--timeout", "3000"])
+    }
+
+    @Test func `help aliases resolve to usage`() {
+        for args in [[], ["-h"], ["--help"], ["help"]] {
+            #expect(resolveRootCommandAction(args) == .usage)
+        }
+    }
+
+    @Test func `known commands preserve trailing args`() {
+        #expect(resolveRootCommandAction(["connect", "--json"]) == .connect(["--json"]))
+        #expect(
+            resolveRootCommandAction(["configure-remote", "--ssh-target", "alice@example.com"])
+                == .configureRemote(["--ssh-target", "alice@example.com"]),
+        )
+        #expect(resolveRootCommandAction(["discover", "--include-local"]) == .discover(["--include-local"]))
+        #expect(resolveRootCommandAction(["wizard", "--mode", "local"]) == .wizard(["--mode", "local"]))
+    }
+
+    @Test func `unknown command resolves to nonzero exit action`() {
+        #expect(resolveRootCommandAction(["nope"]) == .unknown(exitCode: 1))
+    }
+
+    @Test func `command names remain case sensitive`() {
+        #expect(resolveRootCommandAction(["Connect"]) == .unknown(exitCode: 1))
+    }
+}
