Use StaticWebAssetBasePath if specified to calculate blazorwasm publish paths (#27896)

pranavkm · mkArtakMSFT · web-flow · commit d9dd46ec8e72 · 2020-11-20T23:46:31.000-08:00
In 3.2, Blazor WebAssembly had a feature which allowed prefix the relative path within the PublishDir by configuring a StaticWebAssetBasePath property in the project file. As part of migrating to 5.0, this feature was (accidentally) not brought forward which is remedied by this commit. * Use StaticWebAssetBasePath to calculate asset base paths * Add publish tests to verify hosted and standalone scenarios Fixes #27776 Co-authored-by: Artak <34246760+mkArtakMSFT@users.noreply.github.com>
diff --git a/src/Components/WebAssembly/Sdk/integrationtests/ServiceWorkerAssert.cs b/src/Components/WebAssembly/Sdk/integrationtests/ServiceWorkerAssert.cs
@@ -12,11 +12,16 @@ namespace Microsoft.AspNetCore.Razor.Design.IntegrationTests
 {
     internal static class ServiceWorkerAssert
     {
-        internal static void VerifyServiceWorkerFiles(MSBuildResult result, string outputDirectory, string serviceWorkerPath, string serviceWorkerContent, string assetsManifestPath)
+        internal static void VerifyServiceWorkerFiles(MSBuildResult result,
+            string outputDirectory,
+            string serviceWorkerPath,
+            string serviceWorkerContent,
+            string assetsManifestPath,
+            string staticWebAssetsBasePath = "")
         {
             // Check the expected files are there
-            var serviceWorkerResolvedPath = Assert.FileExists(result, outputDirectory, serviceWorkerPath);
-            var assetsManifestResolvedPath = Assert.FileExists(result, outputDirectory, assetsManifestPath);
+            var serviceWorkerResolvedPath = Assert.FileExists(result, outputDirectory, staticWebAssetsBasePath, serviceWorkerPath);
+            var assetsManifestResolvedPath = Assert.FileExists(result, outputDirectory, staticWebAssetsBasePath, assetsManifestPath);
 
             // Check the service worker contains the expected content (which comes from the PublishedContent file)
             Assert.FileContains(result, serviceWorkerResolvedPath, serviceWorkerContent);
@@ -36,8 +41,8 @@ internal static void VerifyServiceWorkerFiles(MSBuildResult result, string outpu
                 // We don't list compressed files in the SWAM, as these are transparent to the client,
                 // nor do we list the service worker itself or its assets manifest, as these don't need to be fetched in the same way
                 if (IsCompressedFile(relativePath)
-                    || string.Equals(relativePath, serviceWorkerPath, StringComparison.Ordinal)
-                    || string.Equals(relativePath, assetsManifestPath, StringComparison.Ordinal))
+                    || string.Equals(relativePath, Path.Combine(staticWebAssetsBasePath, serviceWorkerPath), StringComparison.Ordinal)
+                    || string.Equals(relativePath, Path.Combine(staticWebAssetsBasePath, assetsManifestPath), StringComparison.Ordinal))
                 {
                     continue;
                 }
diff --git a/src/Components/WebAssembly/Sdk/integrationtests/WasmPublishIntegrationTest.cs b/src/Components/WebAssembly/Sdk/integrationtests/WasmPublishIntegrationTest.cs
@@ -252,6 +252,111 @@ public async Task Publish_WithNoBuild_Works()
             VerifyCompression(result, blazorPublishDirectory);
         }
 
+        [Fact]
+        public async Task Publish_WithStaticWebBasePathWorks()
+        {
+            // Arrange
+            using var project = ProjectDirectory.Create("blazorwasm", "razorclasslibrary");
+            project.AddProjectFileContent(
+@"<PropertyGroup>
+    <StaticWebAssetBasePath>different-path/</StaticWebAssetBasePath>
+</PropertyGroup>");
+            var result = await MSBuildProcessManager.DotnetMSBuild(project, "Publish");
+
+            Assert.BuildPassed(result);
+
+            var publishDirectory = project.PublishOutputDirectory;
+
+            // Verify nothing is published directly to the wwwroot directory
+            Assert.FileCountEquals(result, 0, Path.Combine(publishDirectory, "wwwroot"), "*", SearchOption.TopDirectoryOnly);
+
+            var blazorPublishDirectory = Path.Combine(publishDirectory, "wwwroot", "different-path");
+
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazor.boot.json");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazor.webassembly.js");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "dotnet.wasm");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", DotNetJsFileName);
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazorwasm.dll");
+
+            // Verify static assets are in the publish directory
+            Assert.FileExists(result, blazorPublishDirectory, "index.html");
+
+            // Verify web.config
+            Assert.FileExists(result, publishDirectory, "web.config");
+            var webConfigContent = new StreamReader(GetType().Assembly.GetManifestResourceStream("Microsoft.NET.Sdk.BlazorWebAssembly.IntegrationTests.BlazorWasm.web.config")).ReadToEnd();
+            Assert.FileContentEquals(result, Path.Combine(publishDirectory, "web.config"), webConfigContent);
+            Assert.FileCountEquals(result, 1, publishDirectory, "*", SearchOption.TopDirectoryOnly);
+
+            // Verify static web assets from referenced projects are copied.
+            Assert.FileExists(result, blazorPublishDirectory, "_content", "RazorClassLibrary", "wwwroot", "exampleJsInterop.js");
+            Assert.FileExists(result, blazorPublishDirectory, "_content", "RazorClassLibrary", "styles.css");
+
+            VerifyBootManifestHashes(result, blazorPublishDirectory);
+            VerifyServiceWorkerFiles(result,
+                Path.Combine(publishDirectory, "wwwroot"),
+                serviceWorkerPath: Path.Combine("serviceworkers", "my-service-worker.js"),
+                serviceWorkerContent: "// This is the production service worker",
+                assetsManifestPath: "custom-service-worker-assets.js",
+                staticWebAssetsBasePath: "different-path");
+        }
+
+        [Fact]
+        public async Task Publish_Hosted_WithStaticWebBasePathWorks()
+        {
+            using var project = ProjectDirectory.Create("blazorhosted", additionalProjects: new[] { "blazorwasm", "razorclasslibrary", });
+            var wasmProject = project.GetSibling("blazorwasm");
+            wasmProject.AddProjectFileContent(
+@"<PropertyGroup>
+    <StaticWebAssetBasePath>different-path/</StaticWebAssetBasePath>
+</PropertyGroup>");
+            var result = await MSBuildProcessManager.DotnetMSBuild(project, "Publish");
+
+            Assert.BuildPassed(result);
+
+            var publishDirectory = project.PublishOutputDirectory;
+            // Make sure the main project exists
+            Assert.FileExists(result, publishDirectory, "blazorhosted.dll");
+
+            Assert.FileExists(result, publishDirectory, "RazorClassLibrary.dll");
+            Assert.FileExists(result, publishDirectory, "blazorwasm.dll");
+
+            var blazorPublishDirectory = Path.Combine(publishDirectory, "wwwroot", "different-path");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazor.boot.json");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazor.webassembly.js");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "dotnet.wasm");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", DotNetJsFileName);
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazorwasm.dll");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "System.Text.Json.dll"); // Verify dependencies are part of the output.
+
+            // Verify project references appear as static web assets
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "RazorClassLibrary.dll");
+            // Also verify project references to the server project appear in the publish output
+            Assert.FileExists(result, publishDirectory, "RazorClassLibrary.dll");
+
+            // Verify static assets are in the publish directory
+            Assert.FileExists(result, blazorPublishDirectory, "index.html");
+
+            // Verify static web assets from referenced projects are copied.
+            Assert.FileExists(result, publishDirectory, "wwwroot", "_content", "RazorClassLibrary", "wwwroot", "exampleJsInterop.js");
+            Assert.FileExists(result, publishDirectory, "wwwroot", "_content", "RazorClassLibrary", "styles.css");
+
+            // Verify web.config
+            Assert.FileExists(result, publishDirectory, "web.config");
+
+            VerifyBootManifestHashes(result, blazorPublishDirectory);
+
+            // Verify compression works
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "dotnet.wasm.br");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazorwasm.dll.br");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "RazorClassLibrary.dll.br");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "System.Text.Json.dll.br");
+
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "dotnet.wasm.gz");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazorwasm.dll.gz");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "RazorClassLibrary.dll.gz");
+            Assert.FileExists(result, blazorPublishDirectory, "_framework", "System.Text.Json.dll.gz");
+        }
+
         private static void VerifyCompression(MSBuildResult result, string blazorPublishDirectory)
         {
             var original = Assert.FileExists(result, blazorPublishDirectory, "_framework", "blazor.boot.json");
diff --git a/src/Components/WebAssembly/Sdk/src/targets/Microsoft.NET.Sdk.BlazorWebAssembly.Current.targets b/src/Components/WebAssembly/Sdk/src/targets/Microsoft.NET.Sdk.BlazorWebAssembly.Current.targets
@@ -74,7 +74,6 @@ Copyright (c) .NET Foundation. All rights reserved.
 
     <!-- Internal properties -->
     <_BlazorOutputPath>wwwroot\_framework\</_BlazorOutputPath>
-
   </PropertyGroup>
 
   <ItemGroup>
@@ -457,6 +456,12 @@ Copyright (c) .NET Foundation. All rights reserved.
       <Output TaskParameter="JoinResult" ItemName="_ResolvedSatelliteToPublish" />
     </JoinItems>
 
+    <PropertyGroup>
+      <_BlazorPublishOutputPath Condition="'$(StaticWebAssetBasePath)' != '/'">wwwroot\$(StaticWebAssetBasePath.Replace('/', '\'))</_BlazorPublishOutputPath>
+      <_BlazorPublishOutputPath Condition="'$(StaticWebAssetBasePath)' == '/'">wwwroot\</_BlazorPublishOutputPath>
+      <_BlazorFrameworkPublishPath>$(_BlazorPublishOutputPath)_framework\</_BlazorFrameworkPublishPath>
+    </PropertyGroup>
+
     <ItemGroup>
       <ResolvedFileToPublish Remove="@(_ResolvedSatelliteToPublish)" />
       <ResolvedFileToPublish Include="@(_ResolvedSatelliteToPublish)" />
@@ -472,13 +477,24 @@ Copyright (c) .NET Foundation. All rights reserved.
       <!-- Remove dotnet.js from publish output -->
       <ResolvedFileToPublish Remove="@(ResolvedFileToPublish)" Condition="'%(ResolvedFileToPublish.RelativePath)' == 'dotnet.js'" />
 
+      <!-- Remove pdbs from the publish output -->
+      <ResolvedFileToPublish Remove="@(ResolvedFileToPublish)" Condition="'$(CopyOutputSymbolsToPublishDirectory)' != 'true' AND '%(Extension)' == '.pdb'" />
+
       <!-- Retarget so that items are published to the wwwroot directory -->
+      <!--
+        This changes files (such as wwwroot/index.html) that are published to $(PublishDir)wwwroot\ -> $(PublishDir)wwwroot\$(StaticWebAssetBasePath)\.
+        Ignore any user specified web.config in the process.
+      -->
       <ResolvedFileToPublish
-        RelativePath="$(_BlazorOutputPath)%(ResolvedFileToPublish.RelativePath)"
-        Condition="'%(ResolvedFileToPublish.RelativePath)' != 'web.config' AND !$([System.String]::Copy('%(ResolvedFileToPublish.RelativePath)').Replace('\','/').StartsWith('wwwroot/'))" />
+        RelativePath="$(_BlazorPublishOutputPath)$([System.String]::Copy('%(ResolvedFileToPublish.RelativePath)').Replace('/','\').Substring(8))"
+        Condition="'$(StaticWebAssetBasePath)' != '/' AND $([System.String]::Copy('%(ResolvedFileToPublish.RelativePath)').Replace('/','\').StartsWith('wwwroot\'))" />
 
-      <!-- Remove pdbs from the publish output -->
-      <ResolvedFileToPublish Remove="@(ResolvedFileToPublish)" Condition="'$(CopyOutputSymbolsToPublishDirectory)' != 'true' AND '%(Extension)' == '.pdb'" />
+      <!--
+        Change all remaining publish output to publish to appear under the $(PublishDir)wwwroot\$(StaticWebAssetBasePath) path.
+      -->
+      <ResolvedFileToPublish
+        RelativePath="$(_BlazorFrameworkPublishPath)%(ResolvedFileToPublish.RelativePath)"
+        Condition="'%(ResolvedFileToPublish.RelativePath)' != 'web.config' AND !$([System.String]::Copy('%(ResolvedFileToPublish.RelativePath)').Replace('/','\').StartsWith('wwwroot\'))" />
     </ItemGroup>
 
     <ItemGroup Condition="'@(ResolvedFileToPublish->AnyHaveMetadataValue('RelativePath', 'web.config'))' != 'true'">
@@ -515,11 +531,11 @@ Copyright (c) .NET Foundation. All rights reserved.
     <ItemGroup>
       <ResolvedFileToPublish
         Include="$(IntermediateOutputPath)blazor.publish.boot.json"
-        RelativePath="$(_BlazorOutputPath)blazor.boot.json" />
+        RelativePath="$(_BlazorFrameworkPublishPath)blazor.boot.json" />
 
       <ResolvedFileToPublish
         Include="@(_BlazorJSFile)"
-        RelativePath="$(_BlazorOutputPath)%(FileName)%(Extension)" />
+        RelativePath="$(_BlazorFrameworkPublishPath)%(FileName)%(Extension)" />
     </ItemGroup>
   </Target>
 
diff --git a/src/Components/WebAssembly/Sdk/src/targets/Microsoft.NET.Sdk.BlazorWebAssembly.ServiceWorkerAssetsManifest.targets b/src/Components/WebAssembly/Sdk/src/targets/Microsoft.NET.Sdk.BlazorWebAssembly.ServiceWorkerAssetsManifest.targets
@@ -128,6 +128,7 @@ Copyright (c) .NET Foundation. All rights reserved.
         <ContentSourcePath Condition="'%(ServiceWorker.PublishedContent)' != ''">%(ServiceWorker.PublishedContent)</ContentSourcePath>
         <ContentSourcePath Condition="'%(ServiceWorker.PublishedContent)' == ''">%(ServiceWorker.Identity)</ContentSourcePath>
         <RelativePath>%(ServiceWorker.Identity)</RelativePath>
+        <RelativePath Condition="$([System.String]::Copy('%(ServiceWorker.Identity)').Replace('/','\').StartsWith('wwwroot\'))">$(_BlazorPublishOutputPath)$([System.String]::Copy('%(ServiceWorker.Identity)').Substring(8))</RelativePath>
       </_ServiceWorkerIntermediatePublishFile>
 
       <_ServiceWorkerPublishFile Include="@(ResolvedFileToPublish)" Condition="$([System.String]::Copy('%(ResolvedFileToPublish.RelativePath)').Replace('\','/').StartsWith('wwwroot/'))">
@@ -161,7 +162,7 @@ Copyright (c) .NET Foundation. All rights reserved.
       <ResolvedFileToPublish
         Include="$(_ServiceWorkerAssetsManifestPublishIntermediateOutputPath)"
         CopyToPublishDirectory="PreserveNewest"
-        RelativePath="wwwroot\$(ServiceWorkerAssetsManifest)"
+        RelativePath="$(_BlazorPublishOutputPath)$(ServiceWorkerAssetsManifest)"
         ExcludeFromSingleFile="true" />
     </ItemGroup>
   </Target>

Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,16 @@ namespace Microsoft.AspNetCore.Razor.Design.IntegrationTests`
`12`	`12`	`{`
`13`	`13`	`internal static class ServiceWorkerAssert`
`14`	`14`	`{`
`15`		`- internal static void VerifyServiceWorkerFiles(MSBuildResult result, string outputDirectory, string serviceWorkerPath, string serviceWorkerContent, string assetsManifestPath)`
	`15`	`+ internal static void VerifyServiceWorkerFiles(MSBuildResult result,`
	`16`	`+ string outputDirectory,`
	`17`	`+ string serviceWorkerPath,`
	`18`	`+ string serviceWorkerContent,`
	`19`	`+ string assetsManifestPath,`
	`20`	`+ string staticWebAssetsBasePath = "")`
`16`	`21`	`{`
`17`	`22`	`// Check the expected files are there`
`18`		`- var serviceWorkerResolvedPath = Assert.FileExists(result, outputDirectory, serviceWorkerPath);`
`19`		`- var assetsManifestResolvedPath = Assert.FileExists(result, outputDirectory, assetsManifestPath);`
	`23`	`+ var serviceWorkerResolvedPath = Assert.FileExists(result, outputDirectory, staticWebAssetsBasePath, serviceWorkerPath);`
	`24`	`+ var assetsManifestResolvedPath = Assert.FileExists(result, outputDirectory, staticWebAssetsBasePath, assetsManifestPath);`
`20`	`25`
`21`	`26`	`// Check the service worker contains the expected content (which comes from the PublishedContent file)`
`22`	`27`	`Assert.FileContains(result, serviceWorkerResolvedPath, serviceWorkerContent);`
`@@ -36,8 +41,8 @@ internal static void VerifyServiceWorkerFiles(MSBuildResult result, string outpu`
`36`	`41`	`// We don't list compressed files in the SWAM, as these are transparent to the client,`
`37`	`42`	`// nor do we list the service worker itself or its assets manifest, as these don't need to be fetched in the same way`
`38`	`43`	`if (IsCompressedFile(relativePath)`
`39`		`- \|\| string.Equals(relativePath, serviceWorkerPath, StringComparison.Ordinal)`
`40`		`- \|\| string.Equals(relativePath, assetsManifestPath, StringComparison.Ordinal))`
	`44`	`+ \|\| string.Equals(relativePath, Path.Combine(staticWebAssetsBasePath, serviceWorkerPath), StringComparison.Ordinal)`
	`45`	`+ \|\| string.Equals(relativePath, Path.Combine(staticWebAssetsBasePath, assetsManifestPath), StringComparison.Ordinal))`
`41`	`46`	`{`
`42`	`47`	`continue;`
`43`	`48`	`}`