react to aspnet/Hosting#1005 (#68)

analogrelay · web-flow · commit 50299cbac61e · 2017-04-06T15:19:34.000-07:00
diff --git a/ServerTests.sln b/ServerTests.sln
@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26228.10
+VisualStudioVersion = 15.0.26403.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{49AB8AAA-8160-48DF-A18B-78F51E54E02A}"
 	ProjectSection(SolutionItems) = preProject
diff --git a/test/ServerComparison.FunctionalTests/HelloWorldTest.cs b/test/ServerComparison.FunctionalTests/HelloWorldTest.cs
@@ -6,6 +6,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.IntegrationTesting;
+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;
 using Microsoft.AspNetCore.Testing.xunit;
 using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.Logging;
@@ -15,13 +16,10 @@
 
 namespace ServerComparison.FunctionalTests
 {
-    public class HelloWorldTests
+    public class HelloWorldTests : LoggedTest
     {
-        private readonly ITestOutputHelper _output;
-
-        public HelloWorldTests(ITestOutputHelper output)
+        public HelloWorldTests(ITestOutputHelper output) : base(output)
         {
-            _output = output;
         }
 
         // Tests disabled on x86 because of https://github.com/aspnet/Hosting/issues/601
@@ -60,13 +58,10 @@ public Task HelloWorld_Nginx(ServerType serverType, RuntimeFlavor runtimeFlavor,
         public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType, [CallerMemberName] string testName = null)
         {
             testName = $"{testName}_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";
-            var loggerFactory = TestLoggingUtilities.SetUpLogging<HelloWorldTests>(_output, testName);
-            var logger = loggerFactory.CreateLogger("TestHarness");
-            Console.WriteLine($"Starting test: {testName}");
-            logger.LogInformation("Starting test: {testName}", testName);
-
-            using (logger.BeginScope("HelloWorld"))
+            using (StartLog(out var loggerFactory, testName))
             {
+                var logger = loggerFactory.CreateLogger("HelloWorld");
+
                 var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
                 {
                     EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',
@@ -84,13 +79,11 @@ public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor,
                 using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))
                 {
                     var deploymentResult = await deployer.DeployAsync();
-                    var httpClientHandler = new HttpClientHandler();
-                    var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
 
                     // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                     var response = await RetryHelper.RetryRequest(() =>
                     {
-                        return httpClient.GetAsync(string.Empty);
+                        return deploymentResult.HttpClient.GetAsync(string.Empty);
                     }, logger, deploymentResult.HostShutdownToken);
 
                     var responseText = await response.Content.ReadAsStringAsync();
@@ -106,9 +99,6 @@ public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor,
                     }
                 }
             }
-
-            Console.WriteLine($"Finished test: {testName}");
-            logger.LogInformation("Finished test: {testName}", testName);
         }
     }
 }
diff --git a/test/ServerComparison.FunctionalTests/LoggingHandler.cs b/test/ServerComparison.FunctionalTests/LoggingHandler.cs
diff --git a/test/ServerComparison.FunctionalTests/NtlmAuthenticationTest.cs b/test/ServerComparison.FunctionalTests/NtlmAuthenticationTest.cs
@@ -8,6 +8,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.IntegrationTesting;
+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;
 using Microsoft.AspNetCore.Testing.xunit;
 using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.Logging;
@@ -17,13 +18,10 @@
 
 namespace ServerComparison.FunctionalTests
 {
-    public class NtlmAuthenticationTests
+    public class NtlmAuthenticationTests : LoggedTest
     {
-        private readonly ITestOutputHelper _output;
-
-        public NtlmAuthenticationTests(ITestOutputHelper output)
+        public NtlmAuthenticationTests(ITestOutputHelper output) : base(output)
         {
-            _output = output;
         }
 
         [ConditionalTheory, Trait("ServerComparison.FunctionalTests", "ServerComparison.FunctionalTests")]
@@ -38,13 +36,10 @@ public NtlmAuthenticationTests(ITestOutputHelper output)
         public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType)
         {
             var testName = $"NtlmAuthentication_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";
-            var loggerFactory = TestLoggingUtilities.SetUpLogging<HelloWorldTests>(_output, testName);
-            var logger = loggerFactory.CreateLogger("TestHarness");
-            Console.WriteLine($"Starting test: {testName}");
-            logger.LogInformation("Starting test: {testName}", testName);
-
-            using (logger.BeginScope("NtlmAuthenticationTest"))
+            using (StartLog(out var loggerFactory, testName))
             {
+                var logger = loggerFactory.CreateLogger("NtlmAuthenticationTest");
+
                 var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
                 {
                     EnvironmentName = "NtlmAuthentication", // Will pick the Start class named 'StartupNtlmAuthentication'
@@ -62,8 +57,7 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim
                 using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))
                 {
                     var deploymentResult = await deployer.DeployAsync();
-                    var httpClientHandler = new HttpClientHandler();
-                    var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
+                    var httpClient = deploymentResult.HttpClient;
 
                     // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                     var response = await RetryHelper.RetryRequest(() =>
@@ -109,8 +103,9 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim
                         Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
 
                         logger.LogInformation("Enabling Default Credentials");
-                        httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
-                        httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
+
+                        // Change the http client to one that uses default credentials
+                        httpClient = deploymentResult.CreateHttpClient(new HttpClientHandler() { UseDefaultCredentials = true });
 
                         logger.LogInformation("Testing /AutoForbid");
                         response = await httpClient.GetAsync("/AutoForbid");
@@ -155,9 +150,6 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim
                     }
                 }
             }
