Fix web root for WebApplication

src/DefaultBuilder/samples/SampleApp/Program.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -15,13 +14,14 @@ namespace SampleApp
 {
     public class Program
     {
-        public static async Task Main(string[] args)
+        public static void Main(string[] args)
         {
-            await using var webApp = WebApplication.Create(args);
+            var app = WebApplication.Create(args);
 
-            webApp.MapGet("/", (Func<string>)(() => "Hello, World!"));
+            app.UseStaticFiles();
+            app.MapGet("/", (Func<string>)(() => "Hello, World!"));
 
-            await webApp.RunAsync();
+            app.Run();
         }
 
         private static void HelloWorld()

src/DefaultBuilder/src/ConfigureHostBuilder.cs

@@ -61,7 +61,7 @@ public IHostBuilder ConfigureHostConfiguration(Action<IConfigurationBuilder> con
             configureDelegate(_hostConfiguration);
 
             _environment.ApplyConfigurationSettings(_hostConfiguration.Build());
-            Configuration.ChangeBasePath(_environment.ContentRootPath);
+            Configuration.ChangeFileProvider(_environment.ContentRootFileProvider);
 
             _operations += b => b.ConfigureHostConfiguration(configureDelegate);
             return this;

src/DefaultBuilder/src/Properties/AssemblyInfo.cs

@@ -0,0 +1,6 @@
+// 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.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.AspNetCore.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]

src/DefaultBuilder/src/WebHostEnvironment.cs

@@ -38,14 +38,29 @@ public WebHostEnvironment(Assembly? callingAssembly)
             ResolveFileProviders(new Configuration());
         }
 
+        // For testing
+        internal WebHostEnvironment()
+        {
+            ApplicationName = default!;
+            EnvironmentName = default!;
+            ContentRootPath = default!;
+            WebRootPath = default!;
+            ContentRootFileProvider = default!;
+            WebRootFileProvider = default!;
+        }
+
         public void ApplyConfigurationSettings(IConfiguration configuration)
+        {
+            ReadConfigurationSettings(configuration);
+            ResolveFileProviders(configuration);
+        }
+
+        internal void ReadConfigurationSettings(IConfiguration configuration)
         {
             ApplicationName = configuration[WebHostDefaults.ApplicationKey] ?? ApplicationName;
-            ContentRootPath = configuration[WebHostDefaults.ContentRootKey] ?? ContentRootPath;
             EnvironmentName = configuration[WebHostDefaults.EnvironmentKey] ?? EnvironmentName;
-            WebRootPath = configuration[WebHostDefaults.ContentRootKey] ?? WebRootPath;
-
-            ResolveFileProviders(configuration);
+            ContentRootPath = configuration[WebHostDefaults.ContentRootKey] ?? ContentRootPath;
+            WebRootPath = configuration[WebHostDefaults.WebRootKey] ?? WebRootPath;
         }
 
         public void ApplyEnvironmentSettings(IWebHostBuilder genericWebHostBuilder)
@@ -65,7 +80,7 @@ public void ResolveFileProviders(IConfiguration configuration)
 
             if (Directory.Exists(WebRootPath))
             {
-                WebRootFileProvider = new PhysicalFileProvider(Path.Combine(ContentRootPath, WebRootPath));
+                WebRootFileProvider = new PhysicalFileProvider(WebRootPath);
             }
 
             if (this.IsDevelopment())

src/DefaultBuilder/test/Microsoft.AspNetCore.Tests/WebHostEnvironmentTests.cs

@@ -0,0 +1,102 @@
+// 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.Generic;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Tests
+{
+    public class WebHostEnvironmentTests
+    {
+        [Fact]
+        public void ApplyConfigurationSettingsUsesTheCorrectKeys()
+        {
+            var configBuilder = new ConfigurationBuilder();
+            configBuilder.AddInMemoryCollection(new[]
+            {
+                new KeyValuePair<string, string>(WebHostDefaults.ApplicationKey, WebHostDefaults.ApplicationKey),
+                new KeyValuePair<string, string>(WebHostDefaults.EnvironmentKey, WebHostDefaults.EnvironmentKey),
+                new KeyValuePair<string, string>(WebHostDefaults.ContentRootKey, WebHostDefaults.ContentRootKey),
+                new KeyValuePair<string, string>(WebHostDefaults.WebRootKey, WebHostDefaults.WebRootKey),
+            });
+
+            var env = new WebHostEnvironment();
+
+            // Basically call ApplyConfigurationSettings(config) but without creating PhysicalFileProviders.
+            env.ReadConfigurationSettings(configBuilder.Build());
+
+            Assert.Equal(WebHostDefaults.ApplicationKey, env.ApplicationName);
+            Assert.Equal(WebHostDefaults.EnvironmentKey, env.EnvironmentName);
+            Assert.Equal(WebHostDefaults.ContentRootKey, env.ContentRootPath);
+            Assert.Equal(WebHostDefaults.WebRootKey, env.WebRootPath);
+        }
+
+        [Fact]
+        public void ApplyEnvironmentSettingsUsesTheCorrectKeys()
+        {
+            var env = new WebHostEnvironment
+            {
+                ApplicationName = WebHostDefaults.ApplicationKey,
+                EnvironmentName = WebHostDefaults.EnvironmentKey,
+                ContentRootPath = WebHostDefaults.ContentRootKey,
+                WebRootPath = WebHostDefaults.WebRootKey,
+            };
+
+            var settings = new Dictionary<string, string>();
+
+            env.ApplyEnvironmentSettings(new TestWebHostBuilder(settings));
+
+            Assert.Equal(WebHostDefaults.ApplicationKey, settings[WebHostDefaults.ApplicationKey]);
+            Assert.Equal(WebHostDefaults.EnvironmentKey, settings[WebHostDefaults.EnvironmentKey]);
+            Assert.Equal(WebHostDefaults.ContentRootKey, settings[WebHostDefaults.ContentRootKey]);
+            Assert.Equal(WebHostDefaults.WebRootKey, settings[WebHostDefaults.WebRootKey]);
+        }
+
+        private class TestWebHostBuilder : IWebHostBuilder
+        {
+            private readonly Dictionary<string, string> _settings;
+
+            public TestWebHostBuilder(Dictionary<string, string> settingsDictionary)
+            {
+                _settings = settingsDictionary;
+            }
+
+            public IWebHost Build()
+            {
+                throw new NotImplementedException();
+            }
+
+            public IWebHostBuilder ConfigureAppConfiguration(Action<WebHostBuilderContext, IConfigurationBuilder> configureDelegate)
+            {
+                throw new NotImplementedException();
+            }
+
+            public IWebHostBuilder ConfigureServices(Action<IServiceCollection> configureServices)
+            {
+                throw new NotImplementedException();
+            }
+
+            public IWebHostBuilder ConfigureServices(Action<WebHostBuilderContext, IServiceCollection> configureServices)
+            {
+                throw new NotImplementedException();
+            }
+
+            public string GetSetting(string key)
+            {
+                _settings.TryGetValue(key, out var value);
+                return value;
+            }
+
+            public IWebHostBuilder UseSetting(string key, string value)
+            {
+                _settings[key] = value;
+                return this;
+            }
+        }
+    }
+}