Include static web assets endpoints manifest tests

Author: javiercn

src/StaticWebAssetsSdk/Targets/Microsoft.NET.Sdk.StaticWebAssets.targets

@@ -299,7 +299,7 @@ Copyright (c) .NET Foundation. All rights reserved.
       $(ResolveBuildRelatedStaticWebAssetsDependsOn)
     </ResolveBuildRelatedStaticWebAssetsDependsOn>
 
-    <GetCopyToOutputDirectoryItemsDependsOn>$(GetCopyToOutputDirectoryItemsDependsOn);AddStaticWebAssetsManifest</GetCopyToOutputDirectoryItemsDependsOn>
+    <GetCopyToOutputDirectoryItemsDependsOn>$(GetCopyToOutputDirectoryItemsDependsOn);AddStaticWebAssetsManifest;AddStaticWebAssetEndpointsBuildManifest</GetCopyToOutputDirectoryItemsDependsOn>
 
     <CopyStaticWebAssetsToOutputDirectoryDependsOn>LoadStaticWebAssetsBuildManifest;$(CopyStaticWebAssetsToOutputDirectoryDependsOn)</CopyStaticWebAssetsToOutputDirectoryDependsOn>
 

src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetEndpointsManifest.cs

@@ -3,7 +3,7 @@
 
 namespace Microsoft.NET.Sdk.StaticWebAssets.Tasks;
 
-internal class StaticWebAssetEndpointsManifest()
+public class StaticWebAssetEndpointsManifest()
 {
     public int Version { get; set; }
 

test/Microsoft.NET.Sdk.Razor.Tests/StaticWebAssetEndpointsIntegrationTest.cs

@@ -1,9 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Text.Json;
 using Microsoft.AspNetCore.StaticWebAssets.Tasks;
 using Microsoft.NET.Sdk.StaticWebAssets.Tasks;
-using NuGet.Packaging;
 
 namespace Microsoft.NET.Sdk.Razor.Tests;
 
@@ -242,4 +242,174 @@ public void Publish_CreatesEndpointsForAssets_BuildAndPublish_Assets()
 
         AssertManifest(publishManifest, LoadPublishManifest());
     }