-
-            Console.WriteLine($"Finished test: {testName}");
-            logger.LogInformation("Finished test: {testName}", testName);
         }
     }
 }
diff --git a/test/ServerComparison.FunctionalTests/ResponseCompressionTests.cs b/test/ServerComparison.FunctionalTests/ResponseCompressionTests.cs
@@ -11,6 +11,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.IntegrationTesting;
+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;
 using Microsoft.AspNetCore.Testing.xunit;
 using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.Logging;
@@ -21,15 +22,13 @@
 
 namespace ServerComparison.FunctionalTests
 {
-    public class ResponseCompressionTests
+    public class ResponseCompressionTests : LoggedTest
     {
         // NGinx's default min size is 20 bytes
         private static readonly string HelloWorldBody = "Hello World;" + new string('a', 20);
-        private readonly ITestOutputHelper _output;
 
-        public ResponseCompressionTests(ITestOutputHelper output)
+        public ResponseCompressionTests(ITestOutputHelper output) : base(output)
         {
-            _output = output;
         }
 
         [ConditionalTheory]
@@ -127,13 +126,10 @@ public Task ResponseCompression_Nginx_AppAndHostCompression(ServerType serverTyp
         public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, Func<HttpClient, ILogger, Task> scenario, ApplicationType applicationType, bool hostCompression, [CallerMemberName] string testName = null)
         {
             testName = $"{testName}_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";
-            var loggerFactory = TestLoggingUtilities.SetUpLogging<ResponseCompressionTests>(_output, testName);
-            var logger = loggerFactory.CreateLogger("TestHarness");
-            Console.WriteLine($"Starting test: {testName}");
-            logger.LogInformation("Starting test: {testName}", testName);
-
-            using (logger.BeginScope("ResponseCompression"))
+            using (StartLog(out var loggerFactory, testName))
             {
+                var logger = loggerFactory.CreateLogger("ResponseCompression");
+
                 var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
                 {
                     EnvironmentName = "ResponseCompression",
@@ -155,7 +151,7 @@ public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runti
                     var deploymentResult = await deployer.DeployAsync();
                     var httpClientHandler = new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.None };
                     Assert.True(httpClientHandler.SupportsAutomaticDecompression);
-                    var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
+                    var httpClient = deploymentResult.CreateHttpClient(httpClientHandler);
 
                     // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                     var response = await RetryHelper.RetryRequest(() =>
@@ -178,9 +174,6 @@ public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runti
                     await scenario(httpClient, logger);
                 }
             }
-
-            Console.WriteLine($"Finished test: {testName}");
-            logger.LogInformation("Finished test: {testName}", testName);
         }
 
         private static async Task CheckNoCompressionAsync(HttpClient client, ILogger logger)
diff --git a/test/ServerComparison.FunctionalTests/ResponseTests.cs b/test/ServerComparison.FunctionalTests/ResponseTests.cs
@@ -8,6 +8,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.IntegrationTesting;
+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;
 using Microsoft.AspNetCore.Testing.xunit;
 using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.Logging;
@@ -18,13 +19,10 @@
 
 namespace ServerComparison.FunctionalTests
 {
-    public class ResponseTests
+    public class ResponseTests : LoggedTest
     {
-        private readonly ITestOutputHelper _output;
-
-        public ResponseTests(ITestOutputHelper output)
+        public ResponseTests(ITestOutputHelper output) : base(output)
         {
-            _output = output;
         }
 
         [ConditionalTheory]
@@ -165,13 +163,10 @@ public Task ResponseFormats_Kestrel_ManuallyChunkAndClose(ServerType serverType,
         public async Task ResponseFormats(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, Func<HttpClient, ILogger, Task> scenario, ApplicationType applicationType, [CallerMemberName] string testName = null)
         {
             testName = $"{testName}_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";
-            var loggerFactory = TestLoggingUtilities.SetUpLogging<HelloWorldTests>(_output, testName);
-            var logger = loggerFactory.CreateLogger("TestHarness");
-            Console.WriteLine($"Starting test: {testName}");
-            logger.LogInformation("Starting test: {testName}", testName);
-
-            using (logger.BeginScope("ResponseFormats"))
+            using (StartLog(out var loggerFactory, testName))
             {
+                var logger = loggerFactory.CreateLogger("ResponseFormats");
+
                 var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)
                 {
                     EnvironmentName = "Responses",
@@ -189,13 +184,11 @@ public async Task ResponseFormats(ServerType serverType, RuntimeFlavor runtimeFl
                 using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))
                 {
                     var deploymentResult = await deployer.DeployAsync();
-                    var httpClientHandler = new HttpClientHandler();
-                    var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
 
                     // Request to base address and check if various parts of the body are rendered & measure the cold startup time.
                     var response = await RetryHelper.RetryRequest(() =>
                     {
-                        return httpClient.GetAsync(string.Empty);
+                        return deploymentResult.HttpClient.GetAsync(string.Empty);
                     }, logger, deploymentResult.HostShutdownToken);
 
                     var responseText = await response.Content.ReadAsStringAsync();
@@ -210,12 +203,9 @@ public async Task ResponseFormats(ServerType serverType, RuntimeFlavor runtimeFl
                         throw;
                     }
 
-                    await scenario(httpClient, logger);
+                    await scenario(deploymentResult.HttpClient, logger);
                 }
             }
-
-            Console.WriteLine($"Finished test: {testName}");
-            logger.LogInformation("Finished test: {testName}", testName);
         }
 
         private static async Task CheckContentLengthAsync(HttpClient client, ILogger logger)
diff --git a/test/ServerComparison.FunctionalTests/TestLoggingUtilities.cs b/test/ServerComparison.FunctionalTests/TestLoggingUtilities.cs

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`using System.Runtime.CompilerServices;`
`7`	`7`	`using System.Threading.Tasks;`
`8`	`8`	`using Microsoft.AspNetCore.Server.IntegrationTesting;`
	`9`	`+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;`
`9`	`10`	`using Microsoft.AspNetCore.Testing.xunit;`
`10`	`11`	`using Microsoft.DotNet.PlatformAbstractions;`
`11`	`12`	`using Microsoft.Extensions.Logging;`
`@@ -15,13 +16,10 @@`
`15`	`16`
`16`	`17`	`namespace ServerComparison.FunctionalTests`
`17`	`18`	`{`
`18`		`- public class HelloWorldTests`
	`19`	`+ public class HelloWorldTests : LoggedTest`
`19`	`20`	`{`
`20`		`- private readonly ITestOutputHelper _output;`
`21`		`-`
`22`		`- public HelloWorldTests(ITestOutputHelper output)`
	`21`	`+ public HelloWorldTests(ITestOutputHelper output) : base(output)`
`23`	`22`	`{`
`24`		`- _output = output;`
`25`	`23`	`}`
`26`	`24`
`27`	`25`	`// Tests disabled on x86 because of https://github.com/aspnet/Hosting/issues/601`
`@@ -60,13 +58,10 @@ public Task HelloWorld_Nginx(ServerType serverType, RuntimeFlavor runtimeFlavor,`
`60`	`58`	`public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType, [CallerMemberName] string testName = null)`
`61`	`59`	`{`
`62`	`60`	`testName = $"{testName}_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";`
`63`		`- var loggerFactory = TestLoggingUtilities.SetUpLogging<HelloWorldTests>(_output, testName);`
`64`		`- var logger = loggerFactory.CreateLogger("TestHarness");`
`65`		`- Console.WriteLine($"Starting test: {testName}");`
`66`		`- logger.LogInformation("Starting test: {testName}", testName);`
`67`		`-`
`68`		`- using (logger.BeginScope("HelloWorld"))`
	`61`	`+ using (StartLog(out var loggerFactory, testName))`
`69`	`62`	`{`
	`63`	`+ var logger = loggerFactory.CreateLogger("HelloWorld");`
	`64`	`+`
`70`	`65`	`var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)`
`71`	`66`	`{`
`72`	`67`	`EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',`
`@@ -84,13 +79,11 @@ public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor,`
`84`	`79`	`using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))`
`85`	`80`	`{`
`86`	`81`	`var deploymentResult = await deployer.DeployAsync();`
`87`		`- var httpClientHandler = new HttpClientHandler();`
`88`		`- var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };`
`89`	`82`
`90`	`83`	`// Request to base address and check if various parts of the body are rendered & measure the cold startup time.`
`91`	`84`	`var response = await RetryHelper.RetryRequest(() =>`
`92`	`85`	`{`
`93`		`- return httpClient.GetAsync(string.Empty);`
	`86`	`+ return deploymentResult.HttpClient.GetAsync(string.Empty);`
`94`	`87`	`}, logger, deploymentResult.HostShutdownToken);`
`95`	`88`
`96`	`89`	`var responseText = await response.Content.ReadAsStringAsync();`
`@@ -106,9 +99,6 @@ public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor,`
`106`	`99`	`}`
`107`	`100`	`}`
`108`	`101`	`}`
`109`		`-`
`110`		`- Console.WriteLine($"Finished test: {testName}");`
`111`		`- logger.LogInformation("Finished test: {testName}", testName);`
`112`	`102`	`}`
`113`	`103`	`}`
`114`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using System.Runtime.CompilerServices;`
`9`	`9`	`using System.Threading.Tasks;`
`10`	`10`	`using Microsoft.AspNetCore.Server.IntegrationTesting;`
	`11`	`+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;`
`11`	`12`	`using Microsoft.AspNetCore.Testing.xunit;`
`12`	`13`	`using Microsoft.DotNet.PlatformAbstractions;`
`13`	`14`	`using Microsoft.Extensions.Logging;`
`@@ -17,13 +18,10 @@`
`17`	`18`
`18`	`19`	`namespace ServerComparison.FunctionalTests`
`19`	`20`	`{`
`20`		`- public class NtlmAuthenticationTests`
	`21`	`+ public class NtlmAuthenticationTests : LoggedTest`
`21`	`22`	`{`
`22`		`- private readonly ITestOutputHelper _output;`
`23`		`-`
`24`		`- public NtlmAuthenticationTests(ITestOutputHelper output)`
	`23`	`+ public NtlmAuthenticationTests(ITestOutputHelper output) : base(output)`
`25`	`24`	`{`
`26`		`- _output = output;`
`27`	`25`	`}`
`28`	`26`
`29`	`27`	`[ConditionalTheory, Trait("ServerComparison.FunctionalTests", "ServerComparison.FunctionalTests")]`
`@@ -38,13 +36,10 @@ public NtlmAuthenticationTests(ITestOutputHelper output)`
`38`	`36`	`public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, ApplicationType applicationType)`
`39`	`37`	`{`
`40`	`38`	`var testName = $"NtlmAuthentication_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";`
`41`		`- var loggerFactory = TestLoggingUtilities.SetUpLogging<HelloWorldTests>(_output, testName);`
`42`		`- var logger = loggerFactory.CreateLogger("TestHarness");`
`43`		`- Console.WriteLine($"Starting test: {testName}");`
`44`		`- logger.LogInformation("Starting test: {testName}", testName);`
`45`		`-`
`46`		`- using (logger.BeginScope("NtlmAuthenticationTest"))`
	`39`	`+ using (StartLog(out var loggerFactory, testName))`
`47`	`40`	`{`
	`41`	`+ var logger = loggerFactory.CreateLogger("NtlmAuthenticationTest");`
	`42`	`+`
`48`	`43`	`var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)`
`49`	`44`	`{`
`50`	`45`	`EnvironmentName = "NtlmAuthentication", // Will pick the Start class named 'StartupNtlmAuthentication'`
`@@ -62,8 +57,7 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim`
`62`	`57`	`using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory))`
`63`	`58`	`{`
`64`	`59`	`var deploymentResult = await deployer.DeployAsync();`
`65`		`- var httpClientHandler = new HttpClientHandler();`
`66`		`- var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };`
	`60`	`+ var httpClient = deploymentResult.HttpClient;`
`67`	`61`
`68`	`62`	`// Request to base address and check if various parts of the body are rendered & measure the cold startup time.`
`69`	`63`	`var response = await RetryHelper.RetryRequest(() =>`
`@@ -109,8 +103,9 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim`
`109`	`103`	`Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);`
`110`	`104`
`111`	`105`	`logger.LogInformation("Enabling Default Credentials");`
`112`		`- httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };`
`113`		`- httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };`
	`106`	`+`
	`107`	`+ // Change the http client to one that uses default credentials`
	`108`	`+ httpClient = deploymentResult.CreateHttpClient(new HttpClientHandler() { UseDefaultCredentials = true });`
`114`	`109`
`115`	`110`	`logger.LogInformation("Testing /AutoForbid");`
`116`	`111`	`response = await httpClient.GetAsync("/AutoForbid");`
`@@ -155,9 +150,6 @@ public async Task NtlmAuthentication(ServerType serverType, RuntimeFlavor runtim`
`155`	`150`	`}`
`156`	`151`	`}`
`157`	`152`	`}`
`158`		`-`
`159`		`- Console.WriteLine($"Finished test: {testName}");`
`160`		`- logger.LogInformation("Finished test: {testName}", testName);`
`161`	`153`	`}`
`162`	`154`	`}`
`163`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`using System.Runtime.CompilerServices;`
`12`	`12`	`using System.Threading.Tasks;`
`13`	`13`	`using Microsoft.AspNetCore.Server.IntegrationTesting;`
	`14`	`+using Microsoft.AspNetCore.Server.IntegrationTesting.xunit;`
`14`	`15`	`using Microsoft.AspNetCore.Testing.xunit;`
`15`	`16`	`using Microsoft.DotNet.PlatformAbstractions;`
`16`	`17`	`using Microsoft.Extensions.Logging;`
`@@ -21,15 +22,13 @@`
`21`	`22`
`22`	`23`	`namespace ServerComparison.FunctionalTests`
`23`	`24`	`{`
`24`		`- public class ResponseCompressionTests`
	`25`	`+ public class ResponseCompressionTests : LoggedTest`
`25`	`26`	`{`
`26`	`27`	`// NGinx's default min size is 20 bytes`
`27`	`28`	`private static readonly string HelloWorldBody = "Hello World;" + new string('a', 20);`
`28`		`- private readonly ITestOutputHelper _output;`
`29`	`29`
`30`		`- public ResponseCompressionTests(ITestOutputHelper output)`
	`30`	`+ public ResponseCompressionTests(ITestOutputHelper output) : base(output)`
`31`	`31`	`{`
`32`		`- _output = output;`
`33`	`32`	`}`
`34`	`33`
`35`	`34`	`[ConditionalTheory]`
`@@ -127,13 +126,10 @@ public Task ResponseCompression_Nginx_AppAndHostCompression(ServerType serverTyp`
`127`	`126`	`public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, Func<HttpClient, ILogger, Task> scenario, ApplicationType applicationType, bool hostCompression, [CallerMemberName] string testName = null)`
`128`	`127`	`{`
`129`	`128`	`testName = $"{testName}_{serverType}_{runtimeFlavor}_{architecture}_{applicationType}";`
`130`		`- var loggerFactory = TestLoggingUtilities.SetUpLogging<ResponseCompressionTests>(_output, testName);`
`131`		`- var logger = loggerFactory.CreateLogger("TestHarness");`
`132`		`- Console.WriteLine($"Starting test: {testName}");`
`133`		`- logger.LogInformation("Starting test: {testName}", testName);`
`134`		`-`
`135`		`- using (logger.BeginScope("ResponseCompression"))`
	`129`	`+ using (StartLog(out var loggerFactory, testName))`
`136`	`130`	`{`
	`131`	`+ var logger = loggerFactory.CreateLogger("ResponseCompression");`
	`132`	`+`
`137`	`133`	`var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(applicationType), serverType, runtimeFlavor, architecture)`
`138`	`134`	`{`
`139`	`135`	`EnvironmentName = "ResponseCompression",`
`@@ -155,7 +151,7 @@ public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runti`
`155`	`151`	`var deploymentResult = await deployer.DeployAsync();`
`156`	`152`	`var httpClientHandler = new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.None };`
`157`	`153`	`Assert.True(httpClientHandler.SupportsAutomaticDecompression);`
`158`		`- var httpClient = new HttpClient(new LoggingHandler(loggerFactory, httpClientHandler)) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };`
	`154`	`+ var httpClient = deploymentResult.CreateHttpClient(httpClientHandler);`
`159`	`155`
`160`	`156`	`// Request to base address and check if various parts of the body are rendered & measure the cold startup time.`
`161`	`157`	`var response = await RetryHelper.RetryRequest(() =>`
`@@ -178,9 +174,6 @@ public async Task ResponseCompression(ServerType serverType, RuntimeFlavor runti`
`178`	`174`	`await scenario(httpClient, logger);`
`179`	`175`	`}`
`180`	`176`	`}`
`181`		`-`
`182`		`- Console.WriteLine($"Finished test: {testName}");`
`183`		`- logger.LogInformation("Finished test: {testName}", testName);`
`184`	`177`	`}`
`185`	`178`
`186`	`179`	`private static async Task CheckNoCompressionAsync(HttpClient client, ILogger logger)`