Remove nowarn settings and start converting TestHost tests to HostBuilder pattern

Copilot · BrennanConroy · Copilot · commit 194d3666a79b · 2025-07-18T21:59:34.000Z
Co-authored-by: BrennanConroy &lt;7574801+BrennanConroy@users.noreply.github.com&gt;
diff --git a/src/Hosting/TestHost/test/Microsoft.AspNetCore.TestHost.Tests.csproj b/src/Hosting/TestHost/test/Microsoft.AspNetCore.TestHost.Tests.csproj
@@ -2,8 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
-    <!-- CS0618: WebHostBuilder is obsolete -->
-    <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Hosting/TestHost/test/WebSocketClientTests.cs b/src/Hosting/TestHost/test/WebSocketClientTests.cs
@@ -4,6 +4,7 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Hosting;
 
 namespace Microsoft.AspNetCore.TestHost.Tests;
 
@@ -19,22 +20,29 @@ public async Task ConnectAsync_ShouldSetRequestProperties(string requestUri, str
         string capturedHost = null;
         string capturedPath = null;
 
-        using (var testServer = new TestServer(new WebHostBuilder()
-            .Configure(app =>
+        using var host = new HostBuilder()
+            .ConfigureWebHost(webHostBuilder =>
             {
-                app.Run(ctx =>
-                {
-                    if (ctx.Request.Path.StartsWithSegments("/connect"))
+                webHostBuilder
+                    .UseTestServer()
+                    .Configure(app =>
                     {
-                        capturedScheme = ctx.Request.Scheme;
-                        capturedHost = ctx.Request.Host.Value;
-                        capturedPath = ctx.Request.Path;
-                    }
-                    return Task.FromResult(0);
-                });
-            })))
-        {
-            var client = testServer.CreateWebSocketClient();
+                        app.Run(ctx =>
+                        {
+                            if (ctx.Request.Path.StartsWithSegments("/connect"))
+                            {
+                                capturedScheme = ctx.Request.Scheme;
+                                capturedHost = ctx.Request.Host.Value;
+                                capturedPath = ctx.Request.Path;
+                            }
+                            return Task.FromResult(0);
+                        });
+                    });
+            })
+            .Build();
+
+        var testServer = host.GetTestServer();
+        var client = testServer.CreateWebSocketClient();
 
             try
             {
@@ -46,7 +54,6 @@ await client.ConnectAsync(
             {
                 // An exception will be thrown because our dummy endpoint does not implement a full Web socket server
             }
-        }
 
         Assert.Equal("http", capturedScheme);
         Assert.Equal(expectedHost, capturedHost);
@@ -56,72 +63,84 @@ await client.ConnectAsync(
     [Fact]
     public async Task CanAcceptWebSocket()
     {
-        using (var testServer = new TestServer(new WebHostBuilder()
-            .Configure(app =>
+        using var host = new HostBuilder()
+            .ConfigureWebHost(webHostBuilder =>
             {
-                app.UseWebSockets();
-                app.Run(async ctx =>
-                {
-                    if (ctx.Request.Path.StartsWithSegments("/connect"))
+                webHostBuilder
+                    .UseTestServer()
+                    .Configure(app =>
                     {
-                        if (ctx.WebSockets.IsWebSocketRequest)
+                        app.UseWebSockets();
+                        app.Run(async ctx =>
                         {
-                            using var websocket = await ctx.WebSockets.AcceptWebSocketAsync();
-                            var buffer = new byte[1000];
-                            var res = await websocket.ReceiveAsync(buffer, default);
-                            await websocket.SendAsync(buffer.AsMemory(0, res.Count), System.Net.WebSockets.WebSocketMessageType.Binary, true, default);
-                            await websocket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, null, default);
-                        }
-                    }
-                });
-            })))
-        {
-            var client = testServer.CreateWebSocketClient();
+                            if (ctx.Request.Path.StartsWithSegments("/connect"))
+                            {
+                                if (ctx.WebSockets.IsWebSocketRequest)
+                                {
+                                    using var websocket = await ctx.WebSockets.AcceptWebSocketAsync();
+                                    var buffer = new byte[1000];
+                                    var res = await websocket.ReceiveAsync(buffer, default);
+                                    await websocket.SendAsync(buffer.AsMemory(0, res.Count), System.Net.WebSockets.WebSocketMessageType.Binary, true, default);
+                                    await websocket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, null, default);
+                                }
+                            }
+                        });
+                    });
+            })
+            .Build();
 