+
+    [Fact]
+    public void Build_EndpointManifest_ContainsEndpoints()
+    {
+        // Arrange
+        var expectedExtensions = new[] { ".pdb", ".js", ".wasm" };
+        var testAppName = "BlazorWasmWithLibrary";
+        var testInstance = CreateAspNetSdkTestAsset(testAppName)
+            .WithProjectChanges((p, doc) =>
+            {
+                if (Path.GetFileName(p) == "blazorwasm.csproj")
+                {
+                    var itemGroup = new XElement("PropertyGroup");
+                    var serviceWorkerAssetsManifest = new XElement("ServiceWorkerAssetsManifest", "service-worker-assets.js");
+                    itemGroup.Add(serviceWorkerAssetsManifest);
+                    doc.Root.Add(itemGroup);
+                }
+            });
+
+        var buildCommand = new BuildCommand(testInstance, "blazorwasm");
+        buildCommand.WithWorkingDirectory(testInstance.TestRoot);
+        buildCommand.Execute("/bl").Should().Pass();
+
+        var buildOutputDirectory = buildCommand.GetOutputDirectory(DefaultTfm).ToString();
+        VerifyEndpointsCollection(buildOutputDirectory, "blazorwasm", readFromDevManifest: true);
+    }
+
+    [Fact]
+    public void BuildHosted_EndpointManifest_ContainsEndpoints()
+    {
+        // Arrange
+        var testAppName = "BlazorHosted";
+        var testInstance = CreateAspNetSdkTestAsset(testAppName);
+
+        var buildCommand = new BuildCommand(testInstance, "blazorhosted");
+        buildCommand.Execute()
+            .Should().Pass();
+
+        var buildOutputDirectory = OutputPathCalculator.FromProject(Path.Combine(testInstance.TestRoot, "blazorhosted")).GetOutputDirectory();
+
+        VerifyEndpointsCollection(buildOutputDirectory, "blazorhosted", readFromDevManifest: true);
+    }
+
+    [Fact]
+    public void Publish_EndpointManifestContainsEndpoints()
+    {
+        // Arrange
+        var testAppName = "BlazorWasmWithLibrary";
+        var testInstance = CreateAspNetSdkTestAsset(testAppName);
+
+        var publishCommand = new PublishCommand(testInstance, "blazorwasm");
+        publishCommand.Execute().Should().Pass();
+
+        var publishOutputDirectory = publishCommand.GetOutputDirectory(DefaultTfm).ToString();
+
+        VerifyEndpointsCollection(publishOutputDirectory, "blazorwasm");
+    }
+
+    [Fact]
+    public void PublishHosted_EndpointManifest_ContainsEndpoints()
+    {
+        // Arrange
+        var testAppName = "BlazorHosted";
+        var testInstance = CreateAspNetSdkTestAsset(testAppName);
+
+        var publishCommand = new PublishCommand(testInstance, "blazorhosted");
+        publishCommand.Execute().Should().Pass();
+
+        var publishOutputDirectory = publishCommand.GetOutputDirectory(DefaultTfm).ToString();
+
+        VerifyEndpointsCollection(publishOutputDirectory, "blazorhosted");
+    }
+
+    // Makes several assertions about the endpoints we defined.
+    // All assets have at least one endpoint.
+    // No endpoint points to a non-existent asset
+    // All compressed assets have 2 endpoints (one for the path with the extension, one for the path without the extension)
+    // All uncompressed assets have 1 endpoint
+    private static void VerifyEndpointsCollection(string outputDirectory, string projectName, bool readFromDevManifest = false)
+    {
+        var endpointsManifestFile = Path.Combine(outputDirectory, $"{projectName}.staticwebassets.endpoints.json");
+
+        var endpoints = JsonSerializer.Deserialize<StaticWebAssetEndpointsManifest>(File.ReadAllText(endpointsManifestFile));
+
+        var wwwrootFolderFiles = GetWwwrootFolderFiles(outputDirectory);
+
+        var foundAssets = new HashSet<string>();
+        var endpointsByAssetFile = endpoints.Endpoints.GroupBy(e => e.AssetFile).ToDictionary(g => g.Key, g => g.ToArray());
+
+        foreach (var endpoint in endpoints.Endpoints)
+        {
+            wwwrootFolderFiles.Should().Contain(endpoint.AssetFile);
+            foundAssets.Add(endpoint.AssetFile);
+        }
+
+        wwwrootFolderFiles.Should().BeEquivalentTo(foundAssets);
+
+        foreach (var file in wwwrootFolderFiles)
+        {
+            endpointsByAssetFile.Should().ContainKey(file);
+            if (file.EndsWith(".br") || file.EndsWith(".gz"))
+            {
+                endpointsByAssetFile[file].Should().HaveCount(2);
+            }
+            else
+            {
+                endpointsByAssetFile[file].Should().HaveCount(1);
+            }
+        }
+
+        HashSet<string> GetWwwrootFolderFiles(string outputDirectory)
+        {
+            if (!readFromDevManifest)
+            {
+                return new(Directory.GetFiles(Path.Combine(outputDirectory, "wwwroot"), "*", SearchOption.AllDirectories)
+                        .Select(a => StaticWebAsset.Normalize(Path.GetRelativePath(Path.Combine(outputDirectory, "wwwroot"), a))));
+            }
+            else
+            {
+                var staticWebAssetDevelopmentManifest = JsonSerializer.Deserialize<StaticWebAssetsDevelopmentManifest>(File.ReadAllText(Path.Combine(outputDirectory, $"{projectName}.staticwebassets.runtime.json")));
+                var endpoints = new HashSet<string>();
+
+                //Traverse the node tree and compute the paths for all assets
+                Traverse(staticWebAssetDevelopmentManifest.Root, "", endpoints);
+                return endpoints;
+            }
+        }
+    }
+
+    private static void Traverse(StaticWebAssetNode node, string pathSoFar, HashSet<string> endpoints)
+    {
+        if (node.Asset != null)
+        {
+            endpoints.Add(StaticWebAsset.Normalize(pathSoFar));
+        }
+        else
+        {
+            foreach (var child in node.Children)
+            {
+                Traverse(child.Value, Path.Combine(pathSoFar, child.Key), endpoints);
+            }
+        }
+    }
+
+    public class StaticWebAssetsDevelopmentManifest
+    {
+        public string[] ContentRoots { get; set; }
+
+        public StaticWebAssetNode Root { get; set; }
+    }
+
+    public class StaticWebAssetPattern
+    {
+        public int ContentRootIndex { get; set; }
+        public string Pattern { get; set; }
+        public int Depth { get; set; }
+    }
+
+    public class StaticWebAssetMatch
+    {
+        public int ContentRootIndex { get; set; }
+        public string SubPath { get; set; }
+    }
+
+    public class StaticWebAssetNode
+    {
+        public Dictionary<string, StaticWebAssetNode> Children { get; set; }
+        public StaticWebAssetMatch Asset { get; set; }
+        public StaticWebAssetPattern[] Patterns { get; set; }
+    }
 }