private async Task HttpsHelloWorldCerts(TestVariant variant, bool sendClientCert) { var port = TestPortHelper.GetNextSSLPort(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetOutOfProcessTestSitesPath(), ApplicationBaseUriHint = $"https://localhost:{port}/", ServerConfigTemplateContent = GetHttpsServerConfig() }; var deploymentResult = await DeployAsync(deploymentParameters); var handler = new HttpClientHandler { ServerCertificateCustomValidationCallback = (a, b, c, d) => true, ClientCertificateOptions = ClientCertificateOption.Manual }; if (sendClientCert) { X509Certificate2 clientCert = FindClientCert(); Assert.NotNull(clientCert); handler.ClientCertificates.Add(clientCert); } var client = deploymentResult.CreateRetryClient(handler); // Request to base address and check if various parts of the body are rendered & measure the cold startup time. var response = await client.GetAsync("checkclientcert"); var responseText = await response.Content.ReadAsStringAsync(); if (sendClientCert) { Assert.Equal("Scheme:https; Original:http; has cert? True", responseText); } else { Assert.Equal("Scheme:https; Original:http; has cert? False", responseText); } }
private async Task ResponseFormats(TestVariant variant, Func <HttpClient, ILogger, Task> scenario, [CallerMemberName] string testName = null) { testName = $"{testName}_{variant.Server}_{variant.Tfm}_{variant.Architecture}_{variant.ApplicationType}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("ResponseFormats"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), EnvironmentName = "Responses", ServerConfigTemplateContent = Helpers.GetNginxConfigContent(variant.Server, "nginx.conf"), }; using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); // 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(deploymentResult.HttpClient.GetAsync(string.Empty)); }, logger, deploymentResult.HostShutdownToken); var responseText = await response.Content.ReadAsStringAsync(); try { Assert.Equal("Running", responseText); } catch (XunitException) { logger.LogWarning(response.ToString()); logger.LogWarning(responseText); throw; } await scenario(deploymentResult.HttpClient, logger); } } }
public async Task HelloWorld(TestVariant variant) { var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetOutOfProcessTestSitesPath(), }; var deploymentResult = await DeployAsync(deploymentParameters); var response = await deploymentResult.RetryingHttpClient.GetAsync("/HelloWorld"); var responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("Hello World", responseText); response = await deploymentResult.HttpClient.GetAsync("/Path/%3F%3F?query"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("/??", responseText); response = await deploymentResult.HttpClient.GetAsync("/Query/%3FPath?query?"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("?query?", responseText); response = await deploymentResult.HttpClient.GetAsync("/BodyLimit"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("null", responseText); response = await deploymentResult.HttpClient.GetAsync("/Auth"); responseText = await response.Content.ReadAsStringAsync(); // We adapted the Http.config file to be used for inprocess too. We specify WindowsAuth is enabled // We now expect that windows auth is enabled rather than disabled. Assert.True("backcompat;Windows".Equals(responseText) || "latest;Windows".Equals(responseText), "Auth"); }
public async Task HelloWorld(TestVariant variant) { // The default in hosting sets windows auth to true. // Set it to the IISExpress.config file var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetOutOfProcessTestSitesPath() }; var deploymentResult = await DeployAsync(deploymentParameters); var response = await deploymentResult.RetryingHttpClient.GetAsync("/HelloWorld"); var responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("Hello World", responseText); response = await deploymentResult.HttpClient.GetAsync("/Path/%3F%3F?query"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("/??", responseText); response = await deploymentResult.HttpClient.GetAsync("/Query/%3FPath?query?"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("?query?", responseText); response = await deploymentResult.HttpClient.GetAsync("/BodyLimit"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("null", responseText); response = await deploymentResult.HttpClient.GetAsync("/Auth"); responseText = await response.Content.ReadAsStringAsync(); Assert.True("backcompat;Windows".Equals(responseText) || "latest;null".Equals(responseText), "Auth"); }
public async Task HttpsHelloWorld(TestVariant variant) { var port = TestPortHelper.GetNextSSLPort(); var deploymentParameters = _fixture.GetBaseDeploymentParameters(variant); deploymentParameters.ApplicationBaseUriHint = $"https://localhost:{port}/"; deploymentParameters.AddHttpsToServerConfig(); var deploymentResult = await DeployAsync(deploymentParameters); var handler = new HttpClientHandler { ServerCertificateCustomValidationCallback = (a, b, c, d) => true }; var client = deploymentResult.CreateRetryClient(handler); var response = await client.GetAsync("HttpsHelloWorld"); var responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("Scheme:https; Original:http", responseText); }
public async Task InjectedStartup_DefaultApplicationNameIsEntryAssembly(TestVariant variant) { using (StartLog(out var loggerFactory)) { var logger = loggerFactory.CreateLogger(nameof(InjectedStartup_DefaultApplicationNameIsEntryAssembly)); // https://github.com/dotnet/aspnetcore/issues/8247 #pragma warning disable 0618 var applicationPath = Path.Combine(TestPathUtilities.GetSolutionRootDirectory("Hosting"), "test", "testassets", "IStartupInjectionAssemblyName"); #pragma warning restore 0618 var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = applicationPath, StatusMessagesEnabled = false }; using (var deployer = new SelfHostDeployer(deploymentParameters, loggerFactory)) { await deployer.DeployAsync(); string output = string.Empty; var mre = new ManualResetEventSlim(); deployer.HostProcess.OutputDataReceived += (sender, args) => { if (!string.IsNullOrWhiteSpace(args.Data)) { output += args.Data + '\n'; mre.Set(); } }; mre.Wait(50000); output = output.Trim('\n'); Assert.Equal($"IStartupInjectionAssemblyName", output); } } }
public async Task HttpsHelloWorld(TestVariant variant) { var port = TestPortHelper.GetNextSSLPort(); var deploymentParameters = _fixture.GetBaseDeploymentParameters(variant); deploymentParameters.ApplicationBaseUriHint = $"https://localhost:{port}/"; deploymentParameters.AddHttpsToServerConfig(); var deploymentResult = await DeployAsync(deploymentParameters); var client = CreateNonValidatingClient(deploymentResult); var response = await client.GetAsync("HttpsHelloWorld"); var responseText = await response.Content.ReadAsStringAsync(); if (variant.HostingModel == HostingModel.OutOfProcess) { Assert.Equal("Scheme:https; Original:http", responseText); } else { Assert.Equal("Scheme:https; Original:", responseText); } if (variant.AncmVersion == AncmVersion.AspNetCoreModuleV2 && DeployerSelector.HasNewHandler && DeployerSelector.HasNewShim) { // We expect ServerAddress to be set for InProcess and HTTPS_PORT for OutOfProcess if (variant.HostingModel == HostingModel.InProcess) { Assert.Equal(deploymentParameters.ApplicationBaseUriHint, await client.GetStringAsync("/ServerAddresses")); } else { Assert.Equal(port.ToString(), await client.GetStringAsync("/HTTPS_PORT")); } } }
/// <summary> /// Test Find using the Query class /// </summary> private void Step_30_TestFindByQuery_Generated() { using (TransactionManager tm = CreateTransaction()) { //Insert Mock Instance TestVariant mock = CreateMockInstance(tm); bool result = DataRepository.TestVariantProvider.Insert(tm, mock); Assert.IsTrue(result, "Could Not Test FindByQuery, Insert Failed"); TestVariantQuery query = new TestVariantQuery(); query.AppendEquals(TestVariantColumn.TestVariantId, mock.TestVariantId.ToString()); if (mock.VariantField != null) { query.AppendEquals(TestVariantColumn.VariantField, mock.VariantField.ToString()); } TList <TestVariant> results = DataRepository.TestVariantProvider.Find(tm, query); Assert.IsTrue(results.Count == 1, "Find is not working correctly. Failed to find the mock instance"); } }
public async Task Smoke_Tests(TestVariant variant) { var testName = $"SmokeTestSuite_{variant}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("SmokeTestSuite"); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), EnvironmentName = "SocialTesting", ServerConfigTemplateContent = Helpers.GetConfigContent(variant.Server, "Http.config"), SiteName = "MusicStoreTestSite", PublishApplicationBeforeDeployment = true, PreservePublishedApplicationForDebugging = Helpers.PreservePublishedApplicationForDebugging, UserAdditionalCleanup = parameters => { DbUtils.DropDatabase(musicStoreDbName, logger); } }; // Override the connection strings using environment based configuration deploymentParameters.EnvironmentVariables .Add(new KeyValuePair <string, string>( MusicStoreConfig.ConnectionStringKey, DbUtils.CreateConnectionString(musicStoreDbName))); using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); await RunTestsAsync(deploymentResult, logger); } } }
public async Task StartupMessagesLogFileSwitchedWhenLogFilePresentInWebConfig(TestVariant variant) { var firstTempFile = Path.GetTempFileName(); var secondTempFile = Path.GetTempFileName(); try { var deploymentParameters = Fixture.GetBaseDeploymentParameters(variant); deploymentParameters.EnvironmentVariables["ASPNETCORE_MODULE_DEBUG_FILE"] = firstTempFile; deploymentParameters.AddDebugLogToWebConfig(secondTempFile); var deploymentResult = await DeployAsync(deploymentParameters); var response = await deploymentResult.HttpClient.GetAsync("/"); StopServer(); var logContents = Helpers.ReadAllTextFromFile(firstTempFile, Logger); Assert.Contains("Switching debug log files to", logContents); AssertLogs(secondTempFile); } finally { File.Delete(firstTempFile); File.Delete(secondTempFile); } }
public IISDeploymentParameters GetBaseDeploymentParameters(TestVariant variant) { var publisher = variant.HostingModel == HostingModel.InProcess ? InProcessTestSite : OutOfProcessTestSite; return(GetBaseDeploymentParameters(publisher, new DeploymentParameters(variant))); }
public async Task NtlmAuthentication(TestVariant variant) { var testName = $"NtlmAuthentication_{variant.Server}_{variant.Tfm}_{variant.Architecture}_{variant.ApplicationType}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("NtlmAuthenticationTest"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), EnvironmentName = "NtlmAuthentication", // Will pick the Start class named 'StartupNtlmAuthentication' }; using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); 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(() => { return(httpClient.GetAsync(string.Empty)); }, logger, deploymentResult.HostShutdownToken); var responseText = await response.Content.ReadAsStringAsync(); try { Assert.Equal("Hello World", responseText); logger.LogInformation("Testing /Anonymous"); response = await httpClient.GetAsync("/Anonymous"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal("Anonymous?True", responseText); logger.LogInformation("Testing /Restricted"); response = await httpClient.GetAsync("/Restricted"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); if (variant.Server == ServerType.Kestrel) { Assert.DoesNotContain("NTLM", response.Headers.WwwAuthenticate.ToString()); } else { Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); } Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); logger.LogInformation("Testing /Forbidden"); response = await httpClient.GetAsync("/Forbidden"); Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); logger.LogInformation("Enabling Default Credentials"); // Change the http client to one that uses default credentials httpClient = deploymentResult.CreateHttpClient(new HttpClientHandler() { UseDefaultCredentials = true }); logger.LogInformation("Testing /Restricted"); response = await httpClient.GetAsync("/Restricted"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Authenticated", responseText); logger.LogInformation("Testing /Forbidden"); response = await httpClient.GetAsync("/Forbidden"); Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); } catch (XunitException) { logger.LogWarning(response.ToString()); logger.LogWarning(responseText); throw; } } } }
public Task HttpsNoClientCert_NoClientCert(TestVariant variant) { return(ClientCertTest(variant, sendClientCert: false)); }
public SagaPersisterTests(TestVariant param) { this.param = param; }
public Task ResponseFormats_Http11ConnectionClose(TestVariant variant) { return(ResponseFormats(variant, CheckHttp11ConnectionCloseAsync)); }
public Task ResponseFormats_Chunked(TestVariant variant) { return(ResponseFormats(variant, CheckChunkedAsync)); }
///<summary> /// Update the Typed TestVariant Entity with modified mock values. ///</summary> static public void UpdateMockInstance_Generated(TransactionManager tm, TestVariant mock) { mock.VariantField = null; }
public Task ResponseFormats_ManuallyChunkAndClose(TestVariant variant) { return(ResponseFormats(variant, CheckManuallyChunkedAndCloseAsync)); }
public async Task NtlmAuthentication(TestVariant variant) { var deploymentParameters = Fixture.GetBaseDeploymentParameters(variant); deploymentParameters.ApplicationBaseUriHint = $"https://localhost:0/"; deploymentParameters.SetWindowsAuth(enabled: true); var result = await DeployAsync(deploymentParameters); var response = await result.HttpClient.GetAsync("/HelloWorld"); var responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Hello World", responseText); var httpClient = result.HttpClient; response = await httpClient.GetAsync("/Anonymous"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Anonymous?True", responseText); response = await httpClient.GetAsync("/Restricted"); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); response = await httpClient.GetAsync("/RestrictedNTLM"); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); // Note we can't restrict a challenge to a specific auth type, the native auth modules always add themselves. Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); response = await httpClient.GetAsync("/Forbidden"); Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true }; httpClient = result.CreateClient(httpClientHandler); response = await httpClient.GetAsync("/Anonymous"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Anonymous?True", responseText); response = await httpClient.GetAsync("/Restricted"); responseText = await response.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal("Windows", responseText); }
public When_persisting_different_sagas_with_same_correlation_property_value(TestVariant param) : base(param) { }
public async Task HelloWorld(TestVariant variant) { var deploymentParameters = _fixture.GetBaseDeploymentParameters(variant, publish: true); await StartAsync(deploymentParameters); }
private async Task NtlmAuthenticationTest(TestVariant variant) { var testName = $"NtlmAuthentication_{variant}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("NtlmAuthenticationTest"); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), PreservePublishedApplicationForDebugging = Helpers.PreservePublishedApplicationForDebugging, EnvironmentName = "NtlmAuthentication", //Will pick the Start class named 'StartupNtlmAuthentication' ServerConfigTemplateContent = Helpers.GetConfigContent(variant.Server, "NtlmAuthentation.config"), SiteName = "MusicStoreNtlmAuthentication", //This is configured in the NtlmAuthentication.config UserAdditionalCleanup = parameters => { DbUtils.DropDatabase(musicStoreDbName, logger); } }; // Override the connection strings using environment based configuration deploymentParameters.EnvironmentVariables .Add(new KeyValuePair <string, string>( MusicStoreConfig.ConnectionStringKey, DbUtils.CreateConnectionString(musicStoreDbName))); using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true }; 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(async() => { return(await httpClient.GetAsync(string.Empty)); }, logger : logger, cancellationToken : deploymentResult.HostShutdownToken); Assert.False(response == null, "Response object is null because the client could not " + "connect to the server after multiple retries"); var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult); logger.LogInformation("Verifying home page"); await validator.VerifyNtlmHomePage(response); logger.LogInformation("Verifying architecture"); validator.VerifyArchitecture(response, deploymentResult.DeploymentParameters.RuntimeArchitecture); logger.LogInformation("Verifying access to store with permissions"); await validator.AccessStoreWithPermissions(); logger.LogInformation("Variation completed successfully."); } } }
public Task HttpsClientCert_GetCertInformation(TestVariant variant) { return(ClientCertTest(variant, sendClientCert: true)); }
public IISDeploymentParameters(TestVariant variant) : base(variant) { }
public async Task HelloWorld(TestVariant variant) { var testName = $"HelloWorld_{variant.Server}_{variant.Tfm}_{variant.Architecture}_{variant.ApplicationType}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("HelloWorld"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath() }; if (variant.Server == ServerType.Nginx) { deploymentParameters.ServerConfigTemplateContent = Helpers.GetNginxConfigContent("nginx.conf"); } using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); // 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(deploymentResult.HttpClient.GetAsync(string.Empty)); }, logger, deploymentResult.HostShutdownToken); var responseText = await response.Content.ReadAsStringAsync(); try { if (variant.Architecture == RuntimeArchitecture.x64) { Assert.Equal("Hello World X64", responseText); } else { Assert.Equal("Hello World X86", responseText); } } catch (XunitException) { logger.LogWarning(response.ToString()); logger.LogWarning(responseText); throw; } // Make sure it was the right server. var serverHeader = response.Headers.Server.ToString(); switch (variant.Server) { case ServerType.HttpSys: Assert.Equal("Microsoft-HTTPAPI/2.0", serverHeader); break; case ServerType.Nginx: Assert.StartsWith("nginx/", serverHeader); break; case ServerType.Kestrel: Assert.Equal("Kestrel", serverHeader); break; case ServerType.IIS: case ServerType.IISExpress: if (variant.HostingModel == HostingModel.OutOfProcess) { Assert.Equal("Kestrel", serverHeader); } else { Assert.StartsWith("Microsoft-IIS/", serverHeader); } break; default: throw new NotImplementedException(variant.Server.ToString()); } } } }
public Task ResponseCompression_NoCompression(TestVariant variant) { return(ResponseCompression(variant, CheckNoCompressionAsync, hostCompression: false)); }
public async Task StartupMessagesAreLoggedIntoDefaultDebugLogFileWhenEnabledWithEnvVar(TestVariant variant) { var deploymentParameters = Fixture.GetBaseDeploymentParameters(variant); deploymentParameters.EnvironmentVariables["ASPNETCORE_MODULE_DEBUG"] = "file"; // Add empty debugFile handler setting to prevent IIS deployer from overriding debug settings deploymentParameters.HandlerSettings["debugFile"] = ""; var deploymentResult = await DeployAsync(deploymentParameters); await deploymentResult.HttpClient.GetAsync("/"); AssertLogs(Path.Combine(deploymentResult.ContentRoot, "aspnetcore-debug.log")); }
public Task ResponseCompression_AppAndHostCompression(TestVariant variant) { return(ResponseCompression(variant, CheckAppCompressionAsync, hostCompression: true)); }
public async Task CheckStdoutErrLoggingToFile(TestVariant variant) { await CheckStdoutToFile(variant, "ConsoleErrorWrite"); }
private async Task ResponseCompression(TestVariant variant, Func <HttpClient, ILogger, Task> scenario, bool hostCompression, [CallerMemberName] string testName = null) { testName = $"{testName}_{variant.Server}_{variant.Tfm}_{variant.Architecture}_{variant.ApplicationType}"; using (StartLog(out var loggerFactory, variant.Server == ServerType.Nginx ? LogLevel.Trace : LogLevel.Debug, // https://github.com/aspnet/ServerTests/issues/144 testName)) { var logger = loggerFactory.CreateLogger("ResponseCompression"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), EnvironmentName = "ResponseCompression", }; if (variant.Server == ServerType.Nginx) { deploymentParameters.ServerConfigTemplateContent = hostCompression ? Helpers.GetNginxConfigContent("nginx.conf") : Helpers.GetNginxConfigContent("NoCompression.conf"); } else if (variant.Server == ServerType.IISExpress && !hostCompression) { var iisDeploymentParameters = new IISDeploymentParameters(deploymentParameters); iisDeploymentParameters.ServerConfigActionList.Add( (element, _) => { var compressionElement = element .RequiredElement("system.webServer") .RequiredElement("httpCompression"); compressionElement .RequiredElement("dynamicTypes") .Elements() .SkipLast(1) .Remove(); compressionElement .RequiredElement("staticTypes") .Elements() .SkipLast(1) .Remove(); // last element in both dynamicTypes and staticTypes disables compression // <add mimeType="*/*" enabled="false" /> }); deploymentParameters = iisDeploymentParameters; } using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); var httpClientHandler = new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.None }; Assert.True(httpClientHandler.SupportsAutomaticDecompression); 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(() => { return(httpClient.GetAsync(string.Empty)); }, logger, deploymentResult.HostShutdownToken); var responseText = await response.Content.ReadAsStringAsync(); try { Assert.Equal("Running", responseText); } catch (XunitException) { logger.LogWarning(response.ToString()); logger.LogWarning(responseText); throw; } await scenario(httpClient, logger); } } }