Fix UI test browser bootstrap hangs

Author: KSemenenko

.github/workflows/build-validation.yml

@@ -86,7 +86,7 @@ jobs:
 
   ui_tests:
     name: UI Test Suite
-    runs-on: windows-latest
+    runs-on: macos-latest
     timeout-minutes: 60
     needs:
       - build
@@ -100,5 +100,9 @@ jobs:
         uses: "./.github/steps/install_dependencies"
 
       - name: Run UI Tests
-        shell: pwsh
-        run: dotnet test ./DotPilot.UITests/DotPilot.UITests.csproj --logger GitHubActions --blame-crash
+        shell: bash
+        run: |
+          export UNO_UITEST_DRIVER_PATH="${CHROMEWEBDRIVER}"
+          export UNO_UITEST_CHROME_BINARY_PATH="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          export UNO_UITEST_BROWSER_PATH="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          dotnet test ./DotPilot.UITests/DotPilot.UITests.csproj --logger GitHubActions --blame-crash

DotPilot.UITests/BrowserAutomationBootstrap.cs

@@ -25,6 +25,8 @@ internal static partial class BrowserAutomationBootstrap
         "/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing";
     private const string BrowserVersionArgument = "--version";
     private const string BrowserVersionPattern = @"(\d+\.\d+\.\d+\.\d+)";
+    private const string BrowserVersionProbeTimeoutMessage =
+        "Timed out while probing the installed Chrome version for DotPilot UI smoke tests.";
     private const string BrowserBinaryNotFoundMessage =
         "Unable to locate a Chrome browser binary for DotPilot UI smoke tests. " +
         "Set UNO_UITEST_CHROME_BINARY_PATH or UNO_UITEST_BROWSER_PATH explicitly.";
@@ -40,6 +42,7 @@ internal static partial class BrowserAutomationBootstrap
         "ChromeDriver bootstrap completed without producing the expected executable.";
     private const string DriverCacheDirectoryName = "dotpilot-uitest-drivers";
     private const string ChromeDriverBundleNamePrefix = "chromedriver-";
+    private const string DriverVersionCacheFileNameSuffix = ".driver-version";
     private const string LatestPatchVersionsUrl =
         "https://googlechromelabs.github.io/chrome-for-testing/latest-patch-versions-per-build.json";
     private const string ChromeForTestingDownloadBaseUrl =
@@ -53,6 +56,7 @@ internal static partial class BrowserAutomationBootstrap
     {
         Timeout = TimeSpan.FromMinutes(2),
     };
+    private static readonly TimeSpan BrowserVersionProbeTimeout = TimeSpan.FromSeconds(10);
 
     public static BrowserAutomationSettings Resolve()
     {
@@ -122,35 +126,78 @@ private static string ResolveBrowserDriverPath(
     private static string EnsureChromeDriverDownloaded(string browserBinaryPath)
     {
         var browserVersion = ResolveBrowserVersion(browserBinaryPath);
-        var driverVersion = ResolveChromeDriverVersion(browserVersion);
+        var browserBuild = BuildChromeVersionKey(browserVersion);
         var driverPlatform = ResolveChromeDriverPlatform();
-        var cacheRootPath = Path.Combine(Path.GetTempPath(), DriverCacheDirectoryName, driverVersion);
-        var driverDirectory = Path.Combine(cacheRootPath, $"{ChromeDriverBundleNamePrefix}{driverPlatform}");
-        var driverExecutablePath = Path.Combine(driverDirectory, GetChromeDriverExecutableFileName());
+        var cacheRootPath = GetDriverCacheRootPath();
 
         HarnessLog.Write($"Browser version '{browserVersion}' resolved for '{browserBinaryPath}'.");
+
+        var cachedDriverDirectory = ResolveCachedChromeDriverDirectory(cacheRootPath, browserBuild, driverPlatform);
+        if (!string.IsNullOrWhiteSpace(cachedDriverDirectory))
+        {
+            var cachedDriverExecutablePath = Path.Combine(cachedDriverDirectory, GetChromeDriverExecutableFileName());
+            EnsureDriverExecutablePermissions(cachedDriverExecutablePath);
+            HarnessLog.Write($"Reusing cached ChromeDriver at '{cachedDriverExecutablePath}'.");
+            return cachedDriverDirectory;
+        }
+
+        var driverVersion = ResolveChromeDriverVersion(browserBuild);
+        var driverVersionRootPath = Path.Combine(cacheRootPath, driverVersion);
+        var driverDirectory = Path.Combine(driverVersionRootPath, $"{ChromeDriverBundleNamePrefix}{driverPlatform}");
+        var driverExecutablePath = Path.Combine(driverDirectory, GetChromeDriverExecutableFileName());
         HarnessLog.Write($"Matching ChromeDriver version '{driverVersion}' on platform '{driverPlatform}'.");
 
         if (File.Exists(driverExecutablePath))
         {
             EnsureDriverExecutablePermissions(driverExecutablePath);
+            PersistDriverVersionMapping(cacheRootPath, browserBuild, driverPlatform, driverVersion);
             HarnessLog.Write($"Reusing cached ChromeDriver at '{driverExecutablePath}'.");
             return driverDirectory;
         }
 
-        Directory.CreateDirectory(cacheRootPath);
-        HarnessLog.Write($"Downloading ChromeDriver to '{cacheRootPath}'.");
-        DownloadChromeDriverArchive(driverVersion, driverPlatform, cacheRootPath);
+        Directory.CreateDirectory(driverVersionRootPath);
+        HarnessLog.Write($"Downloading ChromeDriver to '{driverVersionRootPath}'.");
+        DownloadChromeDriverArchive(driverVersion, driverPlatform, driverVersionRootPath);
         EnsureDriverExecutablePermissions(driverExecutablePath);
 
         if (!File.Exists(driverExecutablePath))
         {
             throw new InvalidOperationException($"{DriverExecutableNotFoundMessage} Expected path: {driverExecutablePath}");
         }
 
+        PersistDriverVersionMapping(cacheRootPath, browserBuild, driverPlatform, driverVersion);
         return driverDirectory;
     }
 
+    internal static string? ResolveCachedChromeDriverDirectory(string cacheRootPath, string browserBuild, string driverPlatform)
+    {
+        var driverVersionMappingPath = GetDriverVersionMappingPath(cacheRootPath, browserBuild, driverPlatform);
+        if (!File.Exists(driverVersionMappingPath))
+        {
+            return null;
+        }
+
+        var driverVersion = File.ReadAllText(driverVersionMappingPath).Trim();
+        if (string.IsNullOrWhiteSpace(driverVersion))
+        {
+            return null;
+        }
+
+        var driverDirectory = Path.Combine(cacheRootPath, driverVersion, $"{ChromeDriverBundleNamePrefix}{driverPlatform}");
+        var driverExecutablePath = Path.Combine(driverDirectory, GetChromeDriverExecutableFileName());
+        return File.Exists(driverExecutablePath) ? driverDirectory : null;
+    }
+
+    internal static void PersistDriverVersionMapping(
+        string cacheRootPath,
+        string browserBuild,
+        string driverPlatform,
+        string driverVersion)
+    {
+        Directory.CreateDirectory(cacheRootPath);
+        File.WriteAllText(GetDriverVersionMappingPath(cacheRootPath, browserBuild, driverPlatform), driverVersion);
+    }
+
     private static void DownloadChromeDriverArchive(string driverVersion, string driverPlatform, string cacheRootPath)
     {
         var archiveName = $"{ChromeDriverBundleNamePrefix}{driverPlatform}.zip";
@@ -194,11 +241,10 @@ private static string ResolveBrowserVersion(string browserBinaryPath)
             CreateNoWindow = true,
         };
 
-        using var process = Process.Start(processStartInfo)
-            ?? throw new InvalidOperationException(BrowserVersionNotFoundMessage);
-
-        var output = $"{process.StandardOutput.ReadToEnd()}{Environment.NewLine}{process.StandardError.ReadToEnd()}";
-        process.WaitForExit();
+        var output = RunProcessAndCaptureOutput(
+            processStartInfo,
+            BrowserVersionProbeTimeout,
+            BrowserVersionProbeTimeoutMessage);
 
         var match = BrowserVersionRegex().Match(output);
         if (!match.Success)
@@ -209,9 +255,8 @@ private static string ResolveBrowserVersion(string browserBinaryPath)
         return match.Groups[1].Value;
     }
 
-    private static string ResolveChromeDriverVersion(string browserVersion)
+    private static string ResolveChromeDriverVersion(string browserBuild)
     {
-        var browserBuild = BuildChromeVersionKey(browserVersion);
         var response = GetResponseBytes(LatestPatchVersionsUrl, DriverVersionNotFoundMessage);
         using var document = JsonDocument.Parse(response);
 
@@ -237,6 +282,34 @@ private static string BuildChromeVersionKey(string browserVersion)
         return string.Join('.', segments.Take(3));
     }
 
+    internal static string RunProcessAndCaptureOutput(
+        ProcessStartInfo startInfo,
+        TimeSpan timeout,
+        string timeoutMessage)
+    {
+        using var process = Process.Start(startInfo)
+            ?? throw new InvalidOperationException(timeoutMessage);
+        var standardOutputTask = process.StandardOutput.ReadToEndAsync();
+        var standardErrorTask = process.StandardError.ReadToEndAsync();
+
+        if (!process.WaitForExit((int)timeout.TotalMilliseconds))
+        {
+            try
+            {
+                process.Kill(entireProcessTree: true);
+            }
+            catch
+            {
+                // Best-effort cleanup only.
+            }
+
+            throw new TimeoutException(timeoutMessage);
+        }
+
+        process.WaitForExit();
+        return $"{standardOutputTask.GetAwaiter().GetResult()}{Environment.NewLine}{standardErrorTask.GetAwaiter().GetResult()}";
+    }
+
     private static string ResolveChromeDriverPlatform()
     {
         if (OperatingSystem.IsMacOS())
@@ -393,6 +466,16 @@ private static string GetChromeDriverExecutableFileName()
             : ChromeDriverExecutableName;
     }
 
+    private static string GetDriverCacheRootPath()
+    {
+        return Path.Combine(Path.GetTempPath(), DriverCacheDirectoryName);
+    }
+
+    private static string GetDriverVersionMappingPath(string cacheRootPath, string browserBuild, string driverPlatform)
+    {
+        return Path.Combine(cacheRootPath, $"{browserBuild}-{driverPlatform}{DriverVersionCacheFileNameSuffix}");
+    }
+
     private static IEnumerable<string> GetBrowserBinaryEnvironmentVariableNames()
     {
         yield return BrowserBinaryEnvironmentVariableName;

DotPilot.UITests/BrowserAutomationBootstrapTests.cs

@@ -1,3 +1,6 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
 namespace DotPilot.UITests;
 
 [TestFixture]
@@ -66,13 +69,68 @@ public void WhenBrowserBinaryEnvironmentVariableIsMissingThenResolverFallsBackTo
         Assert.That(settings.BrowserBinaryPath, Is.EqualTo(browserBinaryPath));
     }
 
+    [Test]
+    public void WhenCachedDriverVersionMappingExistsThenResolverUsesCachedDriverDirectory()
+    {
+        using var sandbox = new BrowserAutomationSandbox();
+        var browserBuild = "145.0.7632";
+        var driverPlatform = GetExpectedDriverPlatform();
+        var driverVersion = "145.0.7632.117";
+        var cacheRootPath = sandbox.CreateDirectory("driver-cache");
+        var driverDirectory = Path.Combine(cacheRootPath, driverVersion, $"chromedriver-{driverPlatform}");
+        Directory.CreateDirectory(driverDirectory);
+        sandbox.CreateFile(Path.Combine(driverDirectory, GetChromeDriverExecutableFileName()));
+        BrowserAutomationBootstrap.PersistDriverVersionMapping(cacheRootPath, browserBuild, driverPlatform, driverVersion);
+
+        var resolvedDirectory = BrowserAutomationBootstrap.ResolveCachedChromeDriverDirectory(
+            cacheRootPath,
+            browserBuild,
+            driverPlatform);
+
+        Assert.That(resolvedDirectory, Is.EqualTo(driverDirectory));
+    }
+
+    [Test]
+    public void WhenVersionProbeProcessTimesOutThenItFailsFast()
+    {
+        var startInfo = CreateSleepStartInfo();
+
+        var exception = Assert.Throws<TimeoutException>(
+            () => BrowserAutomationBootstrap.RunProcessAndCaptureOutput(
+                startInfo,
+                TimeSpan.FromMilliseconds(50),
+                "version probe timed out"));
+
+        Assert.That(exception, Is.Not.Null);
+        Assert.That(exception!.Message, Does.Contain("version probe timed out"));
+    }
+
     private static string GetChromeDriverExecutableFileName()
     {
         return OperatingSystem.IsWindows()
             ? ChromeDriverExecutableNameWindows
             : ChromeDriverExecutableName;
     }
 
+    private static string GetExpectedDriverPlatform()
+    {
+        if (OperatingSystem.IsMacOS())
+        {
+            return RuntimeInformation.ProcessArchitecture == Architecture.Arm64
+                ? "mac-arm64"
+                : "mac-x64";
+        }
+
+        if (OperatingSystem.IsLinux() && RuntimeInformation.ProcessArchitecture == Architecture.X64)
+        {
+            return "linux64";
+        }
+
+        return RuntimeInformation.ProcessArchitecture == Architecture.X86
+            ? "win32"
+            : "win64";
+    }
+
     private sealed class BrowserAutomationSandbox : IDisposable
     {
         private readonly string _rootPath = Path.Combine(
@@ -87,10 +145,23 @@ public BrowserAutomationSandbox()
         public string CreateFile(string fileName)
         {
             var filePath = Path.Combine(_rootPath, fileName);
+            var directoryPath = Path.GetDirectoryName(filePath);
+            if (!string.IsNullOrWhiteSpace(directoryPath))
+            {
+                Directory.CreateDirectory(directoryPath);
+            }
+
             File.WriteAllText(filePath, fileName);
             return filePath;
         }
 
+        public string CreateDirectory(string relativePath)
+        {
+            var directoryPath = Path.Combine(_rootPath, relativePath);
+            Directory.CreateDirectory(directoryPath);
+            return directoryPath;
+        }
+
         public void Dispose()
         {
             if (Directory.Exists(_rootPath))
@@ -99,4 +170,30 @@ public void Dispose()
             }
         }
     }
+
+    private static ProcessStartInfo CreateSleepStartInfo()
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            return new ProcessStartInfo
+            {
+                FileName = "powershell",
+                Arguments = "-NoProfile -Command Start-Sleep -Seconds 5",
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            };
+        }
+
+        return new ProcessStartInfo
+        {
+            FileName = "/bin/sh",
+            Arguments = "-c \"sleep 5\"",
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+        };
+    }
 }

ui-tests-ci-hang.plan.md

@@ -79,8 +79,8 @@ Fix the `DotPilot.UITests` GitHub Actions execution path so the required UI test
 - [x] `GitHub Actions job: UI Tests`
   Failure symptom: the PR validation run enters `Run UI Tests`, then fails to produce a terminal result and may later surface `Attempting to cancel the build... Error: The operation was canceled.`
   Suspected cause: the UI test harness had unbounded teardown calls for `_browserApp.Dispose()` and `BrowserTestHost.Stop()`, so a Windows-specific cleanup hang could leave the job running until GitHub eventually canceled it.
-  Intended fix path: bound teardown cleanup with explicit timeouts and convert cleanup hangs into deterministic test failures instead of infinite jobs.
-  Status: bounded cleanup is fixed locally; CI still needs instrumented logs to confirm whether any remaining hang is in driver/bootstrap, browser startup, host readiness, or teardown.
+  Intended fix path: bound teardown cleanup with explicit timeouts, add harness stage logging, bound Chrome version probing, and move the GitHub UI suite to the macOS browser environment that already ships Chrome and ChromeDriver.
+  Status: bounded cleanup is fixed locally; the remaining patch now also removes an unbounded browser-version probe and switches CI off the hanging Windows runner path, but GitHub still needs a fresh run to confirm the terminal result.
 
 ## Baseline Notes
 
@@ -95,7 +95,11 @@ Fix the `DotPilot.UITests` GitHub Actions execution path so the required UI test
 - Added bounded cleanup execution in `DotPilot.UITests` so teardown now fails fast if app disposal or browser-host shutdown hangs.
 - Added focused regression tests for the bounded-cleanup helper to prove success, exception, and timeout behavior.
 - Added harness logging around browser binary resolution, ChromeDriver resolution, host startup, setup, and cleanup so the next GitHub run exposes the exact blocking stage instead of sitting silent inside `Run UI Tests`.
+- Added a timeout around Chrome `--version` probing so browser bootstrap now fails fast instead of hanging the whole UI job when the version probe process stalls.
+- Added driver-version mapping reuse by browser build/platform so the harness can reuse a cached matching ChromeDriver without re-querying the Chrome-for-Testing patch endpoint every time.
+- Moved the GitHub Actions `UI Test Suite` job to `macos-latest` and injects the preinstalled Chrome and ChromeDriver paths through the existing Uno.UITest environment variables.
 - `dotnet test DotPilot.UITests/DotPilot.UITests.csproj --filter BoundedCleanupTests` passed.
+- `dotnet test DotPilot.UITests/DotPilot.UITests.csproj --filter BrowserAutomationBootstrapTests` passed.
 - `dotnet test DotPilot.UITests/DotPilot.UITests.csproj` passed with `9` tests green.
 - `dotnet test ./DotPilot.UITests/DotPilot.UITests.csproj --logger GitHubActions --blame-crash` passed with `9` tests green.
 - `dotnet test DotPilot.slnx` passed.