[Static web assets] Cherry-pick changes from preview7 and bump the SDK (#34819)

* Add new static web assets manifest

* Update global.json to a high enough SDK version

* Fix identity tests

* Skip flaky test

* Use regular pack process

* Update ViewImports casing

* Address feedback from Pranav and skip failing test on CI

* Bump SDK version

* Skip more incompatible tests on Helix

* Use Skip attribute

* Skip failing tests

Co-authored-by: John Luo <[email protected]>

global.json

@@ -1,9 +1,9 @@
 {
   "sdk": {
-    "version": "6.0.100-preview.7.21364.4"
+    "version": "6.0.100-rc.1.21376.4"
   },
   "tools": {
-    "dotnet": "6.0.100-preview.7.21364.4",
+    "dotnet": "6.0.100-rc.1.21376.4",
     "runtimes": {
       "dotnet/x64": [
         "2.1.27",

src/Components/WebAssembly/Authentication.Msal/src/Microsoft.Authentication.WebAssembly.Msal.csproj

@@ -24,10 +24,10 @@
 
   <PropertyGroup>
     <YarnWorkingDir>$(MSBuildThisFileDirectory)Interop\</YarnWorkingDir>
-    <ResolveCurrentProjectStaticWebAssetsInputsDependsOn>
+    <ResolveStaticWebAssetsInputsDependsOn>
       CompileInterop;
-      $(ResolveCurrentProjectStaticWebAssetsInputsDependsOn)
-    </ResolveCurrentProjectStaticWebAssetsInputsDependsOn>
+      $(ResolveStaticWebAssetsInputsDependsOn)
+    </ResolveStaticWebAssetsInputsDependsOn>
   </PropertyGroup>
 
   <ItemGroup>
@@ -69,11 +69,15 @@
       <_InteropBuildOutput Include="$(YarnWorkingDir)dist\$(Configuration)\**" Exclude="$(YarnWorkingDir)dist\.gitignore" />
 
       <StaticWebAsset Include="@(_InteropBuildOutput->'%(FullPath)')">
-        <SourceType></SourceType>
+        <SourceType>Computed</SourceType>
         <SourceId>$(PackageId)</SourceId>
         <ContentRoot>$([MSBuild]::NormalizeDirectory('$(YarnWorkingDir)\dist\$(Configuration)'))</ContentRoot>
         <BasePath>_content/$(PackageId)</BasePath>
         <RelativePath>$([System.String]::Copy('%(RecursiveDir)%(FileName)%(Extension)').Replace('\','/'))</RelativePath>
+        <AssetKind>All</AssetKind>
+        <AssetMode>All</AssetMode>
+        <AssetRole>Primary</AssetRole>
+        <OriginalItemSpec>@(_InteropBuildOutput->'%(Identity)'))</OriginalItemSpec>
       </StaticWebAsset>
 
       <FileWrites Include="$(_InteropBuildOutput)" />

src/Components/WebAssembly/DevServer/src/Server/Program.cs

@@ -28,7 +28,8 @@ namespace Microsoft.AspNetCore.Components.WebAssembly.DevServer.Server
                 {
                     var applicationPath = args.SkipWhile(a => a != "--applicationpath").Skip(1).First();
                     var applicationDirectory = Path.GetDirectoryName(applicationPath)!;
-                    var name = Path.ChangeExtension(applicationPath, ".StaticWebAssets.xml");
+                    var name = Path.ChangeExtension(applicationPath, ".staticwebassets.runtime.json");
+                    name = !File.Exists(name) ? Path.ChangeExtension(applicationPath, ".StaticWebAssets.xml") : name;
 
                     var inMemoryConfiguration = new Dictionary<string, string>
                     {

src/Components/WebAssembly/WebAssembly.Authentication/src/Microsoft.AspNetCore.Components.WebAssembly.Authentication.csproj

@@ -25,10 +25,10 @@
 
   <PropertyGroup>
     <YarnWorkingDir>$(MSBuildThisFileDirectory)Interop\</YarnWorkingDir>
-    <ResolveCurrentProjectStaticWebAssetsInputsDependsOn>
+    <ResolveStaticWebAssetsInputsDependsOn>
       CompileInterop;
-      $(ResolveCurrentProjectStaticWebAssetsInputsDependsOn)
-    </ResolveCurrentProjectStaticWebAssetsInputsDependsOn>
+      $(ResolveStaticWebAssetsInputsDependsOn)
+    </ResolveStaticWebAssetsInputsDependsOn>
   </PropertyGroup>
 
   <ItemGroup>
@@ -70,11 +70,15 @@
       <_InteropBuildOutput Include="$(YarnWorkingDir)dist\$(Configuration)\**" Exclude="$(YarnWorkingDir)dist\.gitignore" />
 
       <StaticWebAsset Include="@(_InteropBuildOutput->'%(FullPath)')">
-        <SourceType></SourceType>
+        <SourceType>Computed</SourceType>
         <SourceId>$(PackageId)</SourceId>
         <ContentRoot>$([MSBuild]::NormalizeDirectory('$(YarnWorkingDir)\dist\$(Configuration)'))</ContentRoot>
         <BasePath>_content/$(PackageId)</BasePath>
         <RelativePath>$([System.String]::Copy('%(RecursiveDir)%(FileName)%(Extension)').Replace('\','/'))</RelativePath>
+        <AssetKind>All</AssetKind>
+        <AssetMode>All</AssetMode>
+        <AssetRole>Primary</AssetRole>
+        <OriginalItemSpec>@(_InteropBuildOutput->'%(Identity)'))</OriginalItemSpec>
       </StaticWebAsset>
 
       <FileWrites Include="$(_InteropBuildOutput)" />

src/Components/test/E2ETest/Tests/ComponentRenderingTestBase.cs

@@ -319,7 +319,7 @@ namespace Microsoft.AspNetCore.Components.E2ETest.Tests
                 elem => Assert.Equal(typeof(AssemblyHashAlgorithm).FullName, elem.Text));
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/aspnetcore/issues/34679")]
         public void CanUseComponentAndStaticContentFromExternalNuGetPackage()
         {
             var appElement = Browser.MountTestComponent<ExternalContentPackage>();
@@ -702,7 +702,7 @@ namespace Microsoft.AspNetCore.Components.E2ETest.Tests
             });
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/aspnetcore/issues/34857")]
         public void CanHandleClearedChild()
         {
             var appElement = Browser.MountTestComponent<ContentEditable>();

src/Components/test/E2ETest/Tests/FormsTest.cs

@@ -736,7 +736,7 @@ namespace Microsoft.AspNetCore.Components.E2ETest.Tests
             Browser.Equal("modified invalid-socks", () => socksInput.GetAttribute("class"));
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/aspnetcore/issues/34857")]
         public void NavigateOnSubmitWorks()
         {
             var app = Browser.MountTestComponent<NavigateOnSubmit>();

src/Hosting/Hosting/src/StaticWebAssets/StaticWebAssetsFileProvider.cs

@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.FileSystemGlobbing;
 using Microsoft.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
@@ -158,4 +157,368 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
             }
         }
     }
+
+    internal sealed class ManifestStaticWebAssetFileProvider : IFileProvider
+    {
+        private static readonly StringComparison _fsComparison = OperatingSystem.IsWindows() ?
+            StringComparison.OrdinalIgnoreCase :
+            StringComparison.Ordinal;
+
+        private static readonly IEqualityComparer<IFileInfo> _nameComparer = new FileNameComparer();
+
+        private readonly IFileProvider[] _fileProviders;
+        private readonly StaticWebAssetNode _root;
+
+        public ManifestStaticWebAssetFileProvider(StaticWebAssetManifest manifest, Func<string, IFileProvider> fileProviderFactory)
+        {
+            _fileProviders = new IFileProvider[manifest.ContentRoots.Length];
+
+            for (int i = 0; i < manifest.ContentRoots.Length; i++)
+            {
+                _fileProviders[i] = fileProviderFactory(manifest.ContentRoots[i]);
+            }
+
+            _root = manifest.Root;
+        }
+
+        public IDirectoryContents GetDirectoryContents(string subpath)
+        {
+            if (subpath == null)
+            {
+                throw new ArgumentNullException(nameof(subpath));
+            }
+
+            var segments = Normalize(subpath).Split('/', StringSplitOptions.RemoveEmptyEntries);
+            var candidate = _root;
+
+            // Iterate over the path segments until we reach the destination. Whenever we encounter
+            // a pattern, we start tracking it as well as the content root directory. On every segment
+            // we evalutate the directory to see if there is a subfolder with the current segment and
+            // replace it on the dictionary if it exists or remove it if it does not.
+            // When we reach our destination we enumerate the files in that folder and evalute them against
+            // the pattern to compute the final list.
+            HashSet<IFileInfo>? files = null;
+            for (var i = 0; i < segments.Length; i++)
+            {
+                files = GetFilesForCandidatePatterns(segments, candidate, files);
+
+                if (candidate.HasChildren() && candidate.Children.TryGetValue(segments[i], out var child))
+                {
+                    candidate = child;
+                }
+                else
+                {
+                    candidate = null;
+                    break;
+                }
+            }
+
+            if ((candidate == null || (!candidate.HasChildren() && !candidate.HasPatterns())) && files == null)
+            {
+                return NotFoundDirectoryContents.Singleton;
+            }
+            else
+            {
+                // We do this to make sure we account for the patterns on the last segment which are not covered by the loop above
+                files = GetFilesForCandidatePatterns(segments, candidate, files);
+                if (candidate != null && candidate.HasChildren())
+                {
+                    files ??= new(_nameComparer);
+                    GetCandidateFilesForNode(candidate, files);
+                }
+
+                return new StaticWebAssetsDirectoryContents((files as IEnumerable<IFileInfo>) ?? Array.Empty<IFileInfo>());
+            }
+
+            HashSet<IFileInfo>? GetFilesForCandidatePatterns(string[] segments, StaticWebAssetNode? candidate, HashSet<IFileInfo>? files)
+            {
+                if (candidate != null && candidate.HasPatterns())
+                {
+                    var depth = candidate.Patterns[0].Depth;
+                    var candidateDirectoryPath = string.Join('/', segments[depth..]);
+                    foreach (var pattern in candidate.Patterns)
+                    {
+                        var contentRoot = _fileProviders[pattern.ContentRoot];
+                        var matcher = new Matcher(_fsComparison);
+                        matcher.AddInclude(pattern.Pattern);
+                        foreach (var result in contentRoot.GetDirectoryContents(candidateDirectoryPath))
+                        {
+                            var fileCandidate = string.IsNullOrEmpty(candidateDirectoryPath) ? result.Name : $"{candidateDirectoryPath}/{result.Name}";
+                            if (result.Exists && (result.IsDirectory || matcher.Match(fileCandidate).HasMatches))
+                            {
+                                files ??= new(_nameComparer);
+                                if (!files.Contains(result))
+                                {
+                                    // Multiple patterns might match the same file (even at different locations on disk) at runtime. We don't
+                                    // try to disambiguate anything here, since there is already a build step for it. We just pick the first
+                                    // file that matches the pattern. The manifest entries are ordered, so while this choice is random, it is
+                                    // nonetheless deterministic.
+                                    files.Add(result);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return files;
+            }
+
+            void GetCandidateFilesForNode(StaticWebAssetNode candidate, HashSet<IFileInfo> files)
+            {
+                foreach (var child in candidate.Children!)
+                {
+                    var match = child.Value.Match;
+                    if (match == null)
+                    {
+                        // This is a folder
+                        var file = new StaticWebAssetsDirectoryInfo(child.Key);
+                        // Entries from the manifest always win over any content based on patterns,
+                        // so remove any potentially existing file or folder in favor of the manifest
+                        // entry.
+                        files.Remove(file);
+                        files.Add(file);
+                    }
+                    else
+                    {
+                        // This is a file.
+                        files.RemoveWhere(f => string.Equals(match.Path, f.Name, _fsComparison));
+                        var file = _fileProviders[match.ContentRoot].GetFileInfo(match.Path);
+
+                        files.Add(string.Equals(child.Key, match.Path, _fsComparison) ? file :
+                            // This means that this file was mapped, there is a chance that we added it to the list
+                            // of files by one of the patterns, so we need to replace it with the mapped file.
+                            new StaticWebAssetsFileInfo(child.Key, file));
+                    }
+                }
+            }
+        }
+
+        private string Normalize(string path)
+        {
+            return path.Replace('\\', '/');
+        }
+
+        public IFileInfo GetFileInfo(string subpath)
+        {
+            if (subpath == null)
+            {
+                throw new ArgumentNullException(nameof(subpath));
+            }
+
+            var segments = subpath.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            StaticWebAssetNode? candidate = _root;
+            List<StaticWebAssetPattern>? patterns = null;
+
+            // Iterate over the path segments until we reach the destination, collecting
+            // all pattern candidates along the way except for any pattern at the root.
+            for (var i = 0; i < segments.Length; i++)
+            {
+                if (candidate.HasPatterns())
+                {
+                    patterns ??= new();
+                    patterns.AddRange(candidate.Patterns);
+                }
+                if (candidate.HasChildren() && candidate.Children.TryGetValue(segments[i], out var child))
+                {
+                    candidate = child;
+                }
+                else
+                {
+                    candidate = null;
+                    break;
+                }
+            }
+
+            var match = candidate?.Match;
+            if (match != null)
+            {
+                // If we found a file, that wins over anything else. If there are conflicts with files added after
+                // we've built the manifest, we'll be notified the next time we do a build. This is not different
+                // from previous Static Web Assets versions.
+                var file = _fileProviders[match.ContentRoot].GetFileInfo(match.Path);
+                if (!file.Exists || string.Equals(subpath, Normalize(match.Path), _fsComparison))
+                {
+                    return file;
+                }
+                else
+                {
+                    return new StaticWebAssetsFileInfo(segments[^1], file);
+                }
+            }
+
+            // The list of patterns is ordered by pattern depth, so we compute the string to check for patterns only
+            // once per level. We don't aim to solve conflicts here where multiple files could match a given path,
+            // we have a build check that takes care of that.
+            var currentDepth = 0;
+            var candidatePath = subpath;
+
+            if (patterns != null)
+            {
+                for (var i = 0; i < patterns.Count; i++)
+                {
+                    var pattern = patterns[i];
+                    if (pattern.Depth != currentDepth)
+                    {
+                        currentDepth = pattern.Depth;
+                        candidatePath = string.Join('/', segments[currentDepth..]);
+                    }
+
+                    var result = _fileProviders[pattern.ContentRoot].GetFileInfo(candidatePath);
+                    if (result.Exists)
+                    {
+                        if (!result.IsDirectory)
+                        {
+                            var matcher = new Matcher();
+                            matcher.AddInclude(pattern.Pattern);
+                            if (!matcher.Match(candidatePath).HasMatches)
+                            {
+                                continue;
+                            }
+
+                            return result;
+                        }
+                    }
+                }
+            }
+
+            return new NotFoundFileInfo(subpath);
+        }
+
+        public IChangeToken Watch(string filter) => NullChangeToken.Singleton;
+
+        private sealed class StaticWebAssetsDirectoryContents : IDirectoryContents
+        {
+            private readonly IEnumerable<IFileInfo> _files;
+
+            public StaticWebAssetsDirectoryContents(IEnumerable<IFileInfo> files) =>
+                _files = files;
+
+            public bool Exists => true;
+
+            public IEnumerator<IFileInfo> GetEnumerator() => _files.GetEnumerator();
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        private sealed class StaticWebAssetsDirectoryInfo : IFileInfo
+        {
+            private static readonly DateTimeOffset _lastModified = DateTimeOffset.FromUnixTimeSeconds(0);
+
+            public StaticWebAssetsDirectoryInfo(string name)
+            {
+                Name = name;
+            }
+
+            public bool Exists => true;
+
+            public long Length => 0;
+
+            public string? PhysicalPath => null;
+
+            public DateTimeOffset LastModified => _lastModified;
+
+            public bool IsDirectory => true;
+
+            public string Name { get; }
+
+            public Stream CreateReadStream() => throw new InvalidOperationException("Can not create a stream for a directory.");
+        }
+
+        private sealed class StaticWebAssetsFileInfo : IFileInfo
+        {
+            private readonly IFileInfo _source;
+
+            public StaticWebAssetsFileInfo(string name, IFileInfo source)
+            {
+                Name = name;
+                _source = source;
+            }
+            public bool Exists => _source.Exists;
+
+            public long Length => _source.Length;
+
+            public string PhysicalPath => _source.PhysicalPath;
+
+            public DateTimeOffset LastModified => _source.LastModified;
+
+            public bool IsDirectory => _source.IsDirectory;
+
+            public string Name { get; }
+
+            public Stream CreateReadStream() => _source.CreateReadStream();
+        }
+
+        private sealed class FileNameComparer : IEqualityComparer<IFileInfo>
+        {
+            public bool Equals(IFileInfo? x, IFileInfo? y) => string.Equals(x?.Name, y?.Name, _fsComparison);
+
+            public int GetHashCode(IFileInfo obj) => obj.Name.GetHashCode(_fsComparison);
+        }
+
+        internal sealed class StaticWebAssetManifest
+        {
+            internal static readonly StringComparer PathComparer =
+                OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+
+            public string[] ContentRoots { get; set; } = Array.Empty<string>();
+
+            public StaticWebAssetNode Root { get; set; } = null!;
+
+            internal static StaticWebAssetManifest Parse(Stream manifest)
+            {
+                return JsonSerializer.Deserialize<StaticWebAssetManifest>(manifest)!;
+            }
+        }
+
+        internal sealed class StaticWebAssetNode
+        {
+            [JsonPropertyName("Asset")]
+            public StaticWebAssetMatch? Match { get; set; }
+
+            [JsonConverter(typeof(OSBasedCaseConverter))]
+            public Dictionary<string, StaticWebAssetNode>? Children { get; set; }
+
+            public StaticWebAssetPattern[]? Patterns { get; set; }
+
+            [MemberNotNullWhen(true, nameof(Children))]
+            internal bool HasChildren() => Children != null && Children.Count > 0;
+
+            [MemberNotNullWhen(true, nameof(Patterns))]
+            internal bool HasPatterns() => Patterns != null && Patterns.Length > 0;
+        }
+
+        internal sealed class StaticWebAssetMatch
+        {
+            [JsonPropertyName("ContentRootIndex")]
+            public int ContentRoot { get; set; }
+
+            [JsonPropertyName("SubPath")]
+            public string Path { get; set; } = null!;
+        }
+
+        internal sealed class StaticWebAssetPattern
+        {
+            [JsonPropertyName("ContentRootIndex")]
+            public int ContentRoot { get; set; }
+
+            public int Depth { get; set; }
+
+            public string Pattern { get; set; } = null!;
+        }
+
+        private sealed class OSBasedCaseConverter : JsonConverter<Dictionary<string, StaticWebAssetNode>>
+        {
+            public override Dictionary<string, StaticWebAssetNode> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                return new Dictionary<string, StaticWebAssetNode>(
+                    JsonSerializer.Deserialize<IDictionary<string, StaticWebAssetNode>>(ref reader, options)!,
+                    StaticWebAssetManifest.PathComparer);
+            }
+
+            public override void Write(Utf8JsonWriter writer, Dictionary<string, StaticWebAssetNode> value, JsonSerializerOptions options)
+            {
+                JsonSerializer.Serialize(writer, value, options);
+            }
+        }
+    }
 }

src/Hosting/Hosting/src/StaticWebAssets/StaticWebAssetsLoader.cs

@@ -25,15 +25,29 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
         /// <param name="configuration">The host <see cref="IConfiguration"/>.</param>
         public static void UseStaticWebAssets(IWebHostEnvironment environment, IConfiguration configuration)
         {
-            using var manifest = ResolveManifest(environment, configuration);
-            if (manifest != null)
+            var (manifest, isJson) = ResolveManifest(environment, configuration);
+            using (manifest)
             {
-                UseStaticWebAssetsCore(environment, manifest);
+                if (manifest != null)
+                {
+                    UseStaticWebAssetsCore(environment, manifest, isJson);
+                }
             }
         }
 
-        internal static void UseStaticWebAssetsCore(IWebHostEnvironment environment, Stream manifest)
+        internal static void UseStaticWebAssetsCore(IWebHostEnvironment environment, Stream manifest, bool isJson)
         {
+            if (isJson)
+            {
+                var staticWebAssetManifest = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.Parse(manifest);
+                var provider = new ManifestStaticWebAssetFileProvider(
+                    staticWebAssetManifest,
+                    (contentRoot) => new PhysicalFileProvider(contentRoot));
+
+                environment.WebRootFileProvider = new CompositeFileProvider(new[] { environment.WebRootFileProvider, provider });
+                return;
+            }
+
             var webRootFileProvider = environment.WebRootFileProvider;
 
             var additionalFiles = StaticWebAssetsReader.Parse(manifest)
@@ -52,40 +66,39 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
             }
         }
 
-        internal static Stream? ResolveManifest(IWebHostEnvironment environment, IConfiguration configuration)
+        internal static (Stream, bool) ResolveManifest(IWebHostEnvironment environment, IConfiguration configuration)
         {
             try
             {
                 var manifestPath = configuration.GetValue<string>(WebHostDefaults.StaticWebAssetsKey);
-                var filePath = manifestPath ?? ResolveRelativeToAssembly(environment);
+                var isJson = manifestPath != null && Path.GetExtension(manifestPath).EndsWith(".json", OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+                var candidates = manifestPath != null ? new[] { (manifestPath, isJson) } : ResolveRelativeToAssembly(environment);
 
-                if (filePath != null && File.Exists(filePath))
+                foreach (var (candidate, json) in candidates)
                 {
-                    return File.OpenRead(filePath);
-                }
-                else
-                {
-                    // A missing manifest might simply mean that the feature is not enabled, so we simply
-                    // return early. Misconfigurations will be uncommon given that the entire process is automated
-                    // at build time.
-                    return null;
+                    if (candidate != null && File.Exists(candidate))
+                    {
+                        return (File.OpenRead(candidate), json);
+                    }
                 }
+
+                // A missing manifest might simply mean that the feature is not enabled, so we simply
+                // return early. Misconfigurations will be uncommon given that the entire process is automated
+                // at build time.
+                return default;
             }
             catch
             {
-                return null;
+                return default;
             }
         }
 
-        private static string? ResolveRelativeToAssembly(IWebHostEnvironment environment)
+        private static IEnumerable<(string candidatePath, bool isJson)> ResolveRelativeToAssembly(IWebHostEnvironment environment)
         {
             var assembly = Assembly.Load(environment.ApplicationName);
-            if (string.IsNullOrEmpty(assembly.Location))
-            {
-                return null;
-            }
-
-            return Path.Combine(Path.GetDirectoryName(assembly.Location)!, $"{environment.ApplicationName}.StaticWebAssets.xml");
+            var basePath = string.IsNullOrEmpty(assembly.Location) ? AppContext.BaseDirectory : Path.GetDirectoryName(assembly.Location);
+            yield return (Path.Combine(basePath!, $"{environment.ApplicationName}.staticwebassets.runtime.json"), isJson: true);
+            yield return (Path.Combine(basePath!, $"{environment.ApplicationName}.StaticWebAssets.xml"), isJson: false);
         }
     }
 }

src/Hosting/Hosting/test/StaticWebAssets/ManifestStaticWebAssetsFileProviderTests.cs

@@ -0,0 +1,514 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting.StaticWebAssets;
+using Microsoft.Extensions.FileProviders;
+using Moq;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Hosting.Tests.StaticWebAssets
+{
+    public class ManifestStaticWebAssetsFileProviderTest
+    {
+        [Fact]
+        public void GetFileInfoPrefixRespectsOsCaseSensitivity()
+        {
+            // Arrange
+            var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;
+            var expectedResult = OperatingSystem.IsWindows();
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new[] { Path.GetDirectoryName(typeof(StaticWebAssetsFileProviderTests).Assembly.Location) };
+            manifest.Root = new()
+            {
+                Children = new(comparer)
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new(comparer)
+                        {
+                            ["Microsoft.AspNetCore.Hosting.StaticWebAssets.xml"] = new()
+                            {
+                                Match = new()
+                                {
+                                    ContentRoot = 0,
+                                    Path = "Microsoft.AspNetCore.Hosting.StaticWebAssets.xml"
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var provider = new ManifestStaticWebAssetFileProvider(
+                manifest,
+                contentRoot => new PhysicalFileProvider(contentRoot));
+
+            // Act
+            var file = provider.GetFileInfo("/_CONTENT/Microsoft.AspNetCore.Hosting.StaticWebAssets.xml");
+
+            // Assert
+            Assert.Equal(expectedResult, file.Exists);
+        }
+
+        [Fact]
+        public void CanFindFileListedOnTheManifest()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var file = fileProvider.GetFileInfo("_content/RazorClassLibrary/file.version.js");
+
+            // Assert
+            Assert.NotNull(file);
+            Assert.True(file.Exists);
+            Assert.Equal("file.version.js", file.Name);
+        }
+
+        [Fact]
+        public void GetFileInfoHandlesRootCorrectly()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var file = fileProvider.GetFileInfo("");
+
+            // Assert
+            Assert.NotNull(file);
+            Assert.False(file.Exists);
+            Assert.False(file.IsDirectory);
+            Assert.Equal("", file.Name);
+        }
+
+        [Fact]
+        public void CanFindFileMatchingPattern()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var file = fileProvider.GetFileInfo("_content/RazorClassLibrary/js/project-transitive-dep.js");
+
+            // Assert
+            Assert.NotNull(file);
+            Assert.True(file.Exists);
+            Assert.Equal("project-transitive-dep.js", file.Name);
+        }
+
+        [Fact]
+        public void CanFindFileWithSpaces()
+        {
+            // Arrange
+            var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;
+            var expectedResult = OperatingSystem.IsWindows();
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new[] { Path.Combine(AppContext.BaseDirectory, "testroot", "wwwroot") };
+            manifest.Root = new()
+            {
+                Children = new(comparer)
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new(comparer)
+                        {
+                            ["Static Web Assets.txt"] = new()
+                            {
+                                Match = new()
+                                {
+                                    ContentRoot = 0,
+                                    Path = "Static Web Assets.txt"
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var provider = new ManifestStaticWebAssetFileProvider(manifest, root => new PhysicalFileProvider(root));
+
+            // Assert
+            Assert.True(provider.GetFileInfo("/_content/Static Web Assets.txt").Exists);
+        }
+
+        [Fact]
+        public void IgnoresFilesThatDontMatchThePattern()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var file = fileProvider.GetFileInfo("_content/RazorClassLibrary/styles.css");
+
+            // Assert
+            Assert.NotNull(file);
+            Assert.False(file.Exists);
+        }
+
+        [Fact]
+        public void ReturnsNotFoundFileWhenNoPatternAndNoEntryMatchPatch()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var file = fileProvider.GetFileInfo("_content/RazorClassLibrary/different");
+
+            // Assert
+            Assert.NotNull(file);
+            Assert.False(file.IsDirectory);
+            Assert.False(file.Exists);
+        }
+
+        [Fact]
+        public void GetDirectoryContentsHandlesRootCorrectly()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var contents = fileProvider.GetDirectoryContents("");
+
+            // Assert
+            Assert.NotNull(contents);
+            Assert.Equal(new[] { (true, "_content") }, contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray());
+        }
+
+        [Fact]
+        public void GetDirectoryContentsReturnsNonExistingDirectoryWhenDirectoryDoesNotExist()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var contents = fileProvider.GetDirectoryContents("_content/NonExisting");
+
+            // Assert
+            Assert.NotNull(contents);
+            Assert.False(contents.Exists);
+        }
+
+        [Fact]
+        public void GetDirectoryContentsListsEntriesBasedOnManifest()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var contents = fileProvider.GetDirectoryContents("_content");
+
+            // Assert
+            Assert.NotNull(contents);
+            Assert.Equal(new[]{
+                (true, "AnotherClassLibrary"),
+                (true, "RazorClassLibrary") },
+                contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray());
+        }
+
+        [Fact]
+        public void GetDirectoryContentsListsEntriesBasedOnPatterns()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var contents = fileProvider.GetDirectoryContents("_content/RazorClassLibrary/js");
+
+            // Assert
+            Assert.NotNull(contents);
+            Assert.Equal(new[]{
+                (false, "project-transitive-dep.js"),
+                (false, "project-transitive-dep.v4.js") },
+                contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray());
+        }
+
+        [Theory]
+        [InlineData("\\", "_content")]
+        [InlineData("\\_content\\RazorClassLib\\Dir", "Castle.Core.dll")]
+        [InlineData("", "_content")]
+        [InlineData("/", "_content")]
+        [InlineData("/_content", "RazorClassLib")]
+        [InlineData("/_content/RazorClassLib", "Dir")]
+        [InlineData("/_content/RazorClassLib/Dir", "Microsoft.AspNetCore.Hosting.Tests.dll")]
+        [InlineData("/_content/RazorClassLib/Dir/testroot/", "TextFile.txt")]
+        [InlineData("/_content/RazorClassLib/Dir/testroot/wwwroot/", "README")]
+        public void GetDirectoryContentsWalksUpContentRoot(string searchDir, string expected)
+        {
+            // Arrange
+            var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;
+            var expectedResult = OperatingSystem.IsWindows();
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new[] { AppContext.BaseDirectory };
+            manifest.Root = new()
+            {
+                Children = new(comparer)
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new(comparer)
+                        {
+                            ["RazorClassLib"] = new()
+                            {
+                                Children = new(comparer)
+                                {
+                                    ["Dir"] = new()
+                                    {
+                                        Patterns = new ManifestStaticWebAssetFileProvider.StaticWebAssetPattern[]
+                                        {
+                                            new()
+                                            {
+                                                Pattern = "**",
+                                                ContentRoot = 0,
+                                                Depth = 3,
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var provider = new ManifestStaticWebAssetFileProvider(manifest, root => new PhysicalFileProvider(root));
+
+            // Act
+            var directory = provider.GetDirectoryContents(searchDir);
+
+            // Assert
+            Assert.NotEmpty(directory);
+            Assert.Contains(directory, file => string.Equals(file.Name, expected));
+        }
+
+        [Theory]
+        [InlineData("/_content/RazorClass")]
+        public void GetDirectoryContents_PartialMatchFails(string requestedUrl)
+        {
+            // Arrange
+            var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;
+            var expectedResult = OperatingSystem.IsWindows();
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new[] { AppContext.BaseDirectory };
+            manifest.Root = new()
+            {
+                Children = new(comparer)
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new(comparer)
+                        {
+                            ["RazorClassLib"] = new()
+                            {
+                                Children = new(comparer)
+                                {
+                                    ["Dir"] = new()
+                                    {
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var provider = new ManifestStaticWebAssetFileProvider(manifest, root => new PhysicalFileProvider(root));
+
+            // Act
+            var directory = provider.GetDirectoryContents(requestedUrl);
+
+            // Assert
+            Assert.Empty(directory);
+        }
+
+        [Fact]
+        public void CombinesContentsFromManifestAndPatterns()
+        {
+            var (manifest, factory) = CreateTestManifest();
+
+            var fileProvider = new ManifestStaticWebAssetFileProvider(manifest, factory);
+
+            // Act
+            var contents = fileProvider.GetDirectoryContents("_content/RazorClassLibrary");
+
+            // Assert
+            Assert.NotNull(contents);
+            Assert.Equal(new[]{
+                (false, "file.version.js"),
+                (true, "js") },
+                contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray());
+        }
+
+        [Fact]
+        public void GetDirectoryContentsPrefixRespectsOsCaseSensitivity()
+        {
+            // Arrange
+            var comparer = ManifestStaticWebAssetFileProvider.StaticWebAssetManifest.PathComparer;
+            var expectedResult = OperatingSystem.IsWindows();
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new[] { Path.GetDirectoryName(typeof(StaticWebAssetsFileProviderTests).Assembly.Location) };
+            manifest.Root = new()
+            {
+                Children = new(comparer)
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new(comparer)
+                        {
+                            ["Microsoft.AspNetCore.Hosting.StaticWebAssets.xml"] = new()
+                            {
+                                Match = new()
+                                {
+                                    ContentRoot = 0,
+                                    Path = "Microsoft.AspNetCore.Hosting.StaticWebAssets.xml"
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            var provider = new ManifestStaticWebAssetFileProvider(
+                manifest,
+                contentRoot => new PhysicalFileProvider(contentRoot));
+
+            // Act
+            var directory = provider.GetDirectoryContents("/_CONTENT/");
+
+            // Assert
+            Assert.Equal(expectedResult, directory.Exists);
+        }
+
+        private static (ManifestStaticWebAssetFileProvider.StaticWebAssetManifest manifest, Func<string, IFileProvider> factory) CreateTestManifest()
+        {
+            // Arrange
+            var manifest = new ManifestStaticWebAssetFileProvider.StaticWebAssetManifest();
+            manifest.ContentRoots = new string[2] {
+                "Cero",
+                "Uno"
+            };
+            Func<string, IFileProvider> factory = (string contentRoot) =>
+            {
+                if (contentRoot == "Cero")
+                {
+                    var styles = new TestFileInfo { Exists = true, IsDirectory = false, Name = "styles.css" };
+                    var js = new TestFileInfo { Exists = true, IsDirectory = true, Name = "js" };
+                    var file = new TestFileInfo { Exists = true, Name = "file.js", IsDirectory = false };
+                    var transitiveDep = new TestFileInfo { Exists = true, IsDirectory = false, Name = "project-transitive-dep.js" };
+                    var transitiveDepV4 = new TestFileInfo { Exists = true, IsDirectory = false, Name = "project-transitive-dep.v4.js" };
+                    var providerMock = new Mock<IFileProvider>();
+                    providerMock.Setup(p => p.GetDirectoryContents("")).Returns(new TestDirectoryContents(new[] { styles, js }));
+                    providerMock.Setup(p => p.GetDirectoryContents("js")).Returns(new TestDirectoryContents(new[]
+                    {
+                        transitiveDep,
+                        transitiveDepV4
+                    }));
+                    providerMock.Setup(p => p.GetFileInfo("different")).Returns(new NotFoundFileInfo("different"));
+                    providerMock.Setup(p => p.GetFileInfo("file.js")).Returns(file);
+                    providerMock.Setup(p => p.GetFileInfo("js")).Returns(js);
+                    providerMock.Setup(p => p.GetFileInfo("styles.css")).Returns(styles);
+                    providerMock.Setup(p => p.GetFileInfo("js/project-transitive-dep.js")).Returns(transitiveDep);
+                    providerMock.Setup(p => p.GetFileInfo("js/project-transitive-dep.v4.js")).Returns(transitiveDepV4);
+
+                    return providerMock.Object;
+                }
+                if (contentRoot == "Uno")
+                {
+                    var css = new TestFileInfo { Exists = true, IsDirectory = true, Name = "css" };
+                    var site = new TestFileInfo { Exists = true, IsDirectory = false, Name = "site.css" };
+                    var js = new TestFileInfo { Exists = true, IsDirectory = true, Name = "js" };
+                    var projectDirectDep = new TestFileInfo { Exists = true, IsDirectory = false, Name = "project-direct-dep.js" };
+                    var providerMock = new Mock<IFileProvider>();
+                    providerMock.Setup(p => p.GetDirectoryContents("")).Returns(new TestDirectoryContents(new[] { css, js }));
+                    providerMock.Setup(p => p.GetDirectoryContents("js")).Returns(new TestDirectoryContents(new[]
+                    {
+                        projectDirectDep
+                    }));
+                    providerMock.Setup(p => p.GetDirectoryContents("css")).Returns(new TestDirectoryContents(new[]
+                    {
+                        site
+                    }));
+
+                    providerMock.Setup(p => p.GetFileInfo("js")).Returns(js);
+                    providerMock.Setup(p => p.GetFileInfo("css")).Returns(css);
+                    providerMock.Setup(p => p.GetFileInfo("css/site.css")).Returns(site);
+                    providerMock.Setup(p => p.GetFileInfo("js/project-direct-dep.js")).Returns(projectDirectDep);
+
+                    return providerMock.Object;
+                }
+
+                throw new InvalidOperationException("Invalid content root");
+            };
+            manifest.Root = new()
+            {
+                Children = new()
+                {
+                    ["_content"] = new()
+                    {
+                        Children = new()
+                        {
+                            ["RazorClassLibrary"] = new()
+                            {
+                                Children = new() { ["file.version.js"] = new() { Match = new() { ContentRoot = 0, Path = "file.js" } } },
+                                Patterns = new ManifestStaticWebAssetFileProvider.StaticWebAssetPattern[] { new() { ContentRoot = 0, Depth = 2, Pattern = "**/*.js" } },
+                            },
+                            ["AnotherClassLibrary"] = new()
+                            {
+                                Patterns = new ManifestStaticWebAssetFileProvider.StaticWebAssetPattern[] { new() { ContentRoot = 1, Depth = 2, Pattern = "**" } }
+                            }
+                        }
+                    }
+                }
+            };
+
+            return (manifest, factory);
+        }
+    }
+
+    internal class TestFileInfo : IFileInfo
+    {
+        public bool Exists { get; set; }
+
+        public long Length { get; set; }
+
+        public string PhysicalPath { get; set; }
+
+        public string Name { get; set; }
+
+        public DateTimeOffset LastModified { get; set; }
+
+        public bool IsDirectory { get; set; }
+
+        public Stream CreateReadStream() => Stream.Null;
+    }
+
+    internal class TestDirectoryContents : IDirectoryContents
+    {
+        private readonly IEnumerable<IFileInfo> _contents;
+
+        public TestDirectoryContents(IEnumerable<IFileInfo> contents)
+        {
+            _contents = contents;
+        }
+
+        public bool Exists { get; set; }
+
+        public IEnumerator<IFileInfo> GetEnumerator() => _contents.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}

src/Hosting/Hosting/test/StaticWebAssets/StaticWebAssetsLoaderTests.cs

@@ -31,7 +31,7 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
             };
 
             // Act
-            StaticWebAssetsLoader.UseStaticWebAssetsCore(environment, manifest);
+            StaticWebAssetsLoader.UseStaticWebAssetsCore(environment, manifest, false);
 
             // Assert
             var composite = Assert.IsType<CompositeFileProvider>(environment.WebRootFileProvider);
@@ -54,7 +54,7 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
             };
 
             // Act
-            StaticWebAssetsLoader.UseStaticWebAssetsCore(environment, manifest);
+            StaticWebAssetsLoader.UseStaticWebAssetsCore(environment, manifest, false);
 
             // Assert
             Assert.Equal(originalRoot, environment.WebRootFileProvider);
@@ -75,7 +75,7 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
             };
 
             // Act
-            var manifest = StaticWebAssetsLoader.ResolveManifest(environment, new ConfigurationBuilder().Build());
+            var (manifest,_) = StaticWebAssetsLoader.ResolveManifest(environment, new ConfigurationBuilder().Build());
 
             // Assert
             Assert.Equal(expectedManifest, new StreamReader(manifest).ReadToEnd());
@@ -101,7 +101,7 @@ namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
                 }).Build();
 
             // Act
-            var manifest = StaticWebAssetsLoader.ResolveManifest(environment, configuration);
+            var (manifest,_) = StaticWebAssetsLoader.ResolveManifest(environment, configuration);
 
             // Assert
             Assert.Equal(expectedManifest, new StreamReader(manifest).ReadToEnd());

src/Hosting/Hosting/test/StaticWebAssets/StaticWebAssetsReaderTests.cs

@@ -1,147 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Xml;
-using Xunit;
-
-namespace Microsoft.AspNetCore.Hosting.StaticWebAssets
-{
-    public class StaticWebAssetsReaderTests
-    {
-        [Fact]
-        public void ParseManifest_ThrowsFor_EmptyManifest()
-        {
-            // Arrange
-            var manifestContent = @"";
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<XmlException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Root element is missing.", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_UnknownRootElement()
-        {
-            // Arrange
-            var manifestContent = @"<Invalid />";
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_MissingVersion()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets />";
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_UnknownVersion()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""2.0""/>";
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Unknown manifest version", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_InvalidStaticWebAssetsChildren()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""1.0"">
-    <Invalid />
-</StaticWebAssets>";
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_MissingBasePath()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""1.0"">
-    <ContentRoot Path=""/Path"" />
-</StaticWebAssets>";
-
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_MissingPath()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""1.0"">
-    <ContentRoot BasePath=""/BasePath"" />
-</StaticWebAssets>";
-
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ThrowsFor_ChildContentRootContent()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""1.0"">
-    <ContentRoot Path=""/Path"" BasePath=""/BasePath"">
-    </ContentRoot>
-</StaticWebAssets>";
-
-            var manifest = CreateManifest(manifestContent);
-
-            // Act & Assert
-            var exception = Assert.Throws<InvalidOperationException>(() => StaticWebAssetsReader.Parse(manifest).ToArray());
-            Assert.StartsWith("Invalid manifest", exception.Message);
-        }
-
-        [Fact]
-        public void ParseManifest_ParsesManifest_WithSingleItem()
-        {
-            // Arrange
-            var manifestContent = @"<StaticWebAssets Version=""1.0"">
-    <ContentRoot Path=""/Path"" BasePath=""/BasePath"" />
-</StaticWebAssets>";
-
-            var manifest = CreateManifest(manifestContent);
-
-            // Act
-            var mappings = StaticWebAssetsReader.Parse(manifest).ToArray();
-
-            // Assert
-            var mapping = Assert.Single(mappings);
-            Assert.Equal("/Path", mapping.Path);
-            Assert.Equal("/BasePath", mapping.BasePath);
-        }
-
-        private Stream CreateManifest(string manifestContent)
-        {
-            return new MemoryStream(Encoding.UTF8.GetBytes(manifestContent));
-        }
-    }
-}

src/Identity/UI/src/Microsoft.AspNetCore.Identity.UI.csproj

@@ -8,15 +8,7 @@
     <PackageTags>aspnetcore;identity;membership;razorpages</PackageTags>
     <EnableDefaultRazorGenerateItems>false</EnableDefaultRazorGenerateItems>
     <AddRazorSupportForMvc>true</AddRazorSupportForMvc>
-
-    <DisableStaticWebAssetsBuildPropsFileGeneration>true</DisableStaticWebAssetsBuildPropsFileGeneration>
-    <StaticWebAssetsDisableProjectBuildPropsFileGeneration>true</StaticWebAssetsDisableProjectBuildPropsFileGeneration>
-
-    <GetCurrentProjectStaticWebAssetsDependsOn>
-      $(GetCurrentProjectStaticWebAssetsDependsOn);
-      _UpdatedIdentityUIStaticWebAssets
-    </GetCurrentProjectStaticWebAssetsDependsOn>
-
+    <StaticWebAssetBasePath>Identity</StaticWebAssetBasePath>
     <PackageThirdPartyNoticesFile>$(MSBuildThisFileDirectory)THIRD-PARTY-NOTICES.TXT</PackageThirdPartyNoticesFile>
     <Nullable>disable</Nullable>
   </PropertyGroup>
@@ -24,9 +16,6 @@
   <ItemGroup>
     <Content Remove="@(Content)" />
     <Content Include="wwwroot\**\*" Pack="true" />
-    <None Include="build\*" Pack="true" PackagePath="build\" />
-    <None Include="buildMultiTargeting\*" Pack="true" PackagePath="buildMultiTargeting\" />
-    <None Include="buildTransitive\*" Pack="true" PackagePath="buildTransitive\" />
   </ItemGroup>
 
   <ItemGroup>
@@ -45,22 +34,4 @@
     </ItemGroup>
   </Target>
 
-  <Target Name="_UpdatedIdentityUIStaticWebAssets">
-
-    <ItemGroup>
-      <StaticWebAsset Remove="@(StaticWebAsset)" />
-
-      <_V4Content Include="wwwroot\V4\**" />
-
-      <StaticWebAsset Include="@(_V4Content->'%(FullPath)')">
-        <SourceType></SourceType>
-        <SourceId>Microsoft.AspNetCore.Identity.UI</SourceId>
-        <ContentRoot>$([MSBuild]::NormalizePath('$(MSBuildThisFileDirectory)wwwroot/V4'))</ContentRoot>
-        <BasePath>/Identity</BasePath>
-        <RelativePath>%(RecursiveDir)%(FileName)%(Extension)</RelativePath>
-      </StaticWebAsset>
-    </ItemGroup>
-
-  </Target>
-
 </Project>

src/Identity/UI/src/build/Microsoft.AspNetCore.Identity.UI.props

@@ -1,21 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <IdentityUIFrameworkVersion Condition="'$(IdentityUIFrameworkVersion)' == ''">Bootstrap4</IdentityUIFrameworkVersion>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <AssemblyAttribute Include="Microsoft.AspNetCore.Identity.UI.UIFrameworkAttribute">
-      <_Parameter1>$(IdentityUIFrameworkVersion)</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(IdentityUIFrameworkVersion)' == 'Bootstrap4'">
-    <StaticWebAsset Include="$(MSBuildThisFileDirectory)..\staticwebassets\V4\**">
-      <SourceType>Package</SourceType>
-      <SourceId>Microsoft.AspNetCore.Identity.UI</SourceId>
-      <ContentRoot>$([MSBuild]::NormalizePath('$(MSBuildThisFileDirectory)..\staticwebassets\V4'))</ContentRoot>
-      <BasePath>/Identity</BasePath>
-      <RelativePath>%(RecursiveDir)%(FileName)%(Extension)</RelativePath>
-    </StaticWebAsset>
-  </ItemGroup>
-</Project>

src/Identity/UI/src/build/Microsoft.AspnetCore.Identity.UI.targets

@@ -1,22 +0,0 @@
-<Project>
-
-  <Target Name="ValidateIdentityUIFrameworkVersion" BeforeTargets="Build">
-
-    <PropertyGroup>
-      <_IdentityUIUnknownVersionErrorMessage>The 'IdentityUIFrameworkVersion' '$(IdentityUIFrameworkVersion)' in '$(MSBuildProjectFile)' is not valid. Valid versions are 'Bootstrap4'.
-      </_IdentityUIUnknownVersionErrorMessage>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <_IdentityUIActiveWarnings Include="IdentityUI002" Exclude="$(NoWarn)" />
-    </ItemGroup>
-
-    <Error
-           Code="IdentityUI002"
-           Text="$(_IdentityUIUnknownVersionErrorMessage)"
-           File="@(MSBuildThisProjectFile)"
-           Condition="'$(IdentityUIFrameworkVersion)' != 'Bootstrap4' and '%(_IdentityUIActiveWarnings.Identity)' == 'IdentityUI002'" />
-
-  </Target>
-
-</Project>

src/Identity/UI/src/buildMultiTargeting/Microsoft.AspnetCore.Identity.UI.targets

@@ -1,5 +0,0 @@
-<Project>
-
-  <Import Project="..\build\Microsoft.AspnetCore.Identity.UI.targets" />
-
-</Project>

src/Identity/UI/src/buildTransitive/Microsoft.AspnetCore.Identity.UI.targets

@@ -1,5 +0,0 @@
-<Project>
-
-  <Import Project="..\buildMultiTargeting\Microsoft.AspnetCore.Identity.UI.targets" />
-
-</Project>

src/Identity/test/Identity.FunctionalTests/Infrastructure/ServerFactory.cs

@@ -85,7 +85,7 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 {
                     typeof(StaticWebAssetsLoader)
                         .GetMethod("UseStaticWebAssetsCore", BindingFlags.NonPublic | BindingFlags.Static)
-                        .Invoke(null, new object[] { context.HostingEnvironment, manifest });
+                        .Invoke(null, new object[] { context.HostingEnvironment, manifest, false });
                 }
             });
         }

src/Identity/test/Identity.FunctionalTests/Testing.DefaultWebSite.StaticWebAssets.V4.xml

@@ -1,3 +1,3 @@
 <StaticWebAssets Version="1.0">
-  <ContentRoot BasePath="/Identity" Path="{TEST_PLACEHOLDER}/V4" />
+  <ContentRoot BasePath="/Identity" Path="{TEST_PLACEHOLDER}" />
 </StaticWebAssets>

src/Identity/test/Identity.Test/IdentityUIScriptsTest.cs

@@ -81,7 +81,7 @@ namespace Microsoft.AspNetCore.Identity.Test
         [MemberData(nameof(ScriptWithFallbackSrcData))]
         public async Task IdentityUI_ScriptTags_FallbackSourceContent_Matches_CDNContent(ScriptTag scriptTag)
         {
-            var wwwrootDir = Path.Combine(GetProjectBasePath(), "wwwroot", scriptTag.Version);
+            var wwwrootDir = Path.Combine(GetProjectBasePath(), "wwwroot");
 
             var cdnContent = await _httpClient.GetStringAsync(scriptTag.Src);
             var fallbackSrcContent = File.ReadAllText(

src/Identity/testassets/Identity.DefaultUI.WebSite/StartupBase.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity;
@@ -104,18 +105,34 @@ namespace Identity.DefaultUI.WebSite
                     case IFileProvider staticWebAssets when staticWebAssets.GetType().Name == "StaticWebAssetsFileProvider":
                         GetUnderlyingProvider(staticWebAssets).UseActivePolling = false;
                         break;
+                    case IFileProvider manifestStaticWebAssets when manifestStaticWebAssets.GetType().Name == "ManifestStaticWebAssetFileProvider":
+                        foreach (var provider in GetUnderlyingProviders(manifestStaticWebAssets))
+                        {
+                            pendingProviders.Push(provider);
+                        }
+                        break;
                     case CompositeFileProvider composite:
                         foreach (var childFileProvider in composite.FileProviders)
                         {
                             pendingProviders.Push(childFileProvider);
                         }
                         break;
+                    case NullFileProvider:
+                        break;
                     default:
-                        throw new InvalidOperationException("Unknown provider");
+                        throw new InvalidOperationException($"Unknown provider '{currentProvider.GetType().Name}'");
                 }
             }
         }
 
+        private static IFileProvider[] GetUnderlyingProviders(IFileProvider manifestStaticWebAssets)
+        {
+            return (IFileProvider[])manifestStaticWebAssets
+                .GetType()
+                .GetField("_fileProviders", BindingFlags.NonPublic | BindingFlags.Instance)
+                .GetValue(manifestStaticWebAssets);
+        }
+
         private static PhysicalFileProvider GetUnderlyingProvider(IFileProvider staticWebAssets)
         {
             return (PhysicalFileProvider) staticWebAssets.GetType().GetProperty("InnerProvider").GetValue(staticWebAssets);

src/Mvc/test/Mvc.FunctionalTests/HtmlGenerationTest.cs

@@ -94,7 +94,7 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
             Assert.Equal($"Vrijdag{Environment.NewLine}Month: FirstOne", response, ignoreLineEndingDifferences: true);
         }
 
-        [Theory]
+        [Theory(Skip = "https://github.com/dotnet/aspnetcore/issues/34599")]
         [MemberData(nameof(WebPagesData))]
         public async Task HtmlGenerationWebSite_GeneratesExpectedResults(string action, string antiforgeryPath)
         {
@@ -137,7 +137,7 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
             }
         }
 
-        [Fact]
+        [Fact(Skip = "https://github.com/dotnet/aspnetcore/issues/34599")]
         public async Task HtmlGenerationWebSite_GeneratesExpectedResults_WithImageData()
         {
             await HtmlGenerationWebSite_GeneratesExpectedResults("Image", antiforgeryPath: null);