Launch display regression app directly in UI test

Author: austinywang

cmuxUITests/DisplayResolutionRegressionUITests.swift

@@ -1,5 +1,6 @@
 import XCTest
 import Foundation
+import Darwin
 
 final class DisplayResolutionRegressionUITests: XCTestCase {
     private let defaultDisplayHarnessManifestPath = "/tmp/cmux-ui-test-display-harness.json"
@@ -11,7 +12,8 @@ final class DisplayResolutionRegressionUITests: XCTestCase {
     private var displayDonePath = ""
     private var helperBinaryPath = ""
     private var helperLogPath = ""
-    private var launchedApp: XCUIApplication?
+    private var appLogPath = ""
+    private var launchedAppProcess: Process?
     private var helperProcess: Process?
 
     override func setUp() {
@@ -30,15 +32,14 @@ final class DisplayResolutionRegressionUITests: XCTestCase {
         displayDonePath = "\(tempPrefix).done"
         helperBinaryPath = "\(tempPrefix)-helper"
         helperLogPath = "\(tempPrefix)-helper.log"
+        appLogPath = "\(tempPrefix)-app.log"
 
         removeTestArtifacts()
     }
 
     override func tearDown() {
         terminateLaunchedAppIfNeeded()
-        helperProcess?.terminate()
-        helperProcess?.waitUntilExit()
-        helperProcess = nil
+        terminateHelperProcessIfNeeded()
         removeTestArtifacts()
         super.tearDown()
     }
@@ -240,17 +241,93 @@ final class DisplayResolutionRegressionUITests: XCTestCase {
     }
 
     private func launchAppProcess(targetDisplayID: String) throws {
-        let app = XCUIApplication()
+        let proc = Process()
+        proc.executableURL = URL(fileURLWithPath: try resolveAppExecutablePath())
+
+        var environment = ProcessInfo.processInfo.environment
         for (key, value) in launchEnvironment(targetDisplayID: targetDisplayID) {
-            app.launchEnvironment[key] = value
+            environment[key] = value
         }
-        app.launch()
-        guard ensureForegroundAfterLaunch(app, timeout: 12.0) else {
-            throw NSError(domain: "DisplayResolutionRegressionUITests", code: 2, userInfo: [
-                NSLocalizedDescriptionKey: "XCUIApplication failed to reach foreground. state=\(app.state.rawValue)"
-            ])
+        proc.environment = environment
+
+        let logHandle = FileHandle(forWritingAtPath: appLogPath) ?? {
+            FileManager.default.createFile(atPath: appLogPath, contents: nil)
+            return FileHandle(forWritingAtPath: appLogPath)
+        }()
+        proc.standardOutput = logHandle
+        proc.standardError = logHandle
+
+        try proc.run()
+        launchedAppProcess = proc
+    }
+
+    private func resolveAppExecutablePath() throws -> String {
+        let env = ProcessInfo.processInfo.environment
+        let fileManager = FileManager.default
+        var candidateProductsDirectories: [String] = []
+
+        if let builtProductsDir = env["BUILT_PRODUCTS_DIR"], !builtProductsDir.isEmpty {
+            candidateProductsDirectories.append(builtProductsDir)
+        }
+
+        if let testHost = env["TEST_HOST"], !testHost.isEmpty {
+            let hostURL = URL(fileURLWithPath: testHost)
+            candidateProductsDirectories.append(
+                hostURL
+                    .deletingLastPathComponent()
+                    .deletingLastPathComponent()
+                    .deletingLastPathComponent()
+                    .deletingLastPathComponent()
+                    .path
+            )
         }
-        launchedApp = app
+
+        candidateProductsDirectories.append(contentsOf: inferredBuildProductsDirectories())
+
+        for productsDir in uniquePaths(candidateProductsDirectories) {
+            let appExecutablePath = URL(fileURLWithPath: productsDir)
+                .appendingPathComponent("cmux DEV.app")
+                .appendingPathComponent("Contents/MacOS/cmux DEV")
+                .path
+            if fileManager.isExecutableFile(atPath: appExecutablePath) {
+                return appExecutablePath
+            }
+        }
+
+        throw NSError(domain: "DisplayResolutionRegressionUITests", code: 4, userInfo: [
+            NSLocalizedDescriptionKey: "Unable to resolve cmux DEV executable from UI test environment"
+        ])
+    }
+
+    private func inferredBuildProductsDirectories() -> [String] {
+        let bundleURLs = [
+            Bundle.main.bundleURL,
+            Bundle(for: Self.self).bundleURL,
+        ]
+
+        return bundleURLs.compactMap { bundleURL in
+            let standardizedPath = bundleURL.standardizedFileURL.path
+            let components = standardizedPath.split(separator: "/")
+            guard let productsIndex = components.firstIndex(of: "Products"),
+                  productsIndex + 1 < components.count else {
+                return nil
+            }
+            return "/" + components.prefix(productsIndex + 2).joined(separator: "/")
+        }
+    }
+
+    private func uniquePaths(_ paths: [String]) -> [String] {
+        var seen = Set<String>()
+        var ordered: [String] = []
+        for rawPath in paths {
+            let trimmed = rawPath.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !trimmed.isEmpty else { continue }
+            let path = URL(fileURLWithPath: trimmed).resolvingSymlinksInPath().path
+            if seen.insert(path).inserted {
+                ordered.append(path)
+            }
+        }
+        return ordered
     }
 
     private func launchEnvironment(targetDisplayID: String) -> [String: String] {
@@ -264,31 +341,44 @@ final class DisplayResolutionRegressionUITests: XCTestCase {
     }
 
     private func terminateLaunchedAppIfNeeded() {
-        guard let launchedApp else { return }
-        defer { self.launchedApp = nil }
+        terminateProcessIfNeeded(&launchedAppProcess, timeout: 5.0)
+    }
 
-        if launchedApp.state == .notRunning {
-            return
+    private func terminateHelperProcessIfNeeded() {
+        terminateProcessIfNeeded(&helperProcess, timeout: 2.0)
+    }
+
+    private func terminateProcessIfNeeded(_ processRef: inout Process?, timeout: TimeInterval) {
+        guard let process = processRef else { return }
+        defer { processRef = nil }
+
+        guard process.isRunning else { return }
+
+        process.terminate()
+        waitForProcessExit(process, timeout: timeout)
+
+        if process.isRunning {
+            process.interrupt()
+            waitForProcessExit(process, timeout: 1.0)
         }
 
-        launchedApp.terminate()
-        _ = launchedApp.wait(for: .notRunning, timeout: 5.0)
+        if process.isRunning {
+            _ = kill(process.processIdentifier, SIGKILL)
+            waitForProcessExit(process, timeout: 1.0)
+        }
     }
 
-    private func launchedAppDiagnostics() -> String {
-        guard let launchedApp else { return "not-launched" }
-        return "state=\(launchedApp.state.rawValue)"
+    private func waitForProcessExit(_ process: Process, timeout: TimeInterval) {
+        let deadline = Date().addingTimeInterval(timeout)
+        while process.isRunning && Date() < deadline {
+            RunLoop.current.run(until: Date().addingTimeInterval(0.1))
+        }
     }
 
-    private func ensureForegroundAfterLaunch(_ app: XCUIApplication, timeout: TimeInterval) -> Bool {
-        if app.wait(for: .runningForeground, timeout: timeout) {
-            return true
-        }
-        if app.state == .runningBackground {
-            app.activate()
-            return app.wait(for: .runningForeground, timeout: 6.0)
-        }
-        return false
+    private func launchedAppDiagnostics() -> String {
+        guard let launchedAppProcess else { return "not-launched" }
+        let log = readTrimmedFile(atPath: appLogPath) ?? "<missing>"
+        return "pid=\(launchedAppProcess.processIdentifier) running=\(launchedAppProcess.isRunning) status=\(launchedAppProcess.terminationStatus) log=\(log)"
     }
 
     private func waitForTargetDisplayMove(targetDisplayID: String, timeout: TimeInterval) -> Bool {
@@ -364,6 +454,7 @@ final class DisplayResolutionRegressionUITests: XCTestCase {
             displayDonePath,
             helperBinaryPath,
             helperLogPath,
+            appLogPath,
         ] {
             guard !path.isEmpty else { continue }
             try? FileManager.default.removeItem(atPath: path)