Record Playwright har/videos to helix upload root

.azure/pipelines/helix-matrix.yml

@@ -1,5 +1,9 @@
 # We only want to run full helix matrix on main
-pr: none
+pr:
+  autoCancel: true
+  branches:
+    include:
+    - '*'
 trigger: none
 schedules:
 # Cron timezone is UTC.

eng/helix/content/RunTests/Program.cs

@@ -27,6 +27,12 @@ static async Task Main(string[] args)
                 {
                     keepGoing = runner.InstallAspNetRefIfNeeded();
                 }
+#if INSTALLPLAYWRIGHT
+                if (keepGoing)
+                {
+                    keepGoing = await runner.InstallPlaywrightAsync();
+                }
+#endif
 
                 runner.DisplayContents();
 

eng/helix/content/RunTests/RunTests.csproj

@@ -3,9 +3,11 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net6.0</TargetFramework>
+    <DefineConstants Condition=" '$(InstallPlaywright)' == 'true' ">$(DefineConstants);INSTALLPLAYWRIGHT</DefineConstants>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20158.1" />
+    <PackageReference Condition=" '$(InstallPlaywright)' == 'true' " Include="PlaywrightSharp" Version="0.180.0" />
   </ItemGroup>
 </Project>

eng/helix/content/RunTests/RunTestsOptions.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
+using System.Globalization;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
@@ -67,7 +68,7 @@ public static RunTestsOptions Parse(string[] args)
                 Quarantined = parseResult.ValueForOption<bool>("--quarantined"),
                 RuntimeVersion = sharedFxVersion,
                 Target = parseResult.ValueForOption<string>("--target"),
-                Timeout = TimeSpan.Parse(parseResult.ValueForOption<string>("--helixTimeout")),
+                Timeout = TimeSpan.Parse(parseResult.ValueForOption<string>("--helixTimeout"), CultureInfo.InvariantCulture),
 
                 // When targeting pack builds, it has exactly the same version as the shared framework.
                 AspNetRef = $"Microsoft.AspNetCore.App.Ref.{sharedFxVersion}.nupkg",

eng/helix/content/RunTests/TestRunner.cs

@@ -8,6 +8,9 @@
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
+#if INSTALLPLAYWRIGHT
+using PlaywrightSharp;
+#endif
 
 namespace RunTests
 {
@@ -40,6 +43,13 @@ public bool SetupEnvironment()
                 Console.WriteLine($"Set DotNetEfFullPath: {dotnetEFFullPath}");
                 EnvironmentVariables.Add("DotNetEfFullPath", dotnetEFFullPath);
 
+#if INSTALLPLAYWRIGHT
+                // Playwright will download and look for browsers to this directory
+                var playwrightBrowsers = Path.Combine(helixDir, "ms-playwright");
+                Console.WriteLine($"Setting PLAYWRIGHT_BROWSERS_PATH: {playwrightBrowsers}");
+                EnvironmentVariables.Add("PLAYWRIGHT_BROWSERS_PATH", playwrightBrowsers);
+#endif
+
                 Console.WriteLine($"Creating nuget restore directory: {nugetRestore}");
                 Directory.CreateDirectory(nugetRestore);
 
@@ -80,6 +90,23 @@ public void DisplayContents(string path = "./")
             }
         }
 
