public async Task RunsInIISExpressInProcess() { var applicationName = "CreateDefaultBuilderApp"; var deploymentParameters = new DeploymentParameters(Path.Combine(GetTestSitesPath(), applicationName), ServerType.IISExpress, RuntimeFlavor.CoreClr, RuntimeArchitecture.x64) { TargetFramework = "net6.0", HostingModel = HostingModel.InProcess }; SetEnvironmentVariables(deploymentParameters, "Development"); using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, LoggerFactory)) { var deploymentResult = await deployer.DeployAsync(); var response = await RetryHelper.RetryRequest(() => deploymentResult.HttpClient.GetAsync(string.Empty), Logger, deploymentResult.HostShutdownToken, retryCount : 5); var responseText = await response.Content.ReadAsStringAsync(); try { // Assert server is IISExpress Assert.Equal("Microsoft-IIS/10.0", response.Headers.Server.ToString()); // The application name will be sent in response when all asserts succeed in the test app. Assert.Equal(applicationName, responseText); } catch (XunitException) { Logger.LogWarning(response.ToString()); Logger.LogWarning(responseText); throw; } } }
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", 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 = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory)) { var deploymentResult = await deployer.DeployAsync(); await RunTestsAsync(deploymentResult, logger); } } }
public IISTestSiteFixture() { var logging = AssemblyTestLog.ForAssembly(typeof(IISTestSiteFixture).Assembly); var deploymentParameters = new IISDeploymentParameters(Helpers.GetInProcessTestSitesPath(), DeployerSelector.ServerType, RuntimeFlavor.CoreClr, RuntimeArchitecture.x64) { TargetFramework = Tfm.NetCoreApp22, AncmVersion = AncmVersion.AspNetCoreModuleV2, HostingModel = HostingModel.InProcess, PublishApplicationBeforeDeployment = true, }; _forwardingProvider = new ForwardingProvider(); var loggerFactory = logging.CreateLoggerFactory(null, nameof(IISTestSiteFixture)); loggerFactory.AddProvider(_forwardingProvider); _deployer = IISApplicationDeployerFactory.Create(deploymentParameters, loggerFactory); DeploymentResult = _deployer.DeployAsync().Result; Client = DeploymentResult.HttpClient; BaseUri = DeploymentResult.ApplicationBaseUri; ShutdownToken = DeploymentResult.HostShutdownToken; }
private void EnsureInitialized() { if (_deployer != null) { return; } var deploymentParameters = new IISDeploymentParameters(Helpers.GetInProcessTestSitesPath(), DeployerSelector.ServerType, RuntimeFlavor.CoreClr, RuntimeArchitecture.x64) { TargetFramework = Tfm.NetCoreApp30, AncmVersion = AncmVersion.AspNetCoreModuleV2, HostingModel = HostingModel.InProcess, PublishApplicationBeforeDeployment = true }; _configure(deploymentParameters); deploymentParameters.ApplicationPublisher = new PublishedApplicationPublisher(deploymentParameters.ApplicationPath); _deployer = IISApplicationDeployerFactory.Create(deploymentParameters, _loggerFactory); _deploymentResult = (IISDeploymentResult)_deployer.DeployAsync().Result; }
protected ApplicationDeployer CreateDeployer(IISDeploymentParameters parameters) { if (parameters.ServerType == ServerType.IISExpress && !parameters.EnvironmentVariables.ContainsKey(DebugEnvironmentVariable)) { parameters.EnvironmentVariables[DebugEnvironmentVariable] = "console"; } return(IISApplicationDeployerFactory.Create(parameters, LoggerFactory)); }
public async Task DotnetRun_Tests(TestVariant variant) { var testName = $"DotnetRunTests_{variant}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("DotnetRunTests"); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), PublishApplicationBeforeDeployment = false, EnvironmentName = "Development", UserAdditionalCleanup = parameters => { DbUtils.DropDatabase(musicStoreDbName, logger); }, EnvironmentVariables = { { 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); var response = await RetryHelper.RetryRequest( () => httpClient.GetAsync(string.Empty), logger, 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"); // Verify HomePage should validate that we're using precompiled views. await validator.VerifyHomePage(response); // Verify developer exception page logger.LogInformation("Verifying developer exception page"); response = await RetryHelper.RetryRequest( () => httpClient.GetAsync("PageThatThrows"), logger, cancellationToken : deploymentResult.HostShutdownToken); await validator.VerifyDeveloperExceptionPage(response); logger.LogInformation("Variation completed successfully."); } } }
public async Task OpenIdConnectTestSuite(TestVariant variant) { var testName = $"OpenIdConnectTestSuite_{variant}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("OpenIdConnectTestSuite"); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), PreservePublishedApplicationForDebugging = Helpers.PreservePublishedApplicationForDebugging, EnvironmentName = "OpenIdConnectTesting", UserAdditionalCleanup = parameters => { DbUtils.DropDatabase(musicStoreDbName, logger); }, AdditionalPublishParameters = " /p:PublishForTesting=true" }; // 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(); 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.VerifyHomePage(response); logger.LogInformation("Verifying login by OpenIdConnect"); await validator.LoginWithOpenIdConnect(); logger.LogInformation("Variation completed successfully."); } } }
private void EnsureInitialized() { if (_deployer != null) { return; } _configure(DeploymentParameters); _deployer = IISApplicationDeployerFactory.Create(DeploymentParameters, _loggerFactory); _deploymentResult = (IISDeploymentResult)_deployer.DeployAsync().Result; }
public async Task DefaultLocation_Kestrel() { var serverType = ServerType.Kestrel; var testName = $"SmokeTestsUsingStore_{serverType}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger(nameof(StoreSmokeTests)); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters( Helpers.GetApplicationPath(), serverType, RuntimeFlavor.CoreClr, RuntimeArchitecture.x64) { EnvironmentName = "SocialTesting", PublishApplicationBeforeDeployment = true, PreservePublishedApplicationForDebugging = Helpers.PreservePublishedApplicationForDebugging, TargetFramework = Tfm.NetCoreApp30, 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(); logger.LogInformation("Published output directory structure:"); logger.LogInformation(GetDirectoryStructure(deploymentResult.ContentRoot)); var mvcCoreDll = "Microsoft.AspNetCore.Mvc.Core.dll"; logger.LogInformation( $"Checking if published output was trimmed by verifying that the dll '{mvcCoreDll}' is not present..."); var mvcCoreDllPath = Path.Combine(deploymentResult.ContentRoot, mvcCoreDll); var fileInfo = new FileInfo(mvcCoreDllPath); Assert.False( File.Exists(mvcCoreDllPath), $"The file '{fileInfo.Name}.{fileInfo.Extension}' was not expected to be present in the publish directory"); logger.LogInformation($"Published output does not have the dll '{mvcCoreDll}', so the output seems to be trimmed"); await SmokeTests.RunTestsAsync(deploymentResult, logger); } } }
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, variant.Server == ServerType.Nginx ? LogLevel.Trace : LogLevel.Debug, // https://github.com/aspnet/ServerTests/issues/144 testName)) { var logger = loggerFactory.CreateLogger("ResponseFormats"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), EnvironmentName = "Responses" }; 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 { Assert.Equal("Running", responseText); } catch (XunitException) { logger.LogWarning(response.ToString()); logger.LogWarning(responseText); throw; } await scenario(deploymentResult.HttpClient, logger); } } }
private async Task ExecuteTestApp(string applicationName, Func <DeploymentResult, ILogger, Task> assertAction, bool setTestEnvVars = false, string environment = "Development") { var deploymentParameters = new DeploymentParameters(Path.Combine(GetTestSitesPath(), applicationName), ServerType.Kestrel, RuntimeFlavor.CoreClr, RuntimeArchitecture.x64); if (setTestEnvVars) { SetEnvironmentVariables(deploymentParameters, environment); } using (var deployer = IISApplicationDeployerFactory.Create(deploymentParameters, LoggerFactory)) { var deploymentResult = await deployer.DeployAsync(); await assertAction(deploymentResult, Logger); } }
private void EnsureInitialized() { if (_deployer != null) { return; } var deploymentParameters = new IISDeploymentParameters() { RuntimeArchitecture = RuntimeArchitecture.x64, RuntimeFlavor = RuntimeFlavor.CoreClr, TargetFramework = Tfm.NetCoreApp50, HostingModel = HostingModel.InProcess, PublishApplicationBeforeDeployment = true, ApplicationPublisher = new PublishedApplicationPublisher(Helpers.GetInProcessTestSitesName()), ServerType = DeployerSelector.ServerType }; _configure(deploymentParameters); _deployer = IISApplicationDeployerFactory.Create(deploymentParameters, _loggerFactory); _deploymentResult = (IISDeploymentResult)_deployer.DeployAsync().Result; }
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 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 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 async Task HelloWorld(TestVariant variant) { var testName = $"HelloWorld_{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("HelloWorld"); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath() }; if (variant.Server == ServerType.Nginx) { deploymentParameters.ServerConfigTemplateContent = Helpers.GetNginxConfigContent("nginx.conf"); } if (variant.Server == ServerType.IISExpress) { deploymentParameters.EnvironmentVariables[DebugEnvironmentVariable] = "console"; } 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 { string expectedName = Enum.GetName(typeof(RuntimeArchitecture), variant.Architecture); expectedName = char.ToUpperInvariant(expectedName[0]) + expectedName.Substring(1); Assert.Equal($"Hello World {expectedName}", 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 async Task PublishAndRun_Test(TestVariant variant) { var testName = $"PublishAndRunTests_{variant}"; using (StartLog(out var loggerFactory, testName)) { var logger = loggerFactory.CreateLogger("Publish_And_Run_Tests"); var musicStoreDbName = DbUtils.GetUniqueName(); var deploymentParameters = new DeploymentParameters(variant) { ApplicationPath = Helpers.GetApplicationPath(), 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 = 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. // Add retry logic since tests are flaky on mono due to connection issues var response = await RetryHelper.RetryRequest(() => httpClient.GetAsync(string.Empty), 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.VerifyHomePage(response); logger.LogInformation("Verifying architecture"); validator.VerifyArchitecture(response, deploymentResult.DeploymentParameters.RuntimeArchitecture); logger.LogInformation("Verifying static files are served from static file middleware"); await validator.VerifyStaticContentServed(); if (variant.Server != ServerType.IISExpress) { if (Directory.GetFiles( deploymentParameters.ApplicationPath, "*.cmd", SearchOption.TopDirectoryOnly).Length > 0) { throw new Exception("publishExclude parameter values are not honored."); } } logger.LogInformation("Variation completed successfully."); } } }
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); } } }