-            using var socket = await client.ConnectAsync(
-                uri: new Uri("http://localhost/connect"),
-                cancellationToken: default);
+        var testServer = host.GetTestServer();
+        var client = testServer.CreateWebSocketClient();
 
-            await socket.SendAsync(new byte[10], System.Net.WebSockets.WebSocketMessageType.Binary, true, default);
-            var res = await socket.ReceiveAsync(new byte[100], default);
-            Assert.Equal(10, res.Count);
-            Assert.True(res.EndOfMessage);
+        using var socket = await client.ConnectAsync(
+            uri: new Uri("http://localhost/connect"),
+            cancellationToken: default);
 
-            await socket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, null, default);
-        }
+        await socket.SendAsync(new byte[10], System.Net.WebSockets.WebSocketMessageType.Binary, true, default);
+        var res = await socket.ReceiveAsync(new byte[100], default);
+        Assert.Equal(10, res.Count);
+        Assert.True(res.EndOfMessage);
+
+        await socket.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, null, default);
     }
 
     [Fact]
     public async Task VerifyWebSocketAndUpgradeFeatures()
     {
-        using (var testServer = new TestServer(new WebHostBuilder()
-            .Configure(app =>
+        using var host = new HostBuilder()
+            .ConfigureWebHost(webHostBuilder =>
             {
-                app.Run(async c =>
-                {
-                    var upgradeFeature = c.Features.Get<IHttpUpgradeFeature>();
-                    Assert.NotNull(upgradeFeature);
-                    Assert.False(upgradeFeature.IsUpgradableRequest);
-                    await Assert.ThrowsAsync<NotSupportedException>(() => upgradeFeature.UpgradeAsync());
-
-                    var webSocketFeature = c.Features.Get<IHttpWebSocketFeature>();
-                    Assert.NotNull(webSocketFeature);
-                    Assert.True(webSocketFeature.IsWebSocketRequest);
-                });
-            })))
-        {
-            var client = testServer.CreateWebSocketClient();
+                webHostBuilder
+                    .UseTestServer()
+                    .Configure(app =>
+                    {
+                        app.Run(async c =>
+                        {
+                            var upgradeFeature = c.Features.Get<IHttpUpgradeFeature>();
+                            Assert.NotNull(upgradeFeature);
+                            Assert.False(upgradeFeature.IsUpgradableRequest);
+                            await Assert.ThrowsAsync<NotSupportedException>(() => upgradeFeature.UpgradeAsync());
 
-            try
-            {
-                using var socket = await client.ConnectAsync(
-                    uri: new Uri("http://localhost/connect"),
-                    cancellationToken: default);
-            }
-            catch
-            {
-                // An exception will be thrown because our endpoint does not accept the websocket
-            }
+                            var webSocketFeature = c.Features.Get<IHttpWebSocketFeature>();
+                            Assert.NotNull(webSocketFeature);
+                            Assert.True(webSocketFeature.IsWebSocketRequest);
+                        });
+                    });
+            })
+            .Build();
+
+        var testServer = host.GetTestServer();
+        var client = testServer.CreateWebSocketClient();
+
+        try
+        {
+            using var socket = await client.ConnectAsync(
+                uri: new Uri("http://localhost/connect"),
+                cancellationToken: default);
+        }
+        catch
+        {
+            // An exception will be thrown because our endpoint does not accept the websocket
         }
     }
 }
diff --git a/src/Hosting/WindowsServices/test/Microsoft.AspNetCore.Hosting.WindowsServices.Tests.csproj b/src/Hosting/WindowsServices/test/Microsoft.AspNetCore.Hosting.WindowsServices.Tests.csproj
@@ -2,8 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
-    <!-- CS0618: WebHostBuilder is obsolete -->
-    <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Hosting/WindowsServices/test/WebHostServiceTests.cs b/src/Hosting/WindowsServices/test/WebHostServiceTests.cs
@@ -19,7 +19,9 @@ public class WebHostServiceTests
     [ConditionalFact]
     public async Task StopBeforeServiceStarted()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         var host = new WebHostBuilder().UseServer(new FakeServer()).Configure(x => { }).Build();