+#if INSTALLPLAYWRIGHT
+        public async Task<bool> InstallPlaywrightAsync()
+        {
+            try
+            {
+                Console.WriteLine($"Installing Playwright to {EnvironmentVariables["PLAYWRIGHT_BROWSERS_PATH"]}");
+                await Playwright.InstallAsync(EnvironmentVariables["PLAYWRIGHT_BROWSERS_PATH"]);
+                return true;
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine($"Exception installing playwright: {e.ToString()}");
+                return false;
+            }
+        }
+#endif
+
         public async Task<bool> InstallAspNetAppIfNeededAsync()
         {
             try
@@ -136,6 +163,14 @@ await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
                         throwOnError: false,
                         cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
 
+                    await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
+                        $"tool install dotnet-serve --tool-path {Options.HELIX_WORKITEM_ROOT}",
+                        environmentVariables: EnvironmentVariables,
+                        outputDataReceived: Console.WriteLine,
+                        errorDataReceived: Console.Error.WriteLine,
+                        throwOnError: false,
+                        cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
+
                     // ';' is the path separator on Windows, and ':' on Unix
                     Options.Path += OperatingSystem.IsWindows() ? ";" : ":";
                     Options.Path += $"{Environment.GetEnvironmentVariable("DOTNET_CLI_HOME")}/.dotnet/tools";
@@ -231,7 +266,7 @@ public async Task<int> RunTestsAsync()
             {
                 // Timeout test run 5 minutes before the Helix job would timeout
                 var cts = new CancellationTokenSource(Options.Timeout.Subtract(TimeSpan.FromMinutes(5)));
-                var commonTestArgs = $"test {Options.Target} --logger:xunit --logger:\"console;verbosity=normal\" --blame \"CollectHangDump;TestTimeout=5m\"";
+                var commonTestArgs = $"test {Options.Target} --logger:xunit --logger:\"console;verbosity=normal\" --blame \"CollectHangDump;TestTimeout=15m\"";
                 if (Options.Quarantined)
                 {
                     Console.WriteLine("Running quarantined tests.");

eng/helix/content/installPlaywrightReqs.ps1

@@ -0,0 +1,12 @@
+Write-Host "Set-ExecutionPolicy Bypass -Scope Process"
+Set-ExecutionPolicy Bypass -Scope Process
+if ((Get-WindowsOptionalFeature -FeatureName ServerMediaFoundation -Online).State -eq "Enabled") {
+    Write-Host "ServerMediaFoundation feature already enabled."
+} else {
+    Write-Host "Enable-WindowsOptionalFeature -Online -FeatureName ServerMediaFoundation (For Playwright)"
+    try {
+        Enable-WindowsOptionalFeature -Online -FeatureName ServerMediaFoundation
+    } catch {
+        Write-Host "Enable-WindowsOptionalFeature -Online -FeatureName ServerMediaFoundation threw an exception: $PSItem"
+    }
+}

eng/helix/content/runtests.ps1

@@ -8,11 +8,13 @@ param(
     [string]$Quarantined,
     [string]$EF,
     [string]$HelixTimeout,
+    [string]$InstallPlaywright,
     [string]$FeedCred
 )
 
 $env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE = 1
 $env:DOTNET_MULTILEVEL_LOOKUP = 0
+$env:PLAYWRIGHT_BROWSERS_PATH = "$currentDirectory\ms-playwright"
 
 $currentDirectory = Get-Location
 $envPath = "$env:PATH;$env:HELIX_CORRELATION_PAYLOAD\node\bin"
@@ -53,7 +55,6 @@ function InstallDotnetSDKAndRuntime([string]$Feed, [string]$FeedCredParam) {
         Write-Host "Set PATH to: $env:PATH"
 
         $success = InvokeInstallDotnet ". eng\common\tools.ps1; InstallDotNet $env:DOTNET_ROOT $SdkVersion $Arch `'`' `$true `'$Feed`' `'$FeedCredParam`' `$true"
-
         if (!$success) {
             Write-Host "Retrying..."
             continue
@@ -79,15 +80,15 @@ if ([string]::IsNullOrEmpty($FeedCred)) {
     InstallDotnetSDKAndRuntime "https://dotnetclimsrc.blob.core.windows.net/dotnet" $FeedCred
 }
 
-Write-Host "Restore: dotnet restore RunTests\RunTests.csproj --ignore-failed-sources"
-dotnet restore RunTests\RunTests.csproj --ignore-failed-sources
+Write-Host "Restore: dotnet restore RunTests\RunTests.csproj --ignore-failed-sources /p:InstallPlaywright=$InstallPlaywright"
+dotnet restore RunTests\RunTests.csproj --ignore-failed-sources /p:InstallPlaywright=$InstallPlaywright
 
 if ($LastExitCode -ne 0) {
     exit $LastExitCode
 }
 
-Write-Host "Running tests: dotnet run --no-restore --project RunTests\RunTests.csproj -- --target $Target --runtime $AspRuntimeVersion --queue $Queue --arch $Arch --quarantined $Quarantined --ef $EF --helixTimeout $HelixTimeout"
-dotnet run --no-restore --project RunTests\RunTests.csproj -- --target $Target --runtime $AspRuntimeVersion --queue $Queue --arch $Arch --quarantined $Quarantined --ef $EF --helixTimeout $HelixTimeout
+Write-Host "Running tests: dotnet run --no-restore /p:InstallPlaywright=$InstallPlaywright --project RunTests\RunTests.csproj -- --target $Target --runtime $AspRuntimeVersion --queue $Queue --arch $Arch --quarantined $Quarantined --ef $EF --helixTimeout $HelixTimeout"
+dotnet run --no-restore /p:InstallPlaywright=$InstallPlaywright --project RunTests\RunTests.csproj -- --target $Target --runtime $AspRuntimeVersion --queue $Queue --arch $Arch --quarantined $Quarantined --ef $EF --helixTimeout $HelixTimeout
 
 Write-Host "Finished running tests: exit_code=$LastExitCode"
 exit $LastExitCode

eng/helix/content/runtests.sh

@@ -25,6 +25,9 @@ export DOTNET_CLI_HOME="$DIR/.home$RANDOM"
 
 export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
 
+# Set playwright browser path
+export PLAYWRIGHT_BROWSERS_PATH="$DIR/ms-playwright"
+
 RESET="\033[0m"
 RED="\033[0;31m"
 YELLOW="\033[0;33m"
@@ -49,15 +52,15 @@ if [[ -z "${10:-}" ]]; then
     }
 else
     echo "InstallDotNet $DOTNET_ROOT $dotnet_sdk_version '' '' true https://dotnetclimsrc.blob.core.windows.net/dotnet ..."
-    InstallDotNet $DOTNET_ROOT $dotnet_sdk_version "" "" true https://dotnetclimsrc.blob.core.windows.net/dotnet ${10} || {
+    InstallDotNet $DOTNET_ROOT $dotnet_sdk_version "" "" true https://dotnetclimsrc.blob.core.windows.net/dotnet ${11} || {
       exit_code=$?
       Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
       ExitWithExitCode $exit_code
     }
     echo
 
     echo "InstallDotNet $DOTNET_ROOT $dotnet_runtime_version '' dotnet true https://dotnetclimsrc.blob.core.windows.net/dotnet ..."
-    InstallDotNet $DOTNET_ROOT $dotnet_runtime_version "" dotnet true https://dotnetclimsrc.blob.core.windows.net/dotnet ${10} || {
+    InstallDotNet $DOTNET_ROOT $dotnet_runtime_version "" dotnet true https://dotnetclimsrc.blob.core.windows.net/dotnet ${11} || {
       exit_code=$?
       Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
       ExitWithExitCode $exit_code

eng/targets/Helix.Common.props

@@ -8,14 +8,6 @@
 
   <ItemGroup Condition="'$(IsWindowsOnlyTest)' == 'true'">
     <HelixAvailablePlatform Include="Windows" />
-
-    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\update_schema.ps1" />
-    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\UpdateIISExpressCertificate.ps1" />
-    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\TestCert.pfx" />
-    <HelixContent Include="$(RepoRoot)src\Servers\IIS\AspNetCoreModuleV2\AspNetCore\aspnetcore_schema_v2.xml" />
-
-    <HelixPreCommand Include="call RunPowershell.cmd update_schema.ps1 || exit /b 1" />
-    <HelixPreCommand Include="call RunPowershell.cmd UpdateIISExpressCertificate.ps1 || exit /b 1" />
   </ItemGroup>
 
   <!-- PR(ci.yaml) required queues -->

eng/targets/Helix.targets

@@ -8,6 +8,24 @@
     <HelixPreCommand Include="call RunPowershell.cmd mssql\InstallSqlServerLocalDB.ps1 || exit /b 1" />
   </ItemGroup>
 
+  <PropertyGroup Condition="'$(TestDependsOnPlaywright)' == 'true' AND '$(IsWindowsHelixQueue)' == 'true'">
+    <SkipHelixQueues>Windows.7.Amd64.Open;Windows.81.Amd64.Open</SkipHelixQueues>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TestDependsOnPlaywright)' == 'true' AND '$(IsWindowsHelixQueue)' == 'true'">
+    <HelixPreCommand Include="call RunPowershell.cmd installPlaywrightReqs.ps1 || exit /b 1" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TestDependsOnIIS)' == 'true' AND '$(IsWindowsOnlyTest)' == 'true'">
+    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\update_schema.ps1" />
+    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\UpdateIISExpressCertificate.ps1" />
+    <HelixContent Include="$(RepoRoot)src\Servers\IIS\tools\TestCert.pfx" />
+    <HelixContent Include="$(RepoRoot)src\Servers\IIS\AspNetCoreModuleV2\AspNetCore\aspnetcore_schema_v2.xml" />
+
+    <HelixPreCommand Include="call RunPowershell.cmd update_schema.ps1 || exit /b 1" />
+    <HelixPreCommand Include="call RunPowershell.cmd UpdateIISExpressCertificate.ps1 || exit /b 1" />
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TestDependsOnNode)' == 'true' AND '$(IsWindowsHelixQueue)' == 'false'">
     <HelixPreCommand Include="./installnode.sh $(NodeVersion) $(TargetArchitecture)" />
   </ItemGroup>
@@ -163,8 +181,8 @@
           SharedFxVersion because that's needed even when the targeting pack isn't building.
           Use the BrowserDebugHost transport package as a sentinel for the non-shipping version of the NETCoreApp shared framework.
         -->
-        <Command Condition="$(IsWindowsHelixQueue)">call runtests.cmd $(TargetFileName) $(NETCoreSdkVersion) $(MicrosoftNETCoreBrowserDebugHostTransportVersion) $(SharedFxVersion) $(_HelixFriendlyNameTargetQueue) $(TargetArchitecture) $(RunQuarantinedTests) $(DotnetEfVersion) $(HelixTimeout) $(DotNetRuntimeSourceFeedKey)</Command>
-        <Command Condition="!$(IsWindowsHelixQueue)">./runtests.sh $(TargetFileName) $(NETCoreSdkVersion) $(MicrosoftNETCoreBrowserDebugHostTransportVersion) $(SharedFxVersion) $(_HelixFriendlyNameTargetQueue) $(TargetArchitecture) $(RunQuarantinedTests) $(DotnetEfVersion) $(HelixTimeout) $(DotNetRuntimeSourceFeedKey)</Command>
+        <Command Condition="$(IsWindowsHelixQueue)">call runtests.cmd $(TargetFileName) $(NETCoreSdkVersion) $(MicrosoftNETCoreBrowserDebugHostTransportVersion) $(SharedFxVersion) $(_HelixFriendlyNameTargetQueue) $(TargetArchitecture) $(RunQuarantinedTests) $(DotnetEfVersion) $(HelixTimeout) $(TestDependsOnPlaywright) $(DotNetRuntimeSourceFeedKey)</Command>
+        <Command Condition="!$(IsWindowsHelixQueue)">./runtests.sh $(TargetFileName) $(NETCoreSdkVersion) $(MicrosoftNETCoreBrowserDebugHostTransportVersion) $(SharedFxVersion) $(_HelixFriendlyNameTargetQueue) $(TargetArchitecture) $(RunQuarantinedTests) $(DotnetEfVersion) $(HelixTimeout) $(TestDependsOnPlaywright) $(DotNetRuntimeSourceFeedKey)</Command>
         <Command Condition="$(HelixCommand) != ''">$(HelixCommand)</Command>
         <Timeout>$(HelixTimeout)</Timeout>
       </HelixWorkItem>

src/ProjectTemplates/BlazorTemplates.Tests/BlazorServerTemplateTest.cs

@@ -8,6 +8,7 @@
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.BrowserTesting;
+using Microsoft.AspNetCore.Testing;
 using PlaywrightSharp;
 using ProjectTemplates.Tests.Infrastructure;
 using Templates.Test.Helpers;

src/ProjectTemplates/BlazorTemplates.Tests/BlazorTemplates.Tests.csproj

@@ -6,10 +6,8 @@
 
     <RunTemplateTests Condition="'$(RunTemplateTests)' == ''">true</RunTemplateTests>
     <SkipTests Condition="'$(RunTemplateTests)' != 'true'">true</SkipTests>
-    <!--Do not run this test project on Helix.-->
-    <BuildHelixPayload>false</BuildHelixPayload>
+    <IsWindowsOnlyTest>true</IsWindowsOnlyTest>
     <SkipHelixArm>true</SkipHelixArm>
-
     <BaseOutputPath />
     <OutputPath />
 
@@ -18,6 +16,8 @@
     <TestTemplateCreationFolder>TestTemplates\</TestTemplateCreationFolder>
     <TestPackageRestorePath>$([MSBuild]::EnsureTrailingSlash('$(RepoRoot)'))obj\template-restore\</TestPackageRestorePath>
     <TestDependsOnAspNetRuntime>true</TestDependsOnAspNetRuntime>
+    <TestDependsOnMssql>true</TestDependsOnMssql>
+    <TestDependsOnPlaywright>true</TestDependsOnPlaywright>
   </PropertyGroup>
 
   <ItemGroup>

src/ProjectTemplates/BlazorTemplates.Tests/BlazorWasmTemplateTest.cs

@@ -79,6 +79,8 @@ public async Task BlazorWasmStandaloneTemplate_Works(BrowserKind browserKind)
                     EnsureBrowserAvailable(browserKind);
                 }
             }
+
+            Assert.True(0 == 1, "Fail to get logs");
         }
 
         private async Task<IPage> NavigateToPage(IBrowserContext browser, string listeningUri)
@@ -654,7 +656,19 @@ private void UpdatePublishedSettings(Project serverProject)
 
             Output.WriteLine("Running dotnet serve on published output...");
             var developmentCertificate = DevelopmentCertificate.Create(project.TemplateOutputDir);
-            var serveProcess = ProcessEx.Run(Output, publishDir, DotNetMuxer.MuxerPathOrDefault(), $"serve -S --pfx \"{developmentCertificate.CertificatePath}\" --pfx-pwd \"{developmentCertificate.CertificatePassword}\" --port 0");
+            var args = $"-S --pfx \"{developmentCertificate.CertificatePath}\" --pfx-pwd \"{developmentCertificate.CertificatePassword}\" --port 0";
+            var command = DotNetMuxer.MuxerPathOrDefault();
+            if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HELIX_DIR")))
+            {
+                args = $"serve " + args;
+            }
+            else
+            {
+                command = "dotnet-serve";
+                args = "--roll-forward LatestMajor " + args; // dotnet-serve targets net5.0 by default
+            }            
+
+            var serveProcess = ProcessEx.Run(Output, publishDir, command, args);
             var listeningUri = ResolveListeningUrl(serveProcess);
             return (serveProcess, listeningUri);
         }

src/ProjectTemplates/Shared/Project.cs

@@ -231,19 +231,25 @@ internal async Task<ProcessResult> RunDotNetEfUpdateDatabaseAsync()
         {
             var assembly = typeof(ProjectFactoryFixture).Assembly;
 
-            var dotNetEfFullPath = assembly.GetCustomAttributes<AssemblyMetadataAttribute>()
-                .First(attribute => attribute.Key == "DotNetEfFullPath")
-                .Value;
-
-            var args = $"\"{dotNetEfFullPath}\" --verbose --no-build database update";
+            var args = "--verbose --no-build database update";
 
             // Only run one instance of 'dotnet new' at once, as a workaround for
             // https://github.com/aspnet/templating/issues/63
             await DotNetNewLock.WaitAsync();
             try
             {
                 Output.WriteLine("Acquired DotNetNewLock");
-                using var result = ProcessEx.Run(Output, TemplateOutputDir, DotNetMuxer.MuxerPathOrDefault(), args);
+                var command = DotNetMuxer.MuxerPathOrDefault();
+                if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("DotNetEfFullPath")))
+                {
+                    args = $"\"{DotNetEfFullPath}\" " + args;
+                }
+                else
+                {
+                    command = "dotnet-ef";
+                }
+
+                using var result = ProcessEx.Run(Output, TemplateOutputDir, command, args);
                 await result.Exited;
                 return new ProcessResult(result);
             }

src/Servers/IIS/IIS/test/Directory.Build.props

@@ -8,6 +8,7 @@
 
     <!-- IIS tests are Windows-only -->
     <IsWindowsOnlyTest>true</IsWindowsOnlyTest>
+    <TestDependsOnIIS>true</TestDependsOnIIS>
   </PropertyGroup>
 
 </Project>

src/Shared/BrowserTesting/src/BrowserManager.cs

@@ -46,7 +46,7 @@ private async Task InitializeAsync()
 
             async Task InitializeCore()
             {
-                Playwright = await PlaywrightSharp.Playwright.CreateAsync(_loggerFactory, debug: "pw:api");
+                Playwright = await PlaywrightSharp.Playwright.CreateAsync(_loggerFactory/*, debug: "pw:api"*/);
                 foreach (var (browserName, options) in _browserManagerConfiguration.BrowserOptions)
                 {
                     if (!_launchBrowsers.ContainsKey(browserName))

src/Shared/BrowserTesting/src/ContextInformation.cs

@@ -55,10 +55,25 @@ internal BrowserContextOptions ConfigureUniqueHarPath(BrowserContextOptions brow
             if (browserContextOptions?.RecordHar?.Path != null)
             {
                 var identifier = Guid.NewGuid().ToString("N");
-                browserContextOptions.RecordHar.Path = Path.Combine(browserContextOptions.RecordHar.Path, $"{identifier}.har");
+                var harDirectory = Environment.GetEnvironmentVariable("HELIX_WORKITEM_UPLOAD_ROOT");
+                if (string.IsNullOrEmpty(harDirectory))
+                {
+                    harDirectory = browserContextOptions.RecordHar.Path;
+                }
+
+                browserContextOptions.RecordHar.Path = Path.Combine(harDirectory, $"{identifier}.har");
                 _harPath = browserContextOptions.RecordHar.Path;
             }
 
+            if (browserContextOptions?.RecordVideo?.Dir != null)
+            {
+                var uploadDir = Environment.GetEnvironmentVariable("HELIX_WORKITEM_UPLOAD_ROOT");
+                if (!string.IsNullOrEmpty(uploadDir))
+                {
+                    browserContextOptions.RecordVideo.Dir = uploadDir;
+                }
+            }
+
             return browserContextOptions;
         }
     }