Browser tests (#50844)

Author: tmat

Directory.Build.targets

@@ -73,7 +73,7 @@
   <ItemGroup Condition="$(MicrosoftAspNetCoreAppRefPackageVersion.StartsWith('$(_TargetFrameworkVersionWithoutV)'))">
     <KnownFrameworkReference Update="Microsoft.AspNetCore.App">
       <LatestRuntimeFrameworkVersion>$(MicrosoftAspNetCoreAppRefPackageVersion)</LatestRuntimeFrameworkVersion>
-      <RuntimePackRuntimeIdentifiers>${SupportedRuntimeIdentifiers}</RuntimePackRuntimeIdentifiers>
+      <RuntimePackRuntimeIdentifiers>$(SupportedRuntimeIdentifiers)</RuntimePackRuntimeIdentifiers>
       <TargetingPackVersion>$(MicrosoftAspNetCoreAppRefPackageVersion)</TargetingPackVersion>
       <DefaultRuntimeFrameworkVersion>$(MicrosoftAspNetCoreAppRefPackageVersion)</DefaultRuntimeFrameworkVersion>
     </KnownFrameworkReference>

sdk.slnx

@@ -312,6 +312,7 @@
     <Project Path="test/dotnet-format.UnitTests/dotnet-format.UnitTests.csproj" />
     <Project Path="test/dotnet-MsiInstallation.Tests/dotnet-MsiInstallation.Tests.csproj" />
     <Project Path="test/dotnet-new.IntegrationTests/dotnet-new.IntegrationTests.csproj" />
+    <Project Path="test/dotnet-watch-test-browser/dotnet-watch-test-browser.csproj" />
     <Project Path="test/dotnet-watch.Tests/dotnet-watch.Tests.csproj" />
     <Project Path="test/dotnet.Tests/dotnet.Tests.csproj" />
     <Project Path="test/EndToEnd.Tests/EndToEnd.Tests.csproj" />

src/BuiltInTools/HotReloadClient/HotReloadClients.cs

@@ -173,7 +173,7 @@ public async Task ApplyStaticAssetUpdatesAsync(IEnumerable<(string filePath, str
 #endif
                     content = ImmutableCollectionsMarshal.AsImmutableArray(blob);
                 }
-                catch (Exception e)
+                catch (Exception e) when (e is not OperationCanceledException)
                 {
                     ClientLogger.LogError("Failed to read file {FilePath}: {Message}", filePath, e.Message);
                     continue;

src/BuiltInTools/HotReloadClient/Logging/LogEvents.cs

@@ -30,4 +30,5 @@ public static void Log(this ILogger logger, LogEvent logEvent, params object[] a
     public static readonly LogEvent UpdatingDiagnostics = Create(LogLevel.Debug, "Updating diagnostics.");
     public static readonly LogEvent SendingStaticAssetUpdateRequest = Create(LogLevel.Debug, "Sending static asset update request to connected browsers: '{0}'.");
     public static readonly LogEvent RefreshServerRunningAt = Create(LogLevel.Debug, "Refresh server running at {0}.");
+    public static readonly LogEvent ConnectedToRefreshServer = Create(LogLevel.Debug, "Connected to refresh server.");
 }

src/BuiltInTools/HotReloadClient/Web/AbstractBrowserRefreshServer.cs

@@ -163,7 +163,7 @@ public async Task WaitForClientConnectionAsync(CancellationToken cancellationTok
         }, progressCancellationSource.Token);
 
         // Work around lack of Task.WaitAsync(cancellationToken) on .NET Framework:
-        cancellationToken.Register(() => _browserConnected.SetCanceled());
+        cancellationToken.Register(() => _browserConnected.TrySetCanceled());
 
         try
         {

src/BuiltInTools/HotReloadClient/Web/BrowserConnection.cs

@@ -37,7 +37,7 @@ public BrowserConnection(WebSocket clientSocket, string? sharedSecret, ILoggerFa
         ServerLogger = loggerFactory.CreateLogger(ServerLogComponentName, displayName);
         AgentLogger = loggerFactory.CreateLogger(AgentLogComponentName, displayName);
 
-        ServerLogger.LogDebug("Connected to referesh server.");
+        ServerLogger.Log(LogEvents.ConnectedToRefreshServer);
     }
 
     public void Dispose()

src/BuiltInTools/dotnet-watch.slnf

@@ -18,10 +18,11 @@
       "src\\BuiltInTools\\HotReloadClient\\Microsoft.DotNet.HotReload.Client.shproj",
       "src\\BuiltInTools\\dotnet-watch\\dotnet-watch.csproj",
       "test\\Microsoft.AspNetCore.Watch.BrowserRefresh.Tests\\Microsoft.AspNetCore.Watch.BrowserRefresh.Tests.csproj",
+      "test\\Microsoft.DotNet.HotReload.Client.Tests\\Microsoft.DotNet.HotReload.Client.Tests.csproj",
       "test\\Microsoft.Extensions.DotNetDeltaApplier.Tests\\Microsoft.Extensions.DotNetDeltaApplier.Tests.csproj",
       "test\\Microsoft.NET.TestFramework\\Microsoft.NET.TestFramework.csproj",
       "test\\Microsoft.WebTools.AspireService.Tests\\Microsoft.WebTools.AspireService.Tests.csproj",
-      "test\\Microsoft.DotNet.HotReload.Client.Tests\\Microsoft.DotNet.HotReload.Client.Tests.csproj",
+      "test\\dotnet-watch-test-browser\\dotnet-watch-test-browser.csproj",
       "test\\dotnet-watch.Tests\\dotnet-watch.Tests.csproj"
     ]
   }

src/BuiltInTools/dotnet-watch/Browser/BrowserLauncher.cs

@@ -4,13 +4,14 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using Microsoft.Build.Graph;
 using Microsoft.DotNet.HotReload;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DotNet.Watch;
 
-internal sealed class BrowserLauncher(ILogger logger, EnvironmentOptions environmentOptions)
+internal sealed class BrowserLauncher(ILogger logger, IProcessOutputReporter processOutputReporter, EnvironmentOptions environmentOptions)
 {
     // interlocked
     private ImmutableHashSet<ProjectInstanceId> _browserLaunchAttempted = [];
@@ -61,18 +62,13 @@ public static string GetLaunchUrl(string? profileLaunchUrl, string outputLaunchU
 
     private void LaunchBrowser(string launchUrl, AbstractBrowserRefreshServer? server)
     {
-        var fileName = launchUrl;
+        var (fileName, arg, useShellExecute) = environmentOptions.BrowserPath is { } browserPath
+            ? (browserPath, launchUrl, false)
+            : (launchUrl, null, true);
 
-        var args = string.Empty;
-        if (environmentOptions.BrowserPath is { } browserPath)
-        {
-            args = fileName;
-            fileName = browserPath;
-        }
+        logger.Log(MessageDescriptor.LaunchingBrowser, fileName, arg);
 
-        logger.LogDebug("Launching browser: {FileName} {Args}", fileName, args);
-
-        if (environmentOptions.TestFlags != TestFlags.None)
+        if (environmentOptions.TestFlags != TestFlags.None && environmentOptions.BrowserPath == null)
         {
             if (environmentOptions.TestFlags.HasFlag(TestFlags.MockBrowser))
             {
@@ -83,29 +79,23 @@ private void LaunchBrowser(string launchUrl, AbstractBrowserRefreshServer? serve
             return;
         }
 
-        var info = new ProcessStartInfo
+        // dotnet-watch, by default, relies on URL file association to launch browsers. On Windows and MacOS, this works fairly well
+        // where URLs are associated with the default browser. On Linux, this is a bit murky.
+        // From emperical observation, it's noted that failing to launch a browser results in either Process.Start returning a null-value
+        // or for the process to have immediately exited.
+        // We can use this to provide a helpful message.
+        var processSpec = new ProcessSpec()
         {
-            FileName = fileName,
-            Arguments = args,
-            UseShellExecute = true,
+            Executable = fileName,
+            Arguments = arg != null ? [arg] : [],
+            UseShellExecute = useShellExecute,
+            OnOutput = environmentOptions.TestFlags.HasFlag(TestFlags.RedirectBrowserOutput) ? processOutputReporter.ReportOutput : null,
         };
 
-        try
-        {
-            using var browserProcess = Process.Start(info);
-            if (browserProcess is null or { HasExited: true })
-            {
-                // dotnet-watch, by default, relies on URL file association to launch browsers. On Windows and MacOS, this works fairly well
-                // where URLs are associated with the default browser. On Linux, this is a bit murky.
-                // From emperical observation, it's noted that failing to launch a browser results in either Process.Start returning a null-value
-                // or for the process to have immediately exited.
-                // We can use this to provide a helpful message.
-                logger.LogInformation("Unable to launch the browser. Url '{Url}'.", launchUrl);
-            }
-        }
-        catch (Exception e)
+        using var browserProcess = ProcessRunner.TryStartProcess(processSpec, logger);
+        if (browserProcess is null or { HasExited: true })
         {
-            logger.LogDebug("Failed to launch a browser: {Message}", e.Message);
+            logger.LogWarning("Unable to launch the browser. Url '{Url}'.", launchUrl);
         }
     }
 

src/BuiltInTools/dotnet-watch/Build/ProjectGraphUtilities.cs

@@ -43,6 +43,10 @@ internal static class ProjectGraphUtilities
         }
         catch (Exception e) when (e is not OperationCanceledException)
         {
+            // ProejctGraph aggregates OperationCanceledException exception,
+            // throw here to propagate the cancellation.
+            cancellationToken.ThrowIfCancellationRequested();
+
             logger.LogDebug("Failed to load project graph.");
 
             if (e is AggregateException { InnerExceptions: var innerExceptions })

src/BuiltInTools/dotnet-watch/CommandLine/EnvironmentOptions.cs

@@ -22,6 +22,11 @@ internal enum TestFlags
         /// This allows tests to trigger key based events.
         /// </summary>
         ReadKeyFromStdin = 1 << 3,
+
+        /// <summary>
+        /// Redirects the output of the launched browser process to watch output.
+        /// </summary>
+        RedirectBrowserOutput = 1 << 4,
     }
 
     internal sealed record EnvironmentOptions(