+#pragma warning restore CS0618 // Type or member is obsolete
         var webHostService = new WebHostService(host);
         var applicationLifetime = host.Services.GetRequiredService<IHostApplicationLifetime>();
 
@@ -33,7 +35,9 @@ await Assert.ThrowsAsync<TaskCanceledException>(
     [ConditionalFact]
     public async Task StopAfterServiceStarted()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         var host = new WebHostBuilder().UseServer(new FakeServer()).Configure(x => { }).Build();
+#pragma warning restore CS0618 // Type or member is obsolete
         var webHostService = new WebHostService(host);
         var applicationLifetime = host.Services.GetRequiredService<IHostApplicationLifetime>();
 
diff --git a/src/Hosting/test/testassets/IStartupInjectionAssemblyName/IStartupInjectionAssemblyName.csproj b/src/Hosting/test/testassets/IStartupInjectionAssemblyName/IStartupInjectionAssemblyName.csproj
@@ -3,8 +3,6 @@
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
-    <!-- CS0618: WebHostBuilder is obsolete -->
-    <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Hosting/test/testassets/IStartupInjectionAssemblyName/Program.cs b/src/Hosting/test/testassets/IStartupInjectionAssemblyName/Program.cs
@@ -18,7 +18,9 @@ public static void Main(string[] args)
 
     // Do not change the signature of this method. It's used for tests.
     private static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+#pragma warning disable CS0618 // Type or member is obsolete
         new WebHostBuilder()
         .SuppressStatusMessages(true)
         .ConfigureServices(services => services.AddSingleton<IStartup, Startup>());
+#pragma warning restore CS0618 // Type or member is obsolete
 }
diff --git a/src/Hosting/test/testassets/Microsoft.AspNetCore.Hosting.TestSites/Microsoft.AspNetCore.Hosting.TestSites.csproj b/src/Hosting/test/testassets/Microsoft.AspNetCore.Hosting.TestSites/Microsoft.AspNetCore.Hosting.TestSites.csproj
@@ -3,8 +3,6 @@
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
-    <!-- CS0618: WebHostBuilder is obsolete -->
-    <NoWarn>$(NoWarn);CS0618</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Hosting/test/testassets/Microsoft.AspNetCore.Hosting.TestSites/Program.cs b/src/Hosting/test/testassets/Microsoft.AspNetCore.Hosting.TestSites/Program.cs
@@ -22,6 +22,7 @@ public static void Main(string[] args)
             .AddEnvironmentVariables(prefix: "ASPNETCORE_")
             .Build();
 
+#pragma warning disable CS0618 // Type or member is obsolete
         var builder = new WebHostBuilder()
             .UseServer(new NoopServer())
             .UseConfiguration(config)
@@ -32,6 +33,7 @@ public static void Main(string[] args)
                 factory.AddFilter<ConsoleLoggerProvider>(level => level >= LogLevel.Warning);
             })
             .UseStartup("Microsoft.AspNetCore.Hosting.TestSites");
+#pragma warning restore CS0618 // Type or member is obsolete
 
         if (config["STARTMECHANIC"] == "Run")
         {

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,9 @@ public static void Main(string[] args)`
`18`	`18`
`19`	`19`	`// Do not change the signature of this method. It's used for tests.`
`20`	`20`	`private static IWebHostBuilder CreateWebHostBuilder(string[] args) =>`
	`21`	`+#pragma warning disable CS0618 // Type or member is obsolete`
`21`	`22`	`new WebHostBuilder()`
`22`	`23`	`.SuppressStatusMessages(true)`
`23`	`24`	`.ConfigureServices(services => services.AddSingleton<IStartup, Startup>());`
	`25`	`+#pragma warning restore CS0618 // Type or member is obsolete`
`24`	`26`	`}`