huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Middleware] Move to GenericHost (#23626)

This commit is contained in:
Brennan 2020-07-07 17:32:35 -07:00 committed by GitHub
parent 921d2c6124
commit f1dd68f1bd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
67 changed files with 6328 additions and 3965 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

381
src/Middleware/CORS/test/UnitTests/CorsMiddlewareTests.cs
View File

@ -10,6 +10,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Moq; using Moq;
@ -27,20 +28,27 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
public async Task CorsRequest_MatchesPolicy_OnCaseInsensitiveAccessControlRequestMethod(string accessControlRequestMethod) public async Task CorsRequest_MatchesPolicy_OnCaseInsensitiveAccessControlRequestMethod(string accessControlRequestMethod)
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(builder => webHostBuilder
builder.WithOrigins(OriginUrl) .UseTestServer()
.WithMethods("PUT")); .Configure(app =>
app.Run(async context =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors(builder =>
}); builder.WithOrigins(OriginUrl)
}) .WithMethods("PUT"));
.ConfigureServices(services => services.AddCors()); app.Run(async context =>
{
await context.Response.WriteAsync("Cross origin response");
});
})
.ConfigureServices(services => services.AddCors());
}).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Actual request. // Actual request.
@ -60,22 +68,29 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
public async Task CorsRequest_MatchPolicy_SetsResponseHeaders() public async Task CorsRequest_MatchPolicy_SetsResponseHeaders()
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(builder => webHostBuilder
builder.WithOrigins(OriginUrl) .UseTestServer()
.WithMethods("PUT") .Configure(app =>
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors(builder =>
}); builder.WithOrigins(OriginUrl)
}) .WithMethods("PUT")
.ConfigureServices(services => services.AddCors()); .WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{
await context.Response.WriteAsync("Cross origin response");
});
})
.ConfigureServices(services => services.AddCors());
}).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Actual request. // Actual request.
@ -102,24 +117,31 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
policy.Origins.Add(OriginUrl); policy.Origins.Add(OriginUrl);
policy.Methods.Add("PUT"); policy.Methods.Add("PUT");
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors("customPolicy"); webHostBuilder
app.Run(async context => .UseTestServer()
.Configure(app =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors("customPolicy");
}); app.Run(async context =>
}) {
.ConfigureServices(services => await context.Response.WriteAsync("Cross origin response");
{ });
services.AddCors(options => })
.ConfigureServices(services =>
{ {
options.AddPolicy("customPolicy", policy); services.AddCors(options =>
{
options.AddPolicy("customPolicy", policy);
});
}); });
}); }).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Preflight request. // Preflight request.
@ -144,24 +166,31 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
policy.Headers.Add("Header1"); policy.Headers.Add("Header1");
policy.ExposedHeaders.Add("AllowedHeader"); policy.ExposedHeaders.Add("AllowedHeader");
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors("customPolicy"); webHostBuilder
app.Run(async context => .UseTestServer()
.Configure(app =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors("customPolicy");
}); app.Run(async context =>
}) {
.ConfigureServices(services => await context.Response.WriteAsync("Cross origin response");
{ });
services.AddCors(options => })
.ConfigureServices(services =>
{ {
options.AddPolicy("customPolicy", policy); services.AddCors(options =>
{
options.AddPolicy("customPolicy", policy);
});
}); });
}); }).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Preflight request. // Preflight request.
@ -202,24 +231,31 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
.AllowCredentials() .AllowCredentials()
.Build(); .Build();
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors("customPolicy"); webHostBuilder
app.Run(async context => .UseTestServer()
.Configure(app =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors("customPolicy");
}); app.Run(async context =>
}) {
.ConfigureServices(services => await context.Response.WriteAsync("Cross origin response");
{ });
services.AddCors(options => })
.ConfigureServices(services =>
{ {
options.AddPolicy("customPolicy", policy); services.AddCors(options =>
{
options.AddPolicy("customPolicy", policy);
});
}); });
}); }).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Preflight request. // Preflight request.
@ -260,22 +296,29 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
public async Task PreFlightRequest_DoesNotMatchPolicy_SetsResponseHeadersAndReturnsNoContent() public async Task PreFlightRequest_DoesNotMatchPolicy_SetsResponseHeadersAndReturnsNoContent()
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(builder => webHostBuilder
builder.WithOrigins(OriginUrl) .UseTestServer()
.WithMethods("PUT") .Configure(app =>
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors(builder =>
}); builder.WithOrigins(OriginUrl)
}) .WithMethods("PUT")
.ConfigureServices(services => services.AddCors()); .WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{
await context.Response.WriteAsync("Cross origin response");
});
})
.ConfigureServices(services => services.AddCors());
}).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Preflight request. // Preflight request.
@ -288,28 +331,37 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
Assert.Empty(response.Headers); Assert.Empty(response.Headers);
} }
await host.StartAsync();
} }
[Fact] [Fact]
public async Task CorsRequest_DoesNotMatchPolicy_DoesNotSetHeaders() public async Task CorsRequest_DoesNotMatchPolicy_DoesNotSetHeaders()
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(builder => webHostBuilder
builder.WithOrigins(OriginUrl) .UseTestServer()
.WithMethods("PUT") .Configure(app =>
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors(builder =>
}); builder.WithOrigins(OriginUrl)
}) .WithMethods("PUT")
.ConfigureServices(services => services.AddCors()); .WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{
await context.Response.WriteAsync("Cross origin response");
});
})
.ConfigureServices(services => services.AddCors());
}).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Actual request. // Actual request.
@ -387,38 +439,45 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
public async Task PreFlight_MatchesDefaultPolicy_SetsResponseHeaders() public async Task PreFlight_MatchesDefaultPolicy_SetsResponseHeaders()
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(); webHostBuilder
app.Run(async context => .UseTestServer()
.Configure(app =>
{ {
await context.Response.WriteAsync("Cross origin response"); app.UseCors();
}); app.Run(async context =>
})
.ConfigureServices(services =>
{
services.AddCors(options =>
{
options.AddDefaultPolicy(policyBuilder =>
{ {
policyBuilder await context.Response.WriteAsync("Cross origin response");
.WithOrigins(OriginUrl)
.WithMethods("PUT")
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader")
.Build();
}); });
options.AddPolicy("policy2", policyBuilder => })
.ConfigureServices(services =>
{
services.AddCors(options =>
{ {
policyBuilder options.AddDefaultPolicy(policyBuilder =>
.WithOrigins("http://test.example.com") {
.Build(); policyBuilder
.WithOrigins(OriginUrl)
.WithMethods("PUT")
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader")
.Build();
});
options.AddPolicy("policy2", policyBuilder =>
{
policyBuilder
.WithOrigins("http://test.example.com")
.Build();
});
}); });
}); });
}); }).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Preflight request. // Preflight request.
@ -453,23 +512,30 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
public async Task CorsRequest_SetsResponseHeaders() public async Task CorsRequest_SetsResponseHeaders()
{ {
// Arrange // Arrange
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseCors(builder => webHostBuilder
builder.WithOrigins(OriginUrl) .UseTestServer()
.WithMethods("PUT") .Configure(app =>
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{ {
context.Response.Headers.Add("Test", "Should-Appear"); app.UseCors(builder =>
await context.Response.WriteAsync("Cross origin response"); builder.WithOrigins(OriginUrl)
}); .WithMethods("PUT")
}) .WithHeaders("Header1")
.ConfigureServices(services => services.AddCors()); .WithExposedHeaders("AllowedHeader"));
app.Run(async context =>
{
context.Response.Headers.Add("Test", "Should-Appear");
await context.Response.WriteAsync("Cross origin response");
});
})
.ConfigureServices(services => services.AddCors());
}).Build();
using (var server = new TestServer(hostBuilder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
// Act // Act
// Actual request. // Actual request.
@ -506,39 +572,46 @@ namespace Microsoft.AspNetCore.Cors.Infrastructure
{ {
// Arrange // Arrange
var exceptionSeen = true; var exceptionSeen = true;
var hostBuilder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
// Simulate ExceptionHandler middleware webHostBuilder
app.Use(async (context, next) => .UseTestServer()
.Configure(app =>
{ {
try // Simulate ExceptionHandler middleware
app.Use(async (context, next) =>
{ {
await next(); try
} {
catch (Exception) await next();
}
catch (Exception)
{
exceptionSeen = true;
context.Response.Clear();
context.Response.StatusCode = 500;
}
});
app.UseCors(builder =>
builder.WithOrigins(OriginUrl)
.WithMethods("PUT")
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(context =>
{ {
exceptionSeen = true; context.Response.Headers.Add("Test", "Should-Not-Exist");
context.Response.Clear(); throw new Exception("Runtime error");
context.Response.StatusCode = 500; });
} })
}); .ConfigureServices(services => services.AddCors());
}).Build();
app.UseCors(builder => await host.StartAsync();
builder.WithOrigins(OriginUrl)
.WithMethods("PUT")
.WithHeaders("Header1")
.WithExposedHeaders("AllowedHeader"));
app.Run(context => using (var server = host.GetTestServer())
{
context.Response.Headers.Add("Test", "Should-Not-Exist");
throw new Exception("Runtime error");
});
})
.ConfigureServices(services => services.AddCors());
using (var server = new TestServer(hostBuilder))
{ {
// Act // Act
// Actual request. // Actual request.

18
src/Middleware/CORS/test/testassets/CorsMiddlewareWebSite/Startup.cs
View File

@ -1,9 +1,11 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace CorsMiddlewareWebSite namespace CorsMiddlewareWebSite
{ {
@ -19,15 +21,19 @@ namespace CorsMiddlewareWebSite
app.UseCors(policy => policy.WithOrigins("http://example.com")); app.UseCors(policy => policy.WithOrigins("http://example.com"));
app.UseMiddleware<EchoMiddleware>(); app.UseMiddleware<EchoMiddleware>();
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

14
src/Middleware/ConcurrencyLimiter/sample/Startup.cs
View File

@ -33,13 +33,17 @@ namespace ConcurrencyLimiterSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
new WebHostBuilder() return new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseStartup<Startup>() {
webHostBuilder
.UseKestrel()
.UseStartup<Startup>();
})
.Build() .Build()
.Run(); .RunAsync();
} }
} }
} }

139
src/Middleware/Diagnostics.EntityFrameworkCore/test/FunctionalTests/DatabaseErrorPageMiddlewareTest.cs
View File

@ -17,6 +17,7 @@ using Microsoft.AspNetCore.Testing;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Xunit; using Xunit;
@ -27,10 +28,19 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Successful_requests_pass_thru() public async Task Successful_requests_pass_thru()
{ {
var builder = new WebHostBuilder().Configure(app => app using var host = new HostBuilder()
.UseDatabaseErrorPage() .ConfigureWebHost(webHostBuilder =>
.UseMiddleware<SuccessMiddleware>()); {
var server = new TestServer(builder); webHostBuilder
.UseTestServer()
.Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<SuccessMiddleware>());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
@ -53,10 +63,19 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Non_database_exceptions_pass_thru() public async Task Non_database_exceptions_pass_thru()
{ {
var builder = new WebHostBuilder().Configure(app => app using var host = new HostBuilder()
.UseDatabaseErrorPage() .ConfigureWebHost(webHostBuilder =>
.UseMiddleware<ExceptionMiddleware>()); {
var server = new TestServer(builder); webHostBuilder
.UseTestServer()
.Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<ExceptionMiddleware>());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
await server.CreateClient().GetAsync("http://localhost/")); await server.CreateClient().GetAsync("http://localhost/"));
@ -82,7 +101,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContext, DatabaseErrorButNoMigrationsMiddleware>(database); using var host = await SetupServer<BloggingContext, DatabaseErrorButNoMigrationsMiddleware>(database);
using var server = host.GetTestServer();
var ex = await Assert.ThrowsAsync<DbUpdateException>(async () => var ex = await Assert.ThrowsAsync<DbUpdateException>(async () =>
await server.CreateClient().GetAsync("http://localhost/")); await server.CreateClient().GetAsync("http://localhost/"));
@ -114,7 +134,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContext, NoMigrationsMiddleware>(database); using var host = await SetupServer<BloggingContext, NoMigrationsMiddleware>(database);
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -142,13 +163,13 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[ConditionalFact] [ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux)] [OSSkipCondition(OperatingSystems.Linux)]
[OSSkipCondition(OperatingSystems.MacOSX)] [OSSkipCondition(OperatingSystems.MacOSX)]
public void No_exception_on_diagnostic_event_received_when_null_state() public async Task No_exception_on_diagnostic_event_received_when_null_state()
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
using (var server = SetupTestServer<BloggingContext, NoMigrationsMiddleware>(database)) using (var server = await SetupServer<BloggingContext, NoMigrationsMiddleware>(database))
{ {
using (var db = server.Host.Services.GetService<BloggingContext>()) using (var db = server.Services.GetService<BloggingContext>())
{ {
db.Blogs.Add(new Blog()); db.Blogs.Add(new Blog());
@ -172,7 +193,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContextWithMigrations, PendingMigrationsMiddleware>(database); using var host = await SetupServer<BloggingContextWithMigrations, PendingMigrationsMiddleware>(database);
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -208,7 +230,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContextWithPendingModelChanges, PendingModelChangesMiddleware>(database); using var host = await SetupServer<BloggingContextWithPendingModelChanges, PendingModelChangesMiddleware>(database);
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -245,7 +268,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContextWithMigrations, ApplyMigrationsMiddleware>(database); using var host = await SetupServer<BloggingContextWithMigrations, ApplyMigrationsMiddleware>(database);
using var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var expectedMigrationsEndpoint = "/ApplyDatabaseMigrations"; var expectedMigrationsEndpoint = "/ApplyDatabaseMigrations";
@ -302,7 +326,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => .Configure(app =>
{ {
app.UseDatabaseErrorPage(new DatabaseErrorPageOptions app.UseDatabaseErrorPage(new DatabaseErrorPageOptions
@ -317,7 +345,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
services.AddDbContext<BloggingContextWithMigrations>( services.AddDbContext<BloggingContextWithMigrations>(
optionsBuilder => optionsBuilder.UseSqlite(database.ConnectionString)); optionsBuilder => optionsBuilder.UseSqlite(database.ConnectionString));
}); });
var server = new TestServer(builder); }).Build();
await host.StartAsync();
var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
@ -335,16 +367,24 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
var logProvider = new TestLoggerProvider(); var logProvider = new TestLoggerProvider();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseDatabaseErrorPage(); webHostBuilder
app.UseMiddleware<ContextNotRegisteredInServicesMiddleware>(); .UseTestServer()
.Configure(app =>
{
app.UseDatabaseErrorPage();
app.UseMiddleware<ContextNotRegisteredInServicesMiddleware>();
#pragma warning disable CS0618 // Type or member is obsolete #pragma warning disable CS0618 // Type or member is obsolete
app.ApplicationServices.GetService<ILoggerFactory>().AddProvider(logProvider); app.ApplicationServices.GetService<ILoggerFactory>().AddProvider(logProvider);
#pragma warning restore CS0618 // Type or member is obsolete #pragma warning restore CS0618 // Type or member is obsolete
}); });
var server = new TestServer(builder); }).Build();
await host.StartAsync();
var server = host.GetTestServer();
try try
{ {
@ -391,7 +431,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
var logProvider = new TestLoggerProvider(); var logProvider = new TestLoggerProvider();
var server = SetupTestServer<BloggingContextWithSnapshotThatThrows, ExceptionInLogicMiddleware>(database, logProvider); using var host = await SetupServer<BloggingContextWithSnapshotThatThrows, ExceptionInLogicMiddleware>(database, logProvider);
using var server = host.GetTestServer();
try try
{ {
@ -430,7 +471,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
TestServer server = SetupTestServer<BloggingContext, WrappedExceptionMiddleware>(database); using var host = await SetupServer<BloggingContext, WrappedExceptionMiddleware>(database);
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -461,29 +503,36 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
} }
} }
private static TestServer SetupTestServer<TContext, TMiddleware>(SqlTestStore database, ILoggerProvider logProvider = null) private static async Task<IHost> SetupServer<TContext, TMiddleware>(SqlTestStore database, ILoggerProvider logProvider = null)
where TContext : DbContext where TContext : DbContext
{ {
var builder = new WebHostBuilder() var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseDatabaseErrorPage(); webHostBuilder
.UseTestServer()
app.UseMiddleware<TMiddleware>(); .Configure(app =>
if (logProvider != null)
{ {
#pragma warning disable CS0618 // Type or member is obsolete app.UseDatabaseErrorPage();
app.ApplicationServices.GetService<ILoggerFactory>().AddProvider(logProvider);
#pragma warning restore CS0618 // Type or member is obsolete
}
})
.ConfigureServices(services =>
{
services.AddDbContext<TContext>(optionsBuilder => optionsBuilder.UseSqlite(database.ConnectionString));
});
return new TestServer(builder); app.UseMiddleware<TMiddleware>();
if (logProvider != null)
{
#pragma warning disable CS0618 // Type or member is obsolete
app.ApplicationServices.GetService<ILoggerFactory>().AddProvider(logProvider);
#pragma warning restore CS0618 // Type or member is obsolete
}
})
.ConfigureServices(services =>
{
services.AddDbContext<TContext>(optionsBuilder => optionsBuilder.UseSqlite(database.ConnectionString));
});
}).Build();
await host.StartAsync();
return host;
} }
private static UrlEncoder _urlEncoder = UrlEncoder.Default; private static UrlEncoder _urlEncoder = UrlEncoder.Default;

94
src/Middleware/Diagnostics.EntityFrameworkCore/test/FunctionalTests/MigrationsEndPointMiddlewareTest.cs
View File

@ -18,6 +18,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations; using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
@ -27,10 +28,19 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Non_migration_requests_pass_thru() public async Task Non_migration_requests_pass_thru()
{ {
var builder = new WebHostBuilder().Configure(app => app using var host = new HostBuilder()
.UseMigrationsEndPoint() .ConfigureWebHost(webHostBuilder =>
.UseMiddleware<SuccessMiddleware>()); {
var server = new TestServer(builder); webHostBuilder
.UseTestServer()
.Configure(app => app
.UseMigrationsEndPoint()
.UseMiddleware<SuccessMiddleware>());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
@ -75,7 +85,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
var path = useCustomPath ? new PathString("/EndPoints/ApplyMyMigrations") : MigrationsEndPointOptions.DefaultPath; var path = useCustomPath ? new PathString("/EndPoints/ApplyMyMigrations") : MigrationsEndPointOptions.DefaultPath;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => .Configure(app =>
{ {
if (useCustomPath) if (useCustomPath)
@ -97,7 +111,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
options.UseSqlite(database.ConnectionString); options.UseSqlite(database.ConnectionString);
}); });
}); });
var server = new TestServer(builder); }).Build();
await host.StartAsync();
var server = host.GetTestServer();
using (var db = BloggingContextWithMigrations.CreateWithoutExternalServiceProvider(optionsBuilder.Options)) using (var db = BloggingContextWithMigrations.CreateWithoutExternalServiceProvider(optionsBuilder.Options))
{ {
@ -128,12 +146,20 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Context_type_not_specified() public async Task Context_type_not_specified()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseMigrationsEndPoint(); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseMigrationsEndPoint();
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()); var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>());
@ -148,12 +174,20 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Invalid_context_type_specified() public async Task Invalid_context_type_specified()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseMigrationsEndPoint(); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseMigrationsEndPoint();
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var typeName = "You won't find this type ;)"; var typeName = "You won't find this type ;)";
var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>> var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>
@ -172,10 +206,18 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact] [Fact]
public async Task Context_not_registered_in_services() public async Task Context_not_registered_in_services()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => app.UseMigrationsEndPoint()) .ConfigureWebHost(webHostBuilder =>
.ConfigureServices(services => services.AddEntityFrameworkSqlite()); {
var server = new TestServer(builder); webHostBuilder
.UseTestServer()
.Configure(app => app.UseMigrationsEndPoint())
.ConfigureServices(services => services.AddEntityFrameworkSqlite());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>> var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>
{ {
@ -197,7 +239,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{ {
using (var database = SqlTestStore.CreateScratch()) using (var database = SqlTestStore.CreateScratch())
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app.UseMigrationsEndPoint()) .Configure(app => app.UseMigrationsEndPoint())
.ConfigureServices(services => .ConfigureServices(services =>
{ {
@ -206,7 +252,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
optionsBuilder.UseSqlite(database.ConnectionString); optionsBuilder.UseSqlite(database.ConnectionString);
}); });
}); });
var server = new TestServer(builder); }).Build();
await host.StartAsync();
var server = host.GetTestServer();
var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>> var formData = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>
{ {

15
src/Middleware/Diagnostics/test/FunctionalTests/TestFixture.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
@ -6,12 +6,14 @@ using System.Net.Http;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.AspNetCore.Testing; using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
{ {
public class TestFixture<TStartup> : IDisposable public class TestFixture<TStartup> : IDisposable
{ {
private readonly TestServer _server; private readonly TestServer _server;
private readonly IHost _host;
public TestFixture() public TestFixture()
{ {
@ -20,10 +22,16 @@ namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
// (DefaultRequestCulture) is consistent regardless of system configuration or personal preferences. // (DefaultRequestCulture) is consistent regardless of system configuration or personal preferences.
using (new CultureReplacer()) using (new CultureReplacer())
{ {
var builder = new WebHostBuilder() _host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(typeof(TStartup)); .UseStartup(typeof(TStartup));
}).Build();
_server = new TestServer(builder); _host.Start();
_server = _host.GetTestServer();
} }
Client = _server.CreateClient(); Client = _server.CreateClient();
@ -36,6 +44,7 @@ namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
{ {
Client.Dispose(); Client.Dispose();
_server.Dispose(); _server.Dispose();
_host.Dispose();
} }
} }
} }

193
src/Middleware/Diagnostics/test/UnitTests/DeveloperExceptionPageMiddlewareTest.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Diagnostics namespace Microsoft.AspNetCore.Diagnostics
@ -22,17 +23,25 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
// Arrange // Arrange
DiagnosticListener diagnosticListener = null; DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>(); webHostBuilder
app.UseDeveloperExceptionPage(); .UseTestServer()
app.Run(context => .Configure(app =>
{ {
throw new Exception("Test exception"); diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener(); var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener); diagnosticListener.SubscribeWithAdapter(listener);
@ -50,16 +59,24 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ErrorPageWithAcceptHeaderForHtmlReturnsHtml() public async Task ErrorPageWithAcceptHeaderForHtmlReturnsHtml()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseDeveloperExceptionPage(); webHostBuilder
app.Run(context => .UseTestServer()
.Configure(app =>
{ {
throw new Exception("Test exception"); app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
// Act // Act
var client = server.CreateClient(); var client = server.CreateClient();
@ -77,16 +94,24 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ErrorPageWithoutAcceptHeaderForHtmlReturnsPlainText() public async Task ErrorPageWithoutAcceptHeaderForHtmlReturnsPlainText()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseDeveloperExceptionPage(); webHostBuilder
app.Run(context => .UseTestServer()
.Configure(app =>
{ {
throw new Exception("Test exception"); app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
// Act // Act
var response = await server.CreateClient().GetAsync("/path"); var response = await server.CreateClient().GetAsync("/path");
@ -102,20 +127,28 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ExceptionPageFiltersAreApplied() public async Task ExceptionPageFiltersAreApplied()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{ {
throw new Exception("Test exception"); services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
// Act // Act
var response = await server.CreateClient().GetAsync("/path"); var response = await server.CreateClient().GetAsync("/path");
@ -128,50 +161,68 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ExceptionFilterCallingNextWorks() public async Task ExceptionFilterCallingNextWorks()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<IDeveloperPageExceptionFilter, PassThroughExceptionFilter>(); webHostBuilder
services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysBadFormatExceptionFilter>(); .UseTestServer()
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>(); .ConfigureServices(services =>
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{ {
throw new Exception("Test exception"); services.AddSingleton<IDeveloperPageExceptionFilter, PassThroughExceptionFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysBadFormatExceptionFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
// Act // Act
var response = await server.CreateClient().GetAsync("/path"); var response = await server.CreateClient().GetAsync("/path");
// Assert // Assert
Assert.Equal("Bad format exception!", await response.Content.ReadAsStringAsync()); Assert.Equal("Bad format exception!", await response.Content.ReadAsStringAsync());
await host.StartAsync();
} }
[Fact] [Fact]
public async Task ExceptionPageFiltersAreAppliedInOrder() public async Task ExceptionPageFiltersAreAppliedInOrder()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysThrowSameMessageFilter>(); webHostBuilder
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>(); .UseTestServer()
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionToStringFilter>(); .ConfigureServices(services =>
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{ {
throw new Exception("Test exception"); services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysThrowSameMessageFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionToStringFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
// Act // Act
var response = await server.CreateClient().GetAsync("/path"); var response = await server.CreateClient().GetAsync("/path");
@ -241,17 +292,25 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
// Arrange // Arrange
DiagnosticListener diagnosticListener = null; DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>(); webHostBuilder
app.UseDeveloperExceptionPage(); .UseTestServer()
app.Run(context => .Configure(app =>
{ {
throw new CustomCompilationException(failures); diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new CustomCompilationException(failures);
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener(); var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener); diagnosticListener.SubscribeWithAdapter(listener);

390
src/Middleware/Diagnostics/test/UnitTests/ExceptionHandlerTest.cs
View File

@ -16,6 +16,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Diagnostics namespace Microsoft.AspNetCore.Diagnostics
@ -28,28 +29,35 @@ namespace Microsoft.AspNetCore.Diagnostics
[InlineData(HttpStatusCode.InternalServerError)] [InlineData(HttpStatusCode.InternalServerError)]
public async Task OnlyHandles_UnhandledExceptions(HttpStatusCode expectedStatusCode) public async Task OnlyHandles_UnhandledExceptions(HttpStatusCode expectedStatusCode)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseExceptionHandler("/handle-errors"); webHostBuilder
.UseTestServer()
app.Map("/handle-errors", (innerAppBuilder) => .Configure(app =>
{ {
innerAppBuilder.Run(async (httpContext) => app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
await httpContext.Response.WriteAsync("Handled error in a custom way."); innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync("Handled error in a custom way.");
});
}); });
app.Run((RequestDelegate)(async (context) =>
{
context.Response.StatusCode = (int)expectedStatusCode;
context.Response.ContentType = "text/plain; charset=utf-8";
await context.Response.WriteAsync("An error occurred while adding a product");
}));
}); });
}).Build();
app.Run((RequestDelegate)(async (context) => await host.StartAsync();
{
context.Response.StatusCode = (int)expectedStatusCode;
context.Response.ContentType = "text/plain; charset=utf-8";
await context.Response.WriteAsync("An error occurred while adding a product");
}));
});
using (var server = new TestServer(builder)) using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -61,43 +69,50 @@ namespace Microsoft.AspNetCore.Diagnostics
[Fact] [Fact]
public async Task DoesNotHandle_UnhandledExceptions_WhenResponseAlreadyStarted() public async Task DoesNotHandle_UnhandledExceptions_WhenResponseAlreadyStarted()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.Use(async (httpContext, next) => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
Exception exception = null; app.Use(async (httpContext, next) =>
try
{ {
await next(); Exception exception = null;
} try
catch (InvalidOperationException ex) {
await next();
}
catch (InvalidOperationException ex)
{
exception = ex;
}
Assert.NotNull(exception);
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
exception = ex; innerAppBuilder.Run(async (httpContext) =>
} {
await httpContext.Response.WriteAsync("Handled error in a custom way.");
});
});
Assert.NotNull(exception); app.Run(async (httpContext) =>
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{ {
await httpContext.Response.WriteAsync("Handled error in a custom way."); await httpContext.Response.WriteAsync("Hello");
throw new InvalidOperationException("Something bad happened");
}); });
}); });
}).Build();
app.Run(async (httpContext) => await host.StartAsync();
{
await httpContext.Response.WriteAsync("Hello");
throw new InvalidOperationException("Something bad happened");
});
});
using (var server = new TestServer(builder)) using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -110,54 +125,61 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ClearsResponseBuffer_BeforeRequestIsReexecuted() public async Task ClearsResponseBuffer_BeforeRequestIsReexecuted()
{ {
var expectedResponseBody = "New response body"; var expectedResponseBody = "New response body";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
// add response buffering webHostBuilder
app.Use(async (httpContext, next) => .UseTestServer()
.Configure(app =>
{ {
var response = httpContext.Response; // add response buffering
var originalResponseBody = response.Body; app.Use(async (httpContext, next) =>
var bufferingStream = new MemoryStream();
response.Body = bufferingStream;
try
{ {
await next(); var response = httpContext.Response;
var originalResponseBody = response.Body;
var bufferingStream = new MemoryStream();
response.Body = bufferingStream;
response.Body = originalResponseBody; try
bufferingStream.Seek(0, SeekOrigin.Begin); {
await bufferingStream.CopyToAsync(response.Body); await next();
}
finally response.Body = originalResponseBody;
bufferingStream.Seek(0, SeekOrigin.Begin);
await bufferingStream.CopyToAsync(response.Body);
}
finally
{
response.Body = originalResponseBody;
}
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
response.Body = originalResponseBody; innerAppBuilder.Run(async (httpContext) =>
} {
}); Assert.True(httpContext.Response.Body.CanSeek);
Assert.Equal(0, httpContext.Response.Body.Position);
app.UseExceptionHandler("/handle-errors"); await httpContext.Response.WriteAsync(expectedResponseBody);
});
});
app.Map("/handle-errors", (innerAppBuilder) => app.Run(async (context) =>
{
innerAppBuilder.Run(async (httpContext) =>
{ {
Assert.True(httpContext.Response.Body.CanSeek); // Write some content into the response before throwing exception
Assert.Equal(0, httpContext.Response.Body.Position); await context.Response.WriteAsync(new string('a', 100));
await httpContext.Response.WriteAsync(expectedResponseBody); throw new InvalidOperationException("Invalid input provided.");
}); });
}); });
}).Build();
app.Run(async (context) => await host.StartAsync();
{
// Write some content into the response before throwing exception
await context.Response.WriteAsync(new string('a', 100));
throw new InvalidOperationException("Invalid input provided."); using (var server = host.GetTestServer())
});
});
using (var server = new TestServer(builder))
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -181,32 +203,39 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
var expiresTime = DateTime.UtcNow.AddDays(5).ToString("R"); var expiresTime = DateTime.UtcNow.AddDays(5).ToString("R");
var expectedResponseBody = "Handled error in a custom way."; var expectedResponseBody = "Handled error in a custom way.";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseExceptionHandler("/handle-errors"); webHostBuilder
.UseTestServer()
app.Map("/handle-errors", (innerAppBuilder) => .Configure(app =>
{ {
innerAppBuilder.Run(async (httpContext) => app.UseExceptionHandler("/handle-errors");
{
httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=600" });
httpContext.Response.Headers.Add(
"Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "12345" });
await httpContext.Response.WriteAsync(expectedResponseBody); app.Map("/handle-errors", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=600" });
httpContext.Response.Headers.Add(
"Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "12345" });
await httpContext.Response.WriteAsync(expectedResponseBody);
});
});
app.Run((context) =>
{
throw new InvalidOperationException("Invalid input provided.");
}); });
}); });
}).Build();
app.Run((context) => await host.StartAsync();
{
throw new InvalidOperationException("Invalid input provided.");
});
});
using (var server = new TestServer(builder)) using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -230,31 +259,38 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R"); var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R");
var expectedResponseBody = "Hello world!"; var expectedResponseBody = "Hello world!";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseExceptionHandler("/handle-errors"); webHostBuilder
.UseTestServer()
app.Map("/handle-errors", (innerAppBuilder) => .Configure(app =>
{ {
innerAppBuilder.Run(async (httpContext) => app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
await httpContext.Response.WriteAsync("Handled error in a custom way."); innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync("Handled error in a custom way.");
});
});
app.Run(async (httpContext) =>
{
httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "abcdef" });
await httpContext.Response.WriteAsync(expectedResponseBody);
}); });
}); });
}).Build();
app.Run(async (httpContext) => await host.StartAsync();
{
httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "abcdef" });
await httpContext.Response.WriteAsync(expectedResponseBody); using (var server = host.GetTestServer())
});
});
using (var server = new TestServer(builder))
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -280,49 +316,56 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task DoesNotClearCacheHeaders_WhenResponseHasAlreadyStarted() public async Task DoesNotClearCacheHeaders_WhenResponseHasAlreadyStarted()
{ {
var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R"); var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.Use(async (httpContext, next) => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
Exception exception = null; app.Use(async (httpContext, next) =>
try
{ {
await next(); Exception exception = null;
} try
catch (InvalidOperationException ex) {
await next();
}
catch (InvalidOperationException ex)
{
exception = ex;
}
Assert.NotNull(exception);
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
exception = ex; innerAppBuilder.Run(async (httpContext) =>
} {
await httpContext.Response.WriteAsync("Handled error in a custom way.");
});
});
Assert.NotNull(exception); app.Run(async (httpContext) =>
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{ {
await httpContext.Response.WriteAsync("Handled error in a custom way."); httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "abcdef" });
await httpContext.Response.WriteAsync("Hello");
throw new InvalidOperationException("Something bad happened");
}); });
}); });
}).Build();
app.Run(async (httpContext) => await host.StartAsync();
{
httpContext.Response.Headers.Add("Cache-Control", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Pragma", new[] { "max-age=3600" });
httpContext.Response.Headers.Add("Expires", new[] { expiresTime });
httpContext.Response.Headers.Add("ETag", new[] { "abcdef" });
await httpContext.Response.WriteAsync("Hello"); using (var server = host.GetTestServer())
throw new InvalidOperationException("Something bad happened");
});
});
using (var server = new TestServer(builder))
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -350,25 +393,33 @@ namespace Microsoft.AspNetCore.Diagnostics
// Arrange // Arrange
DiagnosticListener diagnosticListener = null; DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>(); webHostBuilder
.UseTestServer()
app.UseExceptionHandler("/handle-errors"); .Configure(app =>
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
innerAppBuilder.Run(async (httpContext) => diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{ {
await httpContext.Response.WriteAsync("Handled error in a custom way."); innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync("Handled error in a custom way.");
});
});
app.Run(context =>
{
throw new Exception("Test exception");
}); });
}); });
app.Run(context => }).Build();
{
throw new Exception("Test exception"); await host.StartAsync();
});
}); var server = host.GetTestServer();
var server = new TestServer(builder);
var listener = new TestDiagnosticListener(); var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener); diagnosticListener.SubscribeWithAdapter(listener);
@ -395,15 +446,20 @@ namespace Microsoft.AspNetCore.Diagnostics
// Arrange // Arrange
DiagnosticListener diagnosticListener = null; DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>(); webHostBuilder
app.UseExceptionHandler(); .UseTestServer()
}); .Configure(app =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseExceptionHandler();
});
}).Build();
// Act // Act
var exception = Assert.Throws<InvalidOperationException>(() => new TestServer(builder)); var exception = Assert.Throws<InvalidOperationException>(() => host.Start());
// Assert // Assert
Assert.Equal("An error occurred when configuring the exception handler middleware. " + Assert.Equal("An error occurred when configuring the exception handler middleware. " +

209
src/Middleware/Diagnostics/test/UnitTests/StatusCodeMiddlewareTest.cs
View File

@ -10,6 +10,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Diagnostics namespace Microsoft.AspNetCore.Diagnostics
@ -21,36 +22,44 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
var expectedStatusCode = 432; var expectedStatusCode = 432;
var destination = "/location"; var destination = "/location";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseStatusCodePagesWithRedirects("/errorPage?id={0}"); webHostBuilder
.UseTestServer()
app.Map(destination, (innerAppBuilder) => .Configure(app =>
{ {
innerAppBuilder.Run((httpContext) => app.UseStatusCodePagesWithRedirects("/errorPage?id={0}");
app.Map(destination, (innerAppBuilder) =>
{ {
httpContext.Response.StatusCode = expectedStatusCode; innerAppBuilder.Run((httpContext) =>
return Task.FromResult(1); {
httpContext.Response.StatusCode = expectedStatusCode;
return Task.FromResult(1);
});
});
app.Map("/errorPage", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync(httpContext.Request.QueryString.Value);
});
});
app.Run((context) =>
{
throw new InvalidOperationException($"Invalid input provided. {context.Request.Path}");
}); });
}); });
}).Build();
app.Map("/errorPage", (innerAppBuilder) => await host.StartAsync();
{
innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync(httpContext.Request.QueryString.Value);
});
});
app.Run((context) =>
{
throw new InvalidOperationException($"Invalid input provided. {context.Request.Path}");
});
});
var expectedQueryString = $"?id={expectedStatusCode}"; var expectedQueryString = $"?id={expectedStatusCode}";
var expectedUri = $"/errorPage{expectedQueryString}"; var expectedUri = $"/errorPage{expectedQueryString}";
using var server = new TestServer(builder); using var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(destination); var response = await client.GetAsync(destination);
Assert.Equal(HttpStatusCode.Found, response.StatusCode); Assert.Equal(HttpStatusCode.Found, response.StatusCode);
@ -67,49 +76,56 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
var expectedStatusCode = 432; var expectedStatusCode = 432;
var destination = "/location"; var destination = "/location";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.Use(async (context, next) => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
var beforeNext = context.Request.QueryString; app.Use(async (context, next) =>
await next();
var afterNext = context.Request.QueryString;
Assert.Equal(beforeNext, afterNext);
});
app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}");
app.Map(destination, (innerAppBuilder) =>
{
innerAppBuilder.Run((httpContext) =>
{ {
httpContext.Response.StatusCode = expectedStatusCode; var beforeNext = context.Request.QueryString;
return Task.FromResult(1); await next();
var afterNext = context.Request.QueryString;
Assert.Equal(beforeNext, afterNext);
});
app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}");
app.Map(destination, (innerAppBuilder) =>
{
innerAppBuilder.Run((httpContext) =>
{
httpContext.Response.StatusCode = expectedStatusCode;
return Task.FromResult(1);
});
});
app.Map("/errorPage", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
app.Run((context) =>
{
throw new InvalidOperationException("Invalid input provided.");
}); });
}); });
}).Build();
app.Map("/errorPage", (innerAppBuilder) => await host.StartAsync();
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
app.Run((context) => using var server = host.GetTestServer();
{
throw new InvalidOperationException("Invalid input provided.");
});
});
using var server = new TestServer(builder);
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(destination + "?name=James"); var response = await client.GetAsync(destination + "?name=James");
var content = await response.Content.ReadAsStringAsync(); var content = await response.Content.ReadAsStringAsync();
@ -121,50 +137,57 @@ namespace Microsoft.AspNetCore.Diagnostics
{ {
var expectedStatusCode = 432; var expectedStatusCode = 432;
var destination = "/location"; var destination = "/location";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}"); webHostBuilder
.UseTestServer()
app.Use((context, next) => .Configure(app =>
{ {
Assert.Empty(context.Request.RouteValues); app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}");
Assert.Null(context.GetEndpoint());
return next();
});
app.Map(destination, (innerAppBuilder) => app.Use((context, next) =>
{
innerAppBuilder.Run((httpContext) =>
{ {
httpContext.SetEndpoint(new Endpoint((_) => Task.CompletedTask, new EndpointMetadataCollection(), "Test")); Assert.Empty(context.Request.RouteValues);
httpContext.Request.RouteValues["John"] = "Doe"; Assert.Null(context.GetEndpoint());
httpContext.Response.StatusCode = expectedStatusCode; return next();
return Task.CompletedTask; });
app.Map(destination, (innerAppBuilder) =>
{
innerAppBuilder.Run((httpContext) =>
{
httpContext.SetEndpoint(new Endpoint((_) => Task.CompletedTask, new EndpointMetadataCollection(), "Test"));
httpContext.Request.RouteValues["John"] = "Doe";
httpContext.Response.StatusCode = expectedStatusCode;
return Task.CompletedTask;
});
});
app.Map("/errorPage", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
app.Run((context) =>
{
throw new InvalidOperationException("Invalid input provided.");
}); });
}); });
}).Build();
app.Map("/errorPage", (innerAppBuilder) => await host.StartAsync();
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
app.Run((context) => using var server = host.GetTestServer();
{
throw new InvalidOperationException("Invalid input provided.");
});
});
using var server = new TestServer(builder);
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(destination + "?name=James"); var response = await client.GetAsync(destination + "?name=James");
var content = await response.Content.ReadAsStringAsync(); var content = await response.Content.ReadAsStringAsync();

17
src/Middleware/Diagnostics/test/testassets/DatabaseErrorPageSample/Startup.cs
View File

@ -4,6 +4,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace DatabaseErrorPageSample namespace DatabaseErrorPageSample
{ {
@ -26,15 +27,19 @@ namespace DatabaseErrorPageSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }

17
src/Middleware/Diagnostics/test/testassets/DeveloperExceptionPageSample/Startup.cs
View File

@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.Routing.Patterns; using Microsoft.AspNetCore.Routing.Patterns;
using Microsoft.Extensions.Hosting;
namespace DeveloperExceptionPageSample namespace DeveloperExceptionPageSample
{ {
@ -44,15 +45,19 @@ namespace DeveloperExceptionPageSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

18
src/Middleware/Diagnostics/test/testassets/ExceptionHandlerSample/Startup.cs
View File

@ -1,10 +1,12 @@
using System; using System;
using System.Text.Encodings.Web; using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics; using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Hosting;
namespace ExceptionHandlerSample namespace ExceptionHandlerSample
{ {
@ -56,15 +58,19 @@ namespace ExceptionHandlerSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

18
src/Middleware/Diagnostics/test/testassets/StatusCodePagesSample/Startup.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Hosting;
namespace StatusCodePagesSample namespace StatusCodePagesSample
{ {
@ -102,15 +103,18 @@ namespace StatusCodePagesSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.Build(); .UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

19
src/Middleware/Diagnostics/test/testassets/WelcomePageSample/Startup.cs
View File

@ -1,5 +1,7 @@
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
namespace WelcomePageSample namespace WelcomePageSample
{ {
@ -10,15 +12,18 @@ namespace WelcomePageSample
app.UseWelcomePage(); app.UseWelcomePage();
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseIISIntegration() {
.UseStartup<Startup>() webHostBuilder
.Build(); .UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

140
src/Middleware/HeaderPropagation/test/HeaderPropagationIntegrationTest.cs
View File

@ -12,6 +12,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.HeaderPropagation.Tests namespace Microsoft.AspNetCore.HeaderPropagation.Tests
@ -24,34 +25,41 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
// Arrange // Arrange
Exception captured = null; Exception captured = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHttpClient("test").AddHeaderPropagation(); webHostBuilder
services.AddHeaderPropagation(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.Headers.Add("X-TraceId"); services.AddHttpClient("test").AddHeaderPropagation();
}); services.AddHeaderPropagation(options =>
}) {
.Configure(app => options.Headers.Add("X-TraceId");
{ });
// note: no header propagation middleware })
.Configure(app =>
app.Run(async context =>
{ {
try // note: no header propagation middleware
{
var client = context.RequestServices.GetRequiredService<IHttpClientFactory>().CreateClient("test");
await client.GetAsync("http://localhost/"); // will throw
}
catch (Exception ex)
{
captured = ex;
}
});
});
var server = new TestServer(builder); app.Run(async context =>
{
try
{
var client = context.RequestServices.GetRequiredService<IHttpClientFactory>().CreateClient("test");
await client.GetAsync("http://localhost/"); // will throw
}
catch (Exception ex)
{
captured = ex;
}
});
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(); var request = new HttpRequestMessage();
@ -96,10 +104,10 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{ {
// Arrange // Arrange
var handler = new SimpleHandler(); var handler = new SimpleHandler();
var builder = CreateBuilder(c => using var host = await CreateHost(c =>
c.Headers.Add("in", "out"), c.Headers.Add("in", "out"),
handler); handler);
var server = new TestServer(builder); var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(); var request = new HttpRequestMessage();
@ -119,13 +127,13 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{ {
// Arrange // Arrange
var handler = new SimpleHandler(); var handler = new SimpleHandler();
var builder = CreateBuilder(c => using var host = await CreateHost(c =>
{ {
c.Headers.Add("first"); c.Headers.Add("first");
c.Headers.Add("second"); c.Headers.Add("second");
}, },
handler); handler);
var server = new TestServer(builder); var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(); var request = new HttpRequestMessage();
@ -144,15 +152,20 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
} }
[Fact] [Fact]
public void Builder_UseHeaderPropagation_Without_AddHeaderPropagation_Throws() public async Task Builder_UseHeaderPropagation_Without_AddHeaderPropagation_Throws()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHeaderPropagation(); webHostBuilder
}); .UseTestServer()
.Configure(app =>
{
app.UseHeaderPropagation();
});
}).Build();
var exception = Assert.Throws<InvalidOperationException>(() => new TestServer(builder)); var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync());
Assert.Equal( Assert.Equal(
"Unable to find the required services. Please add all the required services by calling 'IServiceCollection.AddHeaderPropagation' inside the call to 'ConfigureServices(...)' in the application startup code.", "Unable to find the required services. Please add all the required services by calling 'IServiceCollection.AddHeaderPropagation' inside the call to 'ConfigureServices(...)' in the application startup code.",
exception.Message); exception.Message);
@ -163,11 +176,11 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{ {
// Arrange // Arrange
var handler = new SimpleHandler(); var handler = new SimpleHandler();
var builder = CreateBuilder( using var host = await CreateHost(
c => c.Headers.Add("in", "out"), c => c.Headers.Add("in", "out"),
handler, handler,
c => c.Headers.Add("out", "different")); c => c.Headers.Add("out", "different"));
var server = new TestServer(builder); var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(); var request = new HttpRequestMessage();
@ -182,32 +195,41 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
Assert.Equal(new[] { "test" }, handler.Headers.GetValues("different")); Assert.Equal(new[] { "test" }, handler.Headers.GetValues("different"));
} }
private IWebHostBuilder CreateBuilder(Action<HeaderPropagationOptions> configure, HttpMessageHandler primaryHandler, Action<HeaderPropagationMessageHandlerOptions> configureClient = null) private async Task<IHost> CreateHost(Action<HeaderPropagationOptions> configure, HttpMessageHandler primaryHandler, Action<HeaderPropagationMessageHandlerOptions> configureClient = null)
{ {
return new WebHostBuilder() var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHeaderPropagation(); webHostBuilder
app.UseMiddleware<SimpleMiddleware>(); .UseTestServer()
}) .Configure(app =>
.ConfigureServices(services => {
{ app.UseHeaderPropagation();
services.AddHeaderPropagation(configure); app.UseMiddleware<SimpleMiddleware>();
var client = services.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com")) })
.ConfigureHttpMessageHandlerBuilder(b => .ConfigureServices(services =>
{ {
b.PrimaryHandler = primaryHandler; services.AddHeaderPropagation(configure);
}); var client = services.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
.ConfigureHttpMessageHandlerBuilder(b =>
{
b.PrimaryHandler = primaryHandler;
});
if (configureClient != null) if (configureClient != null)
{ {
client.AddHeaderPropagation(configureClient); client.AddHeaderPropagation(configureClient);
} }
else else
{ {
client.AddHeaderPropagation(); client.AddHeaderPropagation();
} }
}); });
}).Build();
await host.StartAsync();
return host;
} }
private class SimpleHandler : DelegatingHandler private class SimpleHandler : DelegatingHandler

100
src/Middleware/HealthChecks/test/UnitTests/HealthCheckEndpointRouteBuilderExtensionsTest.cs
View File

@ -13,6 +13,7 @@ using Moq;
using Xunit; using Xunit;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.Diagnostics.HealthChecks namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
{ {
@ -21,21 +22,26 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact] [Fact]
public void ThrowFriendlyErrorWhenServicesNotRegistered() public void ThrowFriendlyErrorWhenServicesNotRegistered()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRouting(); webHostBuilder
app.UseEndpoints(endpoints => .UseTestServer()
.Configure(app =>
{ {
endpoints.MapHealthChecks("/healthz"); app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/healthz");
});
})
.ConfigureServices(services =>
{
services.AddRouting();
}); });
}) }).Build();
.ConfigureServices(services =>
{
services.AddRouting();
});
var ex = Assert.Throws<InvalidOperationException>(() => new TestServer(builder)); var ex = Assert.Throws<InvalidOperationException>(() => host.Start());
Assert.Equal( Assert.Equal(
"Unable to find the required services. Please add all the required services by calling " + "Unable to find the required services. Please add all the required services by calling " +
@ -48,21 +54,29 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
public async Task MapHealthChecks_ReturnsOk() public async Task MapHealthChecks_ReturnsOk()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRouting(); webHostBuilder
app.UseEndpoints(endpoints => .UseTestServer()
.Configure(app =>
{ {
endpoints.MapHealthChecks("/healthz"); app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/healthz");
});
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
}); });
}) }).Build();
.ConfigureServices(services =>
{ await host.StartAsync();
services.AddRouting();
services.AddHealthChecks(); var server = host.GetTestServer();
});
var server = new TestServer(builder);
var client = server.CreateClient(); var client = server.CreateClient();
// Act // Act
@ -78,28 +92,36 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
public async Task MapHealthChecks_WithOptions_ReturnsOk() public async Task MapHealthChecks_WithOptions_ReturnsOk()
{ {
// Arrange // Arrange
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRouting(); webHostBuilder
app.UseEndpoints(endpoints => .UseTestServer()
.Configure(app =>
{ {
endpoints.MapHealthChecks("/healthz", new HealthCheckOptions app.UseRouting();
app.UseEndpoints(endpoints =>
{ {
ResponseWriter = async (context, report) => endpoints.MapHealthChecks("/healthz", new HealthCheckOptions
{ {
context.Response.ContentType = "text/plain"; ResponseWriter = async (context, report) =>
await context.Response.WriteAsync("Custom!"); {
} context.Response.ContentType = "text/plain";
await context.Response.WriteAsync("Custom!");
}
});
}); });
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
}); });
}) }).Build();
.ConfigureServices(services =>
{ await host.StartAsync();
services.AddRouting();
services.AddHealthChecks(); var server = host.GetTestServer();
});
var server = new TestServer(builder);
var client = server.CreateClient(); var client = server.CreateClient();
// Act // Act

55
src/Middleware/HealthChecks/test/UnitTests/HealthCheckMiddlewareSampleTest.cs
View File

@ -1,10 +1,11 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Net; using System.Net;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Diagnostics.HealthChecks namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
@ -14,10 +15,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact] [Fact]
public async Task BasicStartup() public async Task BasicStartup()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.UseStartup<HealthChecksSample.BasicStartup>(); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup<HealthChecksSample.BasicStartup>();
}).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/health"); var response = await client.GetAsync("/health");
@ -29,10 +37,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact] [Fact]
public async Task CustomWriterStartup() public async Task CustomWriterStartup()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.UseStartup<HealthChecksSample.CustomWriterStartup>(); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup<HealthChecksSample.CustomWriterStartup>();
}).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/health"); var response = await client.GetAsync("/health");
@ -45,10 +60,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact] [Fact]
public async Task LivenessProbeStartup_Liveness() public async Task LivenessProbeStartup_Liveness()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.UseStartup<HealthChecksSample.LivenessProbeStartup>(); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup<HealthChecksSample.LivenessProbeStartup>();
}).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/health/live"); var response = await client.GetAsync("/health/live");
@ -60,10 +82,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact] [Fact]
public async Task LivenessProbeStartup_Readiness() public async Task LivenessProbeStartup_Readiness()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.UseStartup<HealthChecksSample.LivenessProbeStartup>(); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup<HealthChecksSample.LivenessProbeStartup>();
}).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/health/ready"); var response = await client.GetAsync("/health/ready");

803
src/Middleware/HealthChecks/test/UnitTests/HealthCheckMiddlewareTests.cs
View File

File diff suppressed because it is too large Load Diff

28
src/Middleware/HealthChecks/test/testassets/HealthChecksSample/Program.cs
View File

@ -1,8 +1,10 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace HealthChecksSample namespace HealthChecksSample
@ -25,12 +27,12 @@ namespace HealthChecksSample
}; };
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
BuildWebHost(args).Run(); return BuildWebHost(args).RunAsync();
} }
public static IWebHost BuildWebHost(string[] args) public static IHost BuildWebHost(string[] args)
{ {
var config = new ConfigurationBuilder() var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory()) .SetBasePath(Directory.GetCurrentDirectory())
@ -45,16 +47,20 @@ namespace HealthChecksSample
startupType = typeof(BasicStartup); startupType = typeof(BasicStartup);
} }
return new WebHostBuilder() return new HostBuilder()
.UseConfiguration(config) .ConfigureWebHost(webHostBuilder =>
.ConfigureLogging(builder =>
{ {
builder.SetMinimumLevel(LogLevel.Trace); webHostBuilder
builder.AddConfiguration(config); .UseConfiguration(config)
builder.AddConsole(); .ConfigureLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddConfiguration(config);
builder.AddConsole();
})
.UseKestrel()
.UseStartup(startupType);
}) })
.UseKestrel()
.UseStartup(startupType)
.Build(); .Build();
} }

40
src/Middleware/HostFiltering/sample/Program.cs
View File

@ -1,35 +1,41 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace HostFilteringSample namespace HostFilteringSample
{ {
public class Program public class Program
{ {
public static void Main(string[] args) public static Task Main(string[] args)
{ {
BuildWebHost(args).Run(); return BuildWebHost(args).RunAsync();
} }
public static IWebHost BuildWebHost(string[] args) public static IHost BuildWebHost(string[] args)
{ {
var hostBuilder = new WebHostBuilder() var hostBuilder = new HostBuilder()
.ConfigureLogging((_, factory) => .ConfigureWebHost(webHostBuilder =>
{ {
factory.SetMinimumLevel(LogLevel.Debug); webHostBuilder
factory.AddConsole(); .ConfigureLogging((_, factory) =>
}) {
.ConfigureAppConfiguration((hostingContext, config) => factory.SetMinimumLevel(LogLevel.Debug);
{ factory.AddConsole();
var env = hostingContext.HostingEnvironment; })
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .ConfigureAppConfiguration((hostingContext, config) =>
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true); {
}) var env = hostingContext.HostingEnvironment;
.UseKestrel() config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.UseStartup<Startup>(); .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
})
.UseKestrel()
.UseStartup<Startup>();
});
return hostBuilder.Build(); return hostBuilder.Build();
} }

249
src/Middleware/HostFiltering/test/HostFilteringMiddlewareTests.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives; using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
@ -21,12 +22,20 @@ namespace Microsoft.AspNetCore.HostFiltering
[Fact] [Fact]
public async Task MissingConfigThrows() public async Task MissingConfigThrows()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHostFiltering(); webHostBuilder
}); .UseTestServer()
await Assert.ThrowsAsync<InvalidOperationException>(() => new TestServer(builder).SendAsync(_ => { })); .Configure(app =>
{
app.UseHostFiltering();
});
}).Build();
await host.StartAsync();
await Assert.ThrowsAsync<InvalidOperationException>(() => host.GetTestServer().SendAsync(_ => { }));
} }
[Theory] [Theory]
@ -34,30 +43,38 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData(false, 400)] [InlineData(false, 400)]
public async Task AllowsMissingHost(bool allowed, int status) public async Task AllowsMissingHost(bool allowed, int status)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHostFiltering(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.AllowEmptyHosts = allowed; services.AddHostFiltering(options =>
options.AllowedHosts.Add("Localhost"); {
}); options.AllowEmptyHosts = allowed;
}) options.AllowedHosts.Add("Localhost");
.Configure(app => });
{ })
app.Use((ctx, next) => .Configure(app =>
{ {
ctx.Request.Headers.Remove(HeaderNames.Host); app.Use((ctx, next) =>
return next(); {
ctx.Request.Headers.Remove(HeaderNames.Host);
return next();
});
app.UseHostFiltering();
app.Run(c =>
{
Assert.False(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
return Task.CompletedTask;
});
}); });
app.UseHostFiltering(); }).Build();
app.Run(c =>
{ await host.StartAsync();
Assert.False(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
return Task.CompletedTask; var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var response = await server.CreateClient().GetAsync("/"); var response = await server.CreateClient().GetAsync("/");
Assert.Equal(status, (int)response.StatusCode); Assert.Equal(status, (int)response.StatusCode);
} }
@ -67,32 +84,40 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData(false, 400)] [InlineData(false, 400)]
public async Task AllowsEmptyHost(bool allowed, int status) public async Task AllowsEmptyHost(bool allowed, int status)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHostFiltering(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.AllowEmptyHosts = allowed; services.AddHostFiltering(options =>
options.AllowedHosts.Add("Localhost"); {
}); options.AllowEmptyHosts = allowed;
}) options.AllowedHosts.Add("Localhost");
.Configure(app => });
{ })
app.Use((ctx, next) => .Configure(app =>
{ {
ctx.Request.Headers[HeaderNames.Host] = ""; app.Use((ctx, next) =>
return next(); {
ctx.Request.Headers[HeaderNames.Host] = "";
return next();
});
app.UseHostFiltering();
app.Run(c =>
{
Assert.True(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
Assert.True(StringValues.Equals("", host));
return Task.CompletedTask;
});
app.Run(c => Task.CompletedTask);
}); });
app.UseHostFiltering(); }).Build();
app.Run(c =>
{ await host.StartAsync();
Assert.True(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
Assert.True(StringValues.Equals("", host)); var server = host.GetTestServer();
return Task.CompletedTask;
});
app.Run(c => Task.CompletedTask);
});
var server = new TestServer(builder);
var response = await server.CreateClient().GetAsync("/"); var response = await server.CreateClient().GetAsync("/");
Assert.Equal(status, (int)response.StatusCode); Assert.Equal(status, (int)response.StatusCode);
} }
@ -113,29 +138,37 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData("xn--c1yn36f:443", "點看")] [InlineData("xn--c1yn36f:443", "點看")]
[InlineData("[::ABC]", "[::aBc]")] [InlineData("[::ABC]", "[::aBc]")]
[InlineData("[::1]:80", "[::1]")] [InlineData("[::1]:80", "[::1]")]
public async Task AllowsSpecifiedHost(string host, string allowedHost) public async Task AllowsSpecifiedHost(string hosturl, string allowedHost)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHostFiltering(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); services.AddHostFiltering(options =>
}); {
}) options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
.Configure(app => });
{ })
app.Use((ctx, next) => .Configure(app =>
{ {
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI app.Use((ctx, next) =>
// and that would over-normalize some of our test conditions like casing. {
ctx.Request.Headers[HeaderNames.Host] = host; // TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
return next(); // and that would over-normalize some of our test conditions like casing.
ctx.Request.Headers[HeaderNames.Host] = hosturl;
return next();
});
app.UseHostFiltering();
app.Run(c => Task.CompletedTask);
}); });
app.UseHostFiltering(); }).Build();
app.Run(c => Task.CompletedTask);
}); await host.StartAsync();
var server = new TestServer(builder);
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync(); var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(200, (int)response.StatusCode); Assert.Equal(200, (int)response.StatusCode);
} }
@ -157,29 +190,37 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData("點看", "點看")] [InlineData("點看", "點看")]
[InlineData("[::1", "[::1]")] [InlineData("[::1", "[::1]")]
[InlineData("[::1:80", "[::1]")] [InlineData("[::1:80", "[::1]")]
public async Task RejectsMismatchedHosts(string host, string allowedHost) public async Task RejectsMismatchedHosts(string hosturl, string allowedHost)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHostFiltering(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); services.AddHostFiltering(options =>
}); {
}) options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
.Configure(app => });
{ })
app.Use((ctx, next) => .Configure(app =>
{ {
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI app.Use((ctx, next) =>
// and that would reject some of our test conditions. {
ctx.Request.Headers[HeaderNames.Host] = host; // TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
return next(); // and that would reject some of our test conditions.
ctx.Request.Headers[HeaderNames.Host] = hosturl;
return next();
});
app.UseHostFiltering();
app.Run(c => throw new NotImplementedException("App"));
}); });
app.UseHostFiltering(); }).Build();
app.Run(c => throw new NotImplementedException("App"));
}); await host.StartAsync();
var server = new TestServer(builder);
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync(); var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(400, (int)response.StatusCode); Assert.Equal(400, (int)response.StatusCode);
} }
@ -191,26 +232,34 @@ namespace Microsoft.AspNetCore.HostFiltering
config["AllowedHosts"] = "localhost"; config["AllowedHosts"] = "localhost";
var currentHost = "otherHost"; var currentHost = "otherHost";
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHostFiltering(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.AllowedHosts = new[] { config["AllowedHosts"] }; services.AddHostFiltering(options =>
}); {
services.AddSingleton<IOptionsChangeTokenSource<HostFilteringOptions>>(new ConfigurationChangeTokenSource<HostFilteringOptions>(config)); options.AllowedHosts = new[] { config["AllowedHosts"] };
}) });
.Configure(app => services.AddSingleton<IOptionsChangeTokenSource<HostFilteringOptions>>(new ConfigurationChangeTokenSource<HostFilteringOptions>(config));
{ })
app.Use((ctx, next) => .Configure(app =>
{ {
ctx.Request.Headers[HeaderNames.Host] = currentHost; app.Use((ctx, next) =>
return next(); {
ctx.Request.Headers[HeaderNames.Host] = currentHost;
return next();
});
app.UseHostFiltering();
app.Run(c => Task.CompletedTask);
}); });
app.UseHostFiltering(); }).Build();
app.Run(c => Task.CompletedTask);
}); await host.StartAsync();
var server = new TestServer(builder);
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync(); var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(400, (int)response.StatusCode); Assert.Equal(400, (int)response.StatusCode);

18
src/Middleware/HttpOverrides/sample/Startup.cs
View File

@ -1,7 +1,9 @@
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpOverrides; using Microsoft.AspNetCore.HttpOverrides;
using Microsoft.Extensions.Hosting;
namespace HttpOverridesSample namespace HttpOverridesSample
{ {
@ -30,15 +32,19 @@ namespace HttpOverridesSample
} }
// Entry point for the application. // Entry point for the application.
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
// .UseIIS() // This repo can no longer reference IIS because IISIntegration depends on it. {
.UseStartup<Startup>() webHostBuilder
.UseKestrel()
// .UseIIS() // This repo can no longer reference IIS because IISIntegration depends on it.
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

203
src/Middleware/HttpOverrides/test/CertificateForwardingTest.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options; using Microsoft.Extensions.Options;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
using Xunit; using Xunit;
@ -42,26 +43,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task VerifyHeaderIsUsedIfNoCertificateAlreadySet() public async Task VerifyHeaderIsUsedIfNoCertificateAlreadySet()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddCertificateForwarding(options => { }); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); services.AddCertificateForwarding(options => { });
await next(); })
}); .Configure(app =>
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{ {
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku); app.Use(async (context, next) =>
await next(); {
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -72,27 +81,35 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task VerifyHeaderOverridesCertificateEvenAlreadySet() public async Task VerifyHeaderOverridesCertificateEvenAlreadySet()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddCertificateForwarding(options => { }); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); services.AddCertificateForwarding(options => { });
context.Connection.ClientCertificate = Certificates.SelfSignedNotYetValid; })
await next(); .Configure(app =>
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{ {
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku); app.Use(async (context, next) =>
await next(); {
Assert.Null(context.Connection.ClientCertificate);
context.Connection.ClientCertificate = Certificates.SelfSignedNotYetValid;
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -103,26 +120,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task VerifySettingTheAzureHeaderOnTheForwarderOptionsWorks() public async Task VerifySettingTheAzureHeaderOnTheForwarderOptionsWorks()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddCertificateForwarding(options => options.CertificateHeader = "X-ARR-ClientCert"); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); services.AddCertificateForwarding(options => options.CertificateHeader = "X-ARR-ClientCert");
await next(); })
}); .Configure(app =>
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{ {
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku); app.Use(async (context, next) =>
await next(); {
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -133,26 +158,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task VerifyACustomHeaderFailsIfTheHeaderIsNotPresent() public async Task VerifyACustomHeaderFailsIfTheHeaderIsNotPresent()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddCertificateForwarding(options => options.CertificateHeader = "some-random-header"); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); services.AddCertificateForwarding(options => options.CertificateHeader = "some-random-header");
await next(); })
}); .Configure(app =>
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); app.Use(async (context, next) =>
await next(); {
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -163,26 +196,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task VerifyArrHeaderEncodedCertFailsOnBadEncoding() public async Task VerifyArrHeaderEncodedCertFailsOnBadEncoding()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddCertificateForwarding(options => { }); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); services.AddCertificateForwarding(options => { });
await next(); })
}); .Configure(app =>
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{ {
Assert.Null(context.Connection.ClientCertificate); app.Use(async (context, next) =>
await next(); {
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {

673
src/Middleware/HttpOverrides/test/ForwardedHeadersMiddlewareTest.cs
View File

@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
using Xunit; using Xunit;
@ -19,15 +20,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task XForwardedForDefaultSettingsChangeRemoteIpAndPort() public async Task XForwardedForDefaultSettingsChangeRemoteIpAndPort()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -46,16 +55,24 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(1, "11.111.111.11.12345", "10.0.0.1", 99)] // Invalid [InlineData(1, "11.111.111.11.12345", "10.0.0.1", 99)] // Invalid
public async Task XForwardedForFirstValueIsInvalid(int limit, string header, string expectedIp, int expectedPort) public async Task XForwardedForFirstValueIsInvalid(int limit, string header, string expectedIp, int expectedPort)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor, app.UseForwardedHeaders(new ForwardedHeadersOptions
ForwardLimit = limit, {
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
ForwardLimit = limit,
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -92,20 +109,28 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(3, "13.113.113.13:34567, 12.112.112.12:23456, 11.111.111.11:12345", "13.113.113.13", 34567, "", true)] [InlineData(3, "13.113.113.13:34567, 12.112.112.12:23456, 11.111.111.11:12345", "13.113.113.13", 34567, "", true)]
public async Task XForwardedForForwardLimit(int limit, string header, string expectedIp, int expectedPort, string remainingHeader, bool requireSymmetry) public async Task XForwardedForForwardLimit(int limit, string header, string expectedIp, int expectedPort, string remainingHeader, bool requireSymmetry)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor, var options = new ForwardedHeadersOptions
RequireHeaderSymmetry = requireSymmetry, {
ForwardLimit = limit, ForwardedHeaders = ForwardedHeaders.XForwardedFor,
}; RequireHeaderSymmetry = requireSymmetry,
options.KnownProxies.Clear(); ForwardLimit = limit,
options.KnownNetworks.Clear(); };
app.UseForwardedHeaders(options); options.KnownProxies.Clear();
}); options.KnownNetworks.Clear();
var server = new TestServer(builder); app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -127,15 +152,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("::", false)] [InlineData("::", false)]
public async Task XForwardedForLoopback(string originalIp, bool expectForwarded) public async Task XForwardedForLoopback(string originalIp, bool expectForwarded)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor, app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -185,22 +218,30 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(3, "13.113.113.13;34567, 12.112.112.12:23456, 11.111.111.11:12345", "10.0.0.1,11.111.111.11,12.112.112.12", "12.112.112.12", 23456, true)] // Invalid 3rd IP [InlineData(3, "13.113.113.13;34567, 12.112.112.12:23456, 11.111.111.11:12345", "10.0.0.1,11.111.111.11,12.112.112.12", "12.112.112.12", 23456, true)] // Invalid 3rd IP
public async Task XForwardedForForwardKnownIps(int limit, string header, string knownIPs, string expectedIp, int expectedPort, bool requireSymmetry) public async Task XForwardedForForwardKnownIps(int limit, string header, string knownIPs, string expectedIp, int expectedPort, bool requireSymmetry)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor, var options = new ForwardedHeadersOptions
RequireHeaderSymmetry = requireSymmetry, {
ForwardLimit = limit, ForwardedHeaders = ForwardedHeaders.XForwardedFor,
}; RequireHeaderSymmetry = requireSymmetry,
foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text))) ForwardLimit = limit,
{ };
options.KnownProxies.Add(ip); foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text)))
} {
app.UseForwardedHeaders(options); options.KnownProxies.Add(ip);
}); }
var server = new TestServer(builder); app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -216,15 +257,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task XForwardedForOverrideBadIpDoesntChangeRemoteIp() public async Task XForwardedForOverrideBadIpDoesntChangeRemoteIp()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -237,15 +286,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task XForwardedHostOverrideChangesRequestHost() public async Task XForwardedHostOverrideChangesRequestHost()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -291,29 +348,37 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Theory] [Theory]
[MemberData(nameof(HostHeaderData))] [MemberData(nameof(HostHeaderData))]
public async Task XForwardedHostAllowsValidCharacters(string host) public async Task XForwardedHostAllowsValidCharacters(string hostHeader)
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost
});
app.Run(context =>
{
Assert.Equal(hostHeader, context.Request.Host.ToString());
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal(host, context.Request.Host.ToString()); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
await server.SendAsync(c => await server.SendAsync(c =>
{ {
c.Request.Headers["X-Forwarded-Host"] = host; c.Request.Headers["X-Forwarded-Host"] = hostHeader;
}); });
Assert.True(assertsExecuted); Assert.True(assertsExecuted);
} }
@ -368,29 +433,37 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Theory] [Theory]
[MemberData(nameof(HostHeaderInvalidData))] [MemberData(nameof(HostHeaderInvalidData))]
public async Task XForwardedHostFailsForInvalidCharacters(string host) public async Task XForwardedHostFailsForInvalidCharacters(string hostHeader)
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost
});
app.Run(context =>
{
Assert.NotEqual(hostHeader, context.Request.Host.Value);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.NotEqual(host, context.Request.Host.Value); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
await server.SendAsync(c => await server.SendAsync(c =>
{ {
c.Request.Headers["X-Forwarded-Host"] = host; c.Request.Headers["X-Forwarded-Host"] = hostHeader;
}); });
Assert.True(assertsExecuted); Assert.True(assertsExecuted);
} }
@ -411,28 +484,36 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("xn--c1yn36f:443", "點看")] [InlineData("xn--c1yn36f:443", "點看")]
[InlineData("[::ABC]", "[::aBc]")] [InlineData("[::ABC]", "[::aBc]")]
[InlineData("[::1]:80", "[::1]")] [InlineData("[::1]:80", "[::1]")]
public async Task XForwardedHostAllowsSpecifiedHost(string host, string allowedHost) public async Task XForwardedHostAllowsSpecifiedHost(string hostHeader, string allowedHost)
{ {
bool assertsExecuted = false; bool assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost, app.UseForwardedHeaders(new ForwardedHeadersOptions
AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) {
ForwardedHeaders = ForwardedHeaders.XForwardedHost,
AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
});
app.Run(context =>
{
Assert.Equal(hostHeader, context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal(host, context.Request.Headers[HeaderNames.Host]); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var response = await server.SendAsync(ctx => var response = await server.SendAsync(ctx =>
{ {
ctx.Request.Headers["X-forwarded-Host"] = host; ctx.Request.Headers["X-forwarded-Host"] = hostHeader;
}); });
Assert.True(assertsExecuted); Assert.True(assertsExecuted);
} }
@ -454,28 +535,36 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("點看", "點看")] [InlineData("點看", "點看")]
[InlineData("[::1", "[::1]")] [InlineData("[::1", "[::1]")]
[InlineData("[::1:80", "[::1]")] [InlineData("[::1:80", "[::1]")]
public async Task XForwardedHostFailsMismatchedHosts(string host, string allowedHost) public async Task XForwardedHostFailsMismatchedHosts(string hostHeader, string allowedHost)
{ {
bool assertsExecuted = false; bool assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost, app.UseForwardedHeaders(new ForwardedHeadersOptions
AllowedHosts = new[] { allowedHost } {
ForwardedHeaders = ForwardedHeaders.XForwardedHost,
AllowedHosts = new[] { allowedHost }
});
app.Run(context =>
{
Assert.NotEqual<string>(hostHeader, context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.NotEqual<string>(host, context.Request.Headers[HeaderNames.Host]); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var response = await server.SendAsync(ctx => var response = await server.SendAsync(ctx =>
{ {
ctx.Request.Headers["X-forwarded-Host"] = host; ctx.Request.Headers["X-forwarded-Host"] = hostHeader;
}); });
Assert.True(assertsExecuted); Assert.True(assertsExecuted);
} }
@ -484,23 +573,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XForwardedHostStopsAtFirstUnspecifiedHost() public async Task XForwardedHostStopsAtFirstUnspecifiedHost()
{ {
bool assertsExecuted = false; bool assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedHost, app.UseForwardedHeaders(new ForwardedHeadersOptions
ForwardLimit = 10, {
AllowedHosts = new[] { "bar.com", "*.foo.com" } ForwardedHeaders = ForwardedHeaders.XForwardedHost,
ForwardLimit = 10,
AllowedHosts = new[] { "bar.com", "*.foo.com" }
});
app.Run(context =>
{
Assert.Equal("bar.foo.com:432", context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal("bar.foo.com:432", context.Request.Headers[HeaderNames.Host]); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var response = await server.SendAsync(ctx => var response = await server.SendAsync(ctx =>
{ {
ctx.Request.Headers["X-forwarded-Host"] = "stuff:523, bar.foo.com:432, bar.com:80"; ctx.Request.Headers["X-forwarded-Host"] = "stuff:523, bar.foo.com:432, bar.com:80";
@ -518,16 +615,24 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(10, "h3, h2, h1", "h3")] [InlineData(10, "h3, h2, h1", "h3")]
public async Task XForwardedProtoOverrideChangesRequestProtocol(int limit, string header, string expected) public async Task XForwardedProtoOverrideChangesRequestProtocol(int limit, string header, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto, app.UseForwardedHeaders(new ForwardedHeadersOptions
ForwardLimit = limit, {
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
ForwardLimit = limit,
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -559,21 +664,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto
});
app.Run(context =>
{
Assert.Equal(scheme, context.Request.Scheme);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal(scheme, context.Request.Scheme); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
await server.SendAsync(c => await server.SendAsync(c =>
{ {
@ -608,21 +721,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto, app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
});
app.Run(context =>
{
Assert.Equal("http", context.Request.Scheme);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal("http", context.Request.Scheme); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
await server.SendAsync(c => await server.SendAsync(c =>
{ {
@ -642,17 +763,25 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")] [InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")]
public async Task XForwardedProtoOverrideLimitedByXForwardedForCount(int limit, string protoHeader, string forHeader, string expected) public async Task XForwardedProtoOverrideLimitedByXForwardedForCount(int limit, string protoHeader, string forHeader, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor, app.UseForwardedHeaders(new ForwardedHeadersOptions
RequireHeaderSymmetry = true, {
ForwardLimit = limit, ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = true,
ForwardLimit = limit,
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -676,17 +805,25 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")] [InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")]
public async Task XForwardedProtoOverrideCanBeIndependentOfXForwardedForCount(int limit, string protoHeader, string forHeader, string expected) public async Task XForwardedProtoOverrideCanBeIndependentOfXForwardedForCount(int limit, string protoHeader, string forHeader, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor, app.UseForwardedHeaders(new ForwardedHeadersOptions
RequireHeaderSymmetry = false, {
ForwardLimit = limit, ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = false,
ForwardLimit = limit,
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -712,23 +849,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("h2, h1", "E::, D::", "F::", true, "http")] [InlineData("h2, h1", "E::, D::", "F::", true, "http")]
public async Task XForwardedProtoOverrideLimitedByLoopback(string protoHeader, string forHeader, string remoteIp, bool loopback, string expected) public async Task XForwardedProtoOverrideLimitedByLoopback(string protoHeader, string forHeader, string remoteIp, bool loopback, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor, var options = new ForwardedHeadersOptions
RequireHeaderSymmetry = true, {
ForwardLimit = 5, ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
}; RequireHeaderSymmetry = true,
if (!loopback) ForwardLimit = 5,
{ };
options.KnownNetworks.Clear(); if (!loopback)
options.KnownProxies.Clear(); {
} options.KnownNetworks.Clear();
app.UseForwardedHeaders(options); options.KnownProxies.Clear();
}); }
var server = new TestServer(builder); app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -753,15 +898,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task AllForwardsEnabledChangeRequestRemoteIpHostandProtocol() public async Task AllForwardsEnabledChangeRequestRemoteIpHostandProtocol()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.All app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.All
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -778,15 +931,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task AllOptionsDisabledRequestDoesntChange() public async Task AllOptionsDisabledRequestDoesntChange()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.None app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.None
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -803,15 +964,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact] [Fact]
public async Task PartiallyEnabledForwardsPartiallyChangesRequest() public async Task PartiallyEnabledForwardsPartiallyChangesRequest()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -852,12 +1021,20 @@ namespace Microsoft.AspNetCore.HttpOverrides
options.KnownNetworks.Add(new IPNetwork(networkIp, prefixLength)); options.KnownNetworks.Add(new IPNetwork(networkIp, prefixLength));
} }
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseForwardedHeaders(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -872,23 +1049,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(2, "httpa, httpb, httpc", "httpb", "httpa")] [InlineData(2, "httpa, httpb, httpc", "httpb", "httpa")]
public async Task ForwardersWithDIOptionsRunsOnce(int limit, string header, string expectedScheme, string remainingHeader) public async Task ForwardersWithDIOptionsRunsOnce(int limit, string header, string expectedScheme, string remainingHeader)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.Configure<ForwardedHeadersOptions>(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.ForwardedHeaders = ForwardedHeaders.XForwardedProto; services.Configure<ForwardedHeadersOptions>(options =>
options.KnownProxies.Clear(); {
options.KnownNetworks.Clear(); options.ForwardedHeaders = ForwardedHeaders.XForwardedProto;
options.ForwardLimit = limit; options.KnownProxies.Clear();
options.KnownNetworks.Clear();
options.ForwardLimit = limit;
});
})
.Configure(app =>
{
app.UseForwardedHeaders();
app.UseForwardedHeaders();
}); });
}) }).Build();
.Configure(app =>
{ await host.StartAsync();
app.UseForwardedHeaders();
app.UseForwardedHeaders(); var server = host.GetTestServer();
});
var server = new TestServer(builder);
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {
@ -904,20 +1089,28 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(2, "httpa, httpb, httpc", "httpa", "")] [InlineData(2, "httpa, httpb, httpc", "httpa", "")]
public async Task ForwardersWithDirectOptionsRunsTwice(int limit, string header, string expectedScheme, string remainingHeader) public async Task ForwardersWithDirectOptionsRunsTwice(int limit, string header, string expectedScheme, string remainingHeader)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new ForwardedHeadersOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ForwardedHeaders = ForwardedHeaders.XForwardedProto, var options = new ForwardedHeadersOptions
ForwardLimit = limit, {
}; ForwardedHeaders = ForwardedHeaders.XForwardedProto,
options.KnownProxies.Clear(); ForwardLimit = limit,
options.KnownNetworks.Clear(); };
app.UseForwardedHeaders(options); options.KnownProxies.Clear();
app.UseForwardedHeaders(options); options.KnownNetworks.Clear();
}); app.UseForwardedHeaders(options);
var server = new TestServer(builder); app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c => var context = await server.SendAsync(c =>
{ {

175
src/Middleware/HttpOverrides/test/HttpMethodOverrideMiddlewareTest.cs
View File

@ -7,6 +7,7 @@ using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.HttpOverrides namespace Microsoft.AspNetCore.HttpOverrides
@ -17,18 +18,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideHeaderAvaiableChangesRequestMethod() public async Task XHttpMethodOverrideHeaderAvaiableChangesRequestMethod()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(); webHostBuilder
app.Run(context => .UseTestServer()
.Configure(app =>
{ {
assertsExecuted = true; app.UseHttpMethodOverride();
Assert.Equal("DELETE", context.Request.Method); app.Run(context =>
return Task.FromResult(0); {
assertsExecuted = true;
Assert.Equal("DELETE", context.Request.Method);
return Task.FromResult(0);
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, ""); var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Headers.Add("X-Http-Method-Override", "DELETE"); req.Headers.Add("X-Http-Method-Override", "DELETE");
@ -40,18 +49,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideHeaderUnavaiableDoesntChangeRequestMethod() public async Task XHttpMethodOverrideHeaderUnavaiableDoesntChangeRequestMethod()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(); webHostBuilder
app.Run(context => .UseTestServer()
.Configure(app =>
{ {
Assert.Equal("POST",context.Request.Method); app.UseHttpMethodOverride();
assertsExecuted = true; app.Run(context =>
return Task.FromResult(0); {
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, ""); var req = new HttpRequestMessage(HttpMethod.Post, "");
await server.CreateClient().SendAsync(req); await server.CreateClient().SendAsync(req);
@ -62,18 +79,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideFromGetRequestDoesntChangeMethodType() public async Task XHttpMethodOverrideFromGetRequestDoesntChangeMethodType()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(); webHostBuilder
app.Run(context => .UseTestServer()
.Configure(app =>
{ {
Assert.Equal("GET", context.Request.Method); app.UseHttpMethodOverride();
assertsExecuted = true; app.Run(context =>
return Task.FromResult(0); {
Assert.Equal("GET", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, ""); var req = new HttpRequestMessage(HttpMethod.Get, "");
await server.CreateClient().SendAsync(req); await server.CreateClient().SendAsync(req);
@ -85,21 +110,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldAvailableChangesRequestMethod() public async Task FormFieldAvailableChangesRequestMethod()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(new HttpMethodOverrideOptions() webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
FormFieldName = "_METHOD" app.UseHttpMethodOverride(new HttpMethodOverrideOptions()
{
FormFieldName = "_METHOD"
});
app.Run(context =>
{
Assert.Equal("DELETE", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal("DELETE", context.Request.Method); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Post, ""); var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new FormUrlEncodedContent(new Dictionary<string, string>() req.Content = new FormUrlEncodedContent(new Dictionary<string, string>()
@ -116,21 +149,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldUnavailableDoesNotChangeRequestMethod() public async Task FormFieldUnavailableDoesNotChangeRequestMethod()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(new HttpMethodOverrideOptions() webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
FormFieldName = "_METHOD" app.UseHttpMethodOverride(new HttpMethodOverrideOptions()
{
FormFieldName = "_METHOD"
});
app.Run(context =>
{
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal("POST", context.Request.Method); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Post, ""); var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new FormUrlEncodedContent(new Dictionary<string, string>() req.Content = new FormUrlEncodedContent(new Dictionary<string, string>()
@ -146,21 +187,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldEmptyDoesNotChangeRequestMethod() public async Task FormFieldEmptyDoesNotChangeRequestMethod()
{ {
var assertsExecuted = false; var assertsExecuted = false;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseHttpMethodOverride(new HttpMethodOverrideOptions() webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
FormFieldName = "_METHOD" app.UseHttpMethodOverride(new HttpMethodOverrideOptions()
{
FormFieldName = "_METHOD"
});
app.Run(context =>
{
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
Assert.Equal("POST", context.Request.Method); await host.StartAsync();
assertsExecuted = true;
return Task.FromResult(0); var server = host.GetTestServer();
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Post, ""); var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new FormUrlEncodedContent(new Dictionary<string, string>() req.Content = new FormUrlEncodedContent(new Dictionary<string, string>()

38
src/Middleware/HttpsPolicy/sample/Startup.cs
View File

@ -49,30 +49,34 @@ namespace HttpsSample
} }
// Entry point for the application. // Entry point for the application.
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel( .ConfigureWebHost(webHostBuilder =>
options =>
{ {
options.Listen(new IPEndPoint(IPAddress.Loopback, 5001), listenOptions => webHostBuilder
.UseKestrel(
options =>
{ {
listenOptions.UseHttps("testCert.pfx", "testPassword"); options.Listen(new IPEndPoint(IPAddress.Loopback, 5001), listenOptions =>
}); {
options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), listenOptions => listenOptions.UseHttps("testCert.pfx", "testPassword");
});
options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), listenOptions =>
{
});
})
.UseContentRoot(Directory.GetCurrentDirectory()) // for the cert file
.ConfigureLogging(factory =>
{ {
}); factory.SetMinimumLevel(LogLevel.Debug);
factory.AddConsole();
})
.UseStartup<Startup>();
}) })
.UseContentRoot(Directory.GetCurrentDirectory()) // for the cert file
.ConfigureLogging(factory =>
{
factory.SetMinimumLevel(LogLevel.Debug);
factory.AddConsole();
})
.UseStartup<Startup>()
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

288
src/Middleware/HttpsPolicy/test/HstsMiddlewareTests.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
@ -12,6 +12,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
@ -24,20 +25,27 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[Fact] [Fact]
public async Task SetOptionsWithDefault_SetsMaxAgeToCorrectValue() public async Task SetOptionsWithDefault_SetsMaxAgeToCorrectValue()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
}) webHostBuilder
.Configure(app => .UseTestServer()
{ .ConfigureServices(services =>
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); })
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri("https://example.com:5050"); client.BaseAddress = new Uri("https://example.com:5050");
@ -58,25 +66,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData(50000, true, true, "max-age=50000; includeSubDomains; preload")] [InlineData(50000, true, true, "max-age=50000; includeSubDomains; preload")]
public async Task SetOptionsThroughConfigure_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected) public async Task SetOptionsThroughConfigure_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.Configure<HstsOptions>(options => { webHostBuilder
options.Preload = preload; .UseTestServer()
options.IncludeSubDomains = includeSubDomains; .ConfigureServices(services =>
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.Configure<HstsOptions>(options =>
{
options.Preload = preload;
options.IncludeSubDomains = includeSubDomains;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri("https://example.com:5050"); client.BaseAddress = new Uri("https://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -96,25 +112,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData(50000, true, true, "max-age=50000; includeSubDomains; preload")] [InlineData(50000, true, true, "max-age=50000; includeSubDomains; preload")]
public async Task SetOptionsThroughHelper_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected) public async Task SetOptionsThroughHelper_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHsts(options => { webHostBuilder
options.Preload = preload; .UseTestServer()
options.IncludeSubDomains = includeSubDomains; .ConfigureServices(services =>
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddHsts(options =>
{
options.Preload = preload;
options.IncludeSubDomains = includeSubDomains;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri("https://example.com:5050"); client.BaseAddress = new Uri("https://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -131,29 +155,37 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData("LOCALHOST")] [InlineData("LOCALHOST")]
[InlineData("127.0.0.1")] [InlineData("127.0.0.1")]
[InlineData("[::1]")] [InlineData("[::1]")]
public async Task DefaultExcludesCommonLocalhostDomains_DoesNotSetHstsHeader(string host) public async Task DefaultExcludesCommonLocalhostDomains_DoesNotSetHstsHeader(string hostUrl)
{ {
var sink = new TestSink( var sink = new TestSink(
TestSink.EnableWithTypeName<HstsMiddleware>, TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>); TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri($"https://{host}:5050"); client.BaseAddress = new Uri($"https://{hostUrl}:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
var response = await client.SendAsync(request); var response = await client.SendAsync(request);
@ -166,41 +198,49 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
Assert.Single(logMessages); Assert.Single(logMessages);
var message = logMessages.Single(); var message = logMessages.Single();
Assert.Equal(LogLevel.Debug, message.LogLevel); Assert.Equal(LogLevel.Debug, message.LogLevel);
Assert.Equal($"The host '{host}' is excluded. Skipping HSTS header.", message.State.ToString(), ignoreCase: true); Assert.Equal($"The host '{hostUrl}' is excluded. Skipping HSTS header.", message.State.ToString(), ignoreCase: true);
} }
[Theory] [Theory]
[InlineData("localhost")] [InlineData("localhost")]
[InlineData("127.0.0.1")] [InlineData("127.0.0.1")]
[InlineData("[::1]")] [InlineData("[::1]")]
public async Task AllowLocalhostDomainsIfListIsReset_SetHstsHeader(string host) public async Task AllowLocalhostDomainsIfListIsReset_SetHstsHeader(string hostUrl)
{ {
var sink = new TestSink( var sink = new TestSink(
TestSink.EnableWithTypeName<HstsMiddleware>, TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>); TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddHsts(options => services.AddHsts(options =>
{
options.ExcludedHosts.Clear();
});
})
.Configure(app =>
{ {
options.ExcludedHosts.Clear(); app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}) }).Build();
.Configure(app =>
{ await host.StartAsync();
app.UseHsts();
app.Run(context => var server = host.GetTestServer();
{
return context.Response.WriteAsync("Hello world");
});
});
var server = new TestServer(builder);
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri($"https://{host}:5050"); client.BaseAddress = new Uri($"https://{hostUrl}:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
var response = await client.SendAsync(request); var response = await client.SendAsync(request);
@ -220,33 +260,42 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData("example.com")] [InlineData("example.com")]
[InlineData("Example.com")] [InlineData("Example.com")]
[InlineData("EXAMPLE.COM")] [InlineData("EXAMPLE.COM")]
public async Task AddExcludedDomains_DoesNotAddHstsHeader(string host) public async Task AddExcludedDomains_DoesNotAddHstsHeader(string hostUrl)
{ {
var sink = new TestSink( var sink = new TestSink(
TestSink.EnableWithTypeName<HstsMiddleware>, TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>); TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
.UseTestServer()
services.AddHsts(options => { .ConfigureServices(services =>
options.ExcludedHosts.Add(host);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddHsts(options =>
{
options.ExcludedHosts.Add(hostUrl);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri($"https://{host}:5050"); client.BaseAddress = new Uri($"https://{hostUrl}:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
var response = await client.SendAsync(request); var response = await client.SendAsync(request);
@ -259,7 +308,7 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
Assert.Single(logMessages); Assert.Single(logMessages);
var message = logMessages.Single(); var message = logMessages.Single();
Assert.Equal(LogLevel.Debug, message.LogLevel); Assert.Equal(LogLevel.Debug, message.LogLevel);
Assert.Equal($"The host '{host}' is excluded. Skipping HSTS header.", message.State.ToString(), ignoreCase: true); Assert.Equal($"The host '{hostUrl}' is excluded. Skipping HSTS header.", message.State.ToString(), ignoreCase: true);
} }
[Fact] [Fact]
@ -270,20 +319,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HstsMiddleware>); TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri("http://example.com:5050"); client.BaseAddress = new Uri("http://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -309,20 +366,27 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HstsMiddleware>); TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHsts();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder);
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
client.BaseAddress = new Uri("https://example.com:5050"); client.BaseAddress = new Uri("https://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");

58
src/Middleware/HttpsPolicy/test/HttpsPolicyTests.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
@ -13,6 +13,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
using Xunit; using Xunit;
@ -30,36 +31,41 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData(302, 5050, 2592000, true, true, "max-age=2592000; includeSubDomains; preload", "https://localhost:5050/")] [InlineData(302, 5050, 2592000, true, true, "max-age=2592000; includeSubDomains; preload", "https://localhost:5050/")]
public async Task SetsBothHstsAndHttpsRedirection_RedirectOnFirstRequest_HstsOnSecondRequest(int statusCode, int? tlsPort, int maxAge, bool includeSubDomains, bool preload, string expectedHstsHeader, string expectedUrl) public async Task SetsBothHstsAndHttpsRedirection_RedirectOnFirstRequest_HstsOnSecondRequest(int statusCode, int? tlsPort, int maxAge, bool includeSubDomains, bool preload, string expectedHstsHeader, string expectedUrl)
{ {
using var host = new HostBuilder()
var builder = new WebHostBuilder() .ConfigureWebHost(webHostBuilder =>
.ConfigureServices(services =>
{ {
services.Configure<HttpsRedirectionOptions>(options => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
options.RedirectStatusCode = statusCode; services.Configure<HttpsRedirectionOptions>(options =>
options.HttpsPort = tlsPort; {
}); options.RedirectStatusCode = statusCode;
services.Configure<HstsOptions>(options => options.HttpsPort = tlsPort;
});
services.Configure<HstsOptions>(options =>
{
options.IncludeSubDomains = includeSubDomains;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
options.Preload = preload;
options.ExcludedHosts.Clear(); // allowing localhost for testing
});
})
.Configure(app =>
{ {
options.IncludeSubDomains = includeSubDomains; app.UseHttpsRedirection();
options.MaxAge = TimeSpan.FromSeconds(maxAge); app.UseHsts();
options.Preload = preload; app.Run(context =>
options.ExcludedHosts.Clear(); // allowing localhost for testing {
return context.Response.WriteAsync("Hello world");
});
}); });
}) }).Build();
.Configure(app =>
{
app.UseHttpsRedirection();
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
var featureCollection = new FeatureCollection(); await host.StartAsync();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection); var server = host.GetTestServer();
server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");

311
src/Middleware/HttpsPolicy/test/HttpsRedirectionMiddlewareTests.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
@ -8,11 +8,13 @@ using System.Net.Http;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features; using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
@ -28,21 +30,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHttpsRedirection();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -71,26 +80,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
services.Configure<HttpsRedirectionOptions>(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.RedirectStatusCode = statusCode; services.AddSingleton<ILoggerFactory>(loggerFactory);
options.HttpsPort = httpsPort; services.Configure<HttpsRedirectionOptions>(options =>
}); {
}) options.RedirectStatusCode = statusCode;
.Configure(app => options.HttpsPort = httpsPort;
{ });
app.UseHttpsRedirection(); })
app.Run(context => .Configure(app =>
{ {
return context.Response.WriteAsync("Hello world"); app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -120,26 +136,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
services.AddHttpsRedirection(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.RedirectStatusCode = statusCode; services.AddSingleton<ILoggerFactory>(loggerFactory);
options.HttpsPort = httpsPort; services.AddHttpsRedirection(options =>
}); {
}) options.RedirectStatusCode = statusCode;
.Configure(app => options.HttpsPort = httpsPort;
{ });
app.UseHttpsRedirection(); })
app.Run(context => .Configure(app =>
{ {
return context.Response.WriteAsync("Hello world"); app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -169,34 +192,39 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
public async Task SetHttpsPortEnvironmentVariableAndServerFeature_ReturnsCorrectStatusCodeOnResponse( public async Task SetHttpsPortEnvironmentVariableAndServerFeature_ReturnsCorrectStatusCodeOnResponse(
int? optionsHttpsPort, string configHttpsPort, string serverAddressFeatureUrl, string expectedUrl) int? optionsHttpsPort, string configHttpsPort, string serverAddressFeatureUrl, string expectedUrl)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddHttpsRedirection(options => webHostBuilder
{ .UseTestServer()
options.HttpsPort = optionsHttpsPort; .ConfigureServices(services =>
}); {
}) services.AddHttpsRedirection(options =>
.Configure(app => {
{ options.HttpsPort = optionsHttpsPort;
app.UseHttpsRedirection(); });
app.Run(context => })
{ .Configure(app =>
return context.Response.WriteAsync("Hello world"); {
}); app.UseHttpsRedirection();
}); app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
builder.UseSetting("HTTPS_PORT", configHttpsPort); webHostBuilder.UseSetting("HTTPS_PORT", configHttpsPort);
}).Build();
var featureCollection = new FeatureCollection(); var server = host.GetTestServer();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature()); server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
if (serverAddressFeatureUrl != null) if (serverAddressFeatureUrl != null)
{ {
server.Features.Get<IServerAddressesFeature>().Addresses.Add(serverAddressFeatureUrl); server.Features.Get<IServerAddressesFeature>().Addresses.Add(serverAddressFeatureUrl);
} }
await host.StartAsync();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -213,25 +241,30 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{ {
app.UseHttpsRedirection(); services.AddSingleton<ILoggerFactory>(loggerFactory);
app.Run(context => })
.Configure(app =>
{ {
return context.Response.WriteAsync("Hello world"); app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var featureCollection = new FeatureCollection(); var server = host.GetTestServer();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature()); server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050"); server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050");
await host.StartAsync();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -259,27 +292,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{ {
app.UseHttpsRedirection(); services.AddSingleton<ILoggerFactory>(loggerFactory);
app.Run(context => })
.Configure(app =>
{ {
return context.Response.WriteAsync("Hello world"); app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var featureCollection = new FeatureCollection(); var server = host.GetTestServer();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature()); server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050"); server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050");
server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5051"); server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5051");
await host.StartAsync();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -303,27 +342,32 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{ {
app.UseHttpsRedirection(); services.AddSingleton<ILoggerFactory>(loggerFactory);
app.Run(context => })
.Configure(app =>
{ {
return context.Response.WriteAsync("Hello world"); app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var featureCollection = new FeatureCollection();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
var server = host.GetTestServer();
server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050"); server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://localhost:5050");
server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://example.com:5050"); server.Features.Get<IServerAddressesFeature>().Addresses.Add("https://example.com:5050");
await host.StartAsync();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -351,21 +395,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHttpsRedirection();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
var response = await client.SendAsync(request); var response = await client.SendAsync(request);
@ -386,23 +437,29 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>, TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>); TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseHttpsRedirection();
app.Run(context =>
{ {
return context.Response.WriteAsync("Hello world"); services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
}); });
}); }).Build();
var featureCollection = new FeatureCollection(); var server = host.GetTestServer();
featureCollection.Set<IServerAddressesFeature>(null); server.Features.Set<IServerAddressesFeature>(null);
var server = new TestServer(builder, featureCollection);
await host.StartAsync();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");

200
src/Middleware/Localization.Routing/test/RouteDataRequestCultureProviderTest.cs
View File

@ -1,4 +1,4 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic; using System.Collections.Generic;
@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing; using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Localization.Routing namespace Microsoft.AspNetCore.Localization.Routing
@ -30,50 +31,57 @@ namespace Microsoft.AspNetCore.Localization.Routing
string expectedCulture, string expectedCulture,
string expectedUICulture) string expectedUICulture)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRouter(routes => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
routes.MapMiddlewareRoute(routeTemplate, fork => app.UseRouter(routes =>
{ {
var options = new RequestLocalizationOptions routes.MapMiddlewareRoute(routeTemplate, fork =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{ {
new CultureInfo("ar-YE") new RouteDataRequestCultureProvider()
} {
}; Options = options
options.RequestCultureProviders = new[] }
{ };
new RouteDataRequestCultureProvider() fork.UseRequestLocalization(options);
{
Options = options
}
};
fork.UseRequestLocalization(options);
fork.Run(context => fork.Run(context =>
{ {
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>(); var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture; var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync( return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}"); $"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
});
}); });
}); });
})
.ConfigureServices(services =>
{
services.AddRouting();
}); });
}) }).Build();
.ConfigureServices(services =>
{
services.AddRouting();
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(requestUrl); var response = await client.GetAsync(requestUrl);
@ -87,32 +95,39 @@ namespace Microsoft.AspNetCore.Localization.Routing
[Fact] [Fact]
public async Task GetDefaultCultureInfo_IfCultureKeysAreMissing() public async Task GetDefaultCultureInfo_IfCultureKeysAreMissing()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US") var options = new RequestLocalizationOptions
};
options.RequestCultureProviders = new[]
{
new RouteDataRequestCultureProvider()
{ {
Options = options DefaultRequestCulture = new RequestCulture("en-US")
} };
}; options.RequestCultureProviders = new[]
app.UseRequestLocalization(options); {
app.Run(context => new RouteDataRequestCultureProvider()
{ {
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>(); Options = options
var requestCulture = requestCultureFeature.RequestCulture; }
};
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync( return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}"); $"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
});
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page"); var response = await client.GetAsync("/page");
@ -135,53 +150,60 @@ namespace Microsoft.AspNetCore.Localization.Routing
string expectedCulture, string expectedCulture,
string expectedUICulture) string expectedUICulture)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRouter(routes => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
routes.MapMiddlewareRoute(routeTemplate, fork => app.UseRouter(routes =>
{ {
var options = new RequestLocalizationOptions routes.MapMiddlewareRoute(routeTemplate, fork =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{ {
new CultureInfo("ar-YE") new RouteDataRequestCultureProvider()
} {
}; Options = options,
options.RequestCultureProviders = new[] RouteDataStringKey = "c",
{ UIRouteDataStringKey = "uic"
new RouteDataRequestCultureProvider() }
{ };
Options = options, fork.UseRequestLocalization(options);
RouteDataStringKey = "c",
UIRouteDataStringKey = "uic"
}
};
fork.UseRequestLocalization(options);
fork.Run(context => fork.Run(context =>
{ {
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>(); var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture; var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync( return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}"); $"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
});
}); });
}); });
})
.ConfigureServices(services =>
{
services.AddRouting();
}); });
}) }).Build();
.ConfigureServices(services =>
{
services.AddRouting();
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(requestUrl); var response = await client.GetAsync(requestUrl);

22
src/Middleware/Localization/sample/Startup.cs
View File

@ -3,12 +3,14 @@
using System; using System;
using System.Globalization; using System.Globalization;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Localization; using Microsoft.AspNetCore.Localization;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Localization; using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
@ -134,21 +136,25 @@ $@"<!doctype html>
await context.Response.WriteAsync($" <option value=\"pp-NOTREAL\">Made-up (Not a real anything)</option>"); await context.Response.WriteAsync($" <option value=\"pp-NOTREAL\">Made-up (Not a real anything)</option>");
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var config = new ConfigurationBuilder() var config = new ConfigurationBuilder()
.AddCommandLine(args) .AddCommandLine(args)
.Build(); .Build();
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging(factory => factory.AddConsole()) .ConfigureWebHost(webHostBuilder =>
.UseKestrel() {
.UseConfiguration(config) webHostBuilder
.UseIISIntegration() .ConfigureLogging(factory => factory.AddConsole())
.UseStartup<Startup>() .UseKestrel()
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

14
src/Middleware/Localization/test/FunctionalTests/LocalizationSampleTest.cs
View File

@ -9,6 +9,7 @@ using System.Threading.Tasks;
using LocalizationSample; using LocalizationSample;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Localization.FunctionalTests namespace Microsoft.AspNetCore.Localization.FunctionalTests
@ -19,8 +20,17 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
public async Task LocalizationSampleSmokeTest() public async Task LocalizationSampleSmokeTest()
{ {
// Arrange // Arrange
var webHostBuilder = new WebHostBuilder().UseStartup(typeof(Startup)); using var host = new HostBuilder()
var testHost = new TestServer(webHostBuilder); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(typeof(Startup));
}).Build();
await host.StartAsync();
var testHost = host.GetTestServer();
var locale = "fr-FR"; var locale = "fr-FR";
var client = testHost.CreateClient(); var client = testHost.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "My/Resources"); var request = new HttpRequestMessage(HttpMethod.Get, "My/Resources");

16
src/Middleware/Localization/test/FunctionalTests/LocalizationTest.cs
View File

@ -8,6 +8,7 @@ using System.Threading.Tasks;
using LocalizationWebsite; using LocalizationWebsite;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Localization.FunctionalTests namespace Microsoft.AspNetCore.Localization.FunctionalTests
@ -97,8 +98,17 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
private async Task RunTest(Type startupType, string culture, string expected) private async Task RunTest(Type startupType, string culture, string expected)
{ {
var webHostBuilder = new WebHostBuilder().UseStartup(startupType); using var host = new HostBuilder()
var testHost = new TestServer(webHostBuilder); .ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(startupType);
}).Build();
await host.StartAsync();
var testHost = host.GetTestServer();
var client = testHost.CreateClient(); var client = testHost.CreateClient();
var request = new HttpRequestMessage(); var request = new HttpRequestMessage();
@ -109,6 +119,6 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expected, await response.Content.ReadAsStringAsync()); Assert.Equal(expected, await response.Content.ReadAsStringAsync());
} }
} }
} }

171
src/Middleware/Localization/test/UnitTests/AcceptLanguageHeaderRequestCultureProviderTest.cs
View File

@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Localization; using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.Extensions.Localization namespace Microsoft.Extensions.Localization
@ -17,28 +18,35 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetFallbackLanguage_ReturnsFirstNonNullCultureFromSupportedCultureList() public async Task GetFallbackLanguage_ReturnsFirstNonNullCultureFromSupportedCultureList()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA"), DefaultRequestCulture = new RequestCulture("en-US"),
new CultureInfo("en-US") SupportedCultures = new List<CultureInfo>
} {
new CultureInfo("ar-SA"),
new CultureInfo("en-US")
}
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("jp,ar-SA,en-US"); client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("jp,ar-SA,en-US");
@ -51,28 +59,35 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetFallbackLanguage_ReturnsFromSupportedCulture_AcceptLanguageListContainsSupportedCultures() public async Task GetFallbackLanguage_ReturnsFromSupportedCulture_AcceptLanguageListContainsSupportedCultures()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("fr-FR"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA"), DefaultRequestCulture = new RequestCulture("fr-FR"),
new CultureInfo("en-US") SupportedCultures = new List<CultureInfo>
} {
new CultureInfo("ar-SA"),
new CultureInfo("en-US")
}
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-SA,en-US"); client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-SA,en-US");
@ -84,28 +99,35 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetFallbackLanguage_ReturnsDefault_AcceptLanguageListDoesnotContainSupportedCultures() public async Task GetFallbackLanguage_ReturnsDefault_AcceptLanguageListDoesnotContainSupportedCultures()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("fr-FR"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA"), DefaultRequestCulture = new RequestCulture("fr-FR"),
new CultureInfo("af-ZA") SupportedCultures = new List<CultureInfo>
} {
new CultureInfo("ar-SA"),
new CultureInfo("af-ZA")
}
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("fr-FR", requestCulture.Culture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("fr-FR", requestCulture.Culture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-MA,en-US"); client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-MA,en-US");
@ -118,33 +140,40 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task OmitDefaultRequestCultureShouldNotThrowNullReferenceException_And_ShouldGetTheRightCulture() public async Task OmitDefaultRequestCultureShouldNotThrowNullReferenceException_And_ShouldGetTheRightCulture()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-YE") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-YE")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-YE") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-YE", requestCulture.Culture.Name); Assert.Equal("ar-YE", requestCulture.Culture.Name);
Assert.Equal("ar-YE", requestCulture.UICulture.Name); Assert.Equal("ar-YE", requestCulture.UICulture.Name);
return Task.FromResult(0); return Task.FromResult(0);
});
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-YE,en-US"); client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-YE,en-US");

278
src/Middleware/Localization/test/UnitTests/CookieRequestCultureProviderTest.cs
View File

@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Localization; using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
@ -21,38 +22,45 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetCultureInfoFromPersistentCookie() public async Task GetCultureInfoFromPersistentCookie()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
};
var provider = new CookieRequestCultureProvider
{ {
new CultureInfo("ar-SA") CookieName = "Preferences"
} };
}; options.RequestCultureProviders.Insert(0, provider);
var provider = new CookieRequestCultureProvider
{
CookieName = "Preferences"
};
options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options); app.UseRequestLocalization(options);
app.Run(context => app.Run(context =>
{ {
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>(); var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture; var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name); Assert.Equal("ar-SA", requestCulture.Culture.Name);
return Task.FromResult(0); return Task.FromResult(0);
});
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var culture = new CultureInfo("ar-SA"); var culture = new CultureInfo("ar-SA");
@ -67,37 +75,44 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetDefaultCultureInfoIfCultureKeysAreMissingOrInvalid() public async Task GetDefaultCultureInfoIfCultureKeysAreMissingOrInvalid()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
};
var provider = new CookieRequestCultureProvider
{ {
new CultureInfo("ar-SA") CookieName = "Preferences"
} };
}; options.RequestCultureProviders.Insert(0, provider);
var provider = new CookieRequestCultureProvider app.UseRequestLocalization(options);
{ app.Run(context =>
CookieName = "Preferences" {
}; var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
options.RequestCultureProviders.Insert(0, provider); var requestCulture = requestCultureFeature.RequestCulture;
app.UseRequestLocalization(options); Assert.Equal("en-US", requestCulture.Culture.Name);
app.Run(context => return Task.FromResult(0);
{ });
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
return Task.FromResult(0);
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
@ -109,37 +124,44 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetDefaultCultureInfoIfCookieDoesNotExist() public async Task GetDefaultCultureInfoIfCookieDoesNotExist()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
};
var provider = new CookieRequestCultureProvider
{ {
new CultureInfo("ar-SA") CookieName = "Preferences"
} };
}; options.RequestCultureProviders.Insert(0, provider);
var provider = new CookieRequestCultureProvider app.UseRequestLocalization(options);
{ app.Run(context =>
CookieName = "Preferences" {
}; var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
options.RequestCultureProviders.Insert(0, provider); var requestCulture = requestCultureFeature.RequestCulture;
app.UseRequestLocalization(options); Assert.Equal("en-US", requestCulture.Culture.Name);
app.Run(context => return Task.FromResult(0);
{ });
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
return Task.FromResult(0);
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync(string.Empty); var response = await client.GetAsync(string.Empty);
@ -153,35 +175,42 @@ namespace Microsoft.Extensions.Localization
TestSink.EnableWithTypeName<RequestLocalizationMiddleware>, TestSink.EnableWithTypeName<RequestLocalizationMiddleware>,
TestSink.EnableWithTypeName<RequestLocalizationMiddleware>); TestSink.EnableWithTypeName<RequestLocalizationMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-YE") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-YE")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
var provider = new CookieRequestCultureProvider
{ {
new CultureInfo("ar-YE") CookieName = "Preferences"
} };
}; options.RequestCultureProviders.Insert(0, provider);
var provider = new CookieRequestCultureProvider app.UseRequestLocalization(options);
app.Run(context => Task.CompletedTask);
})
.ConfigureServices(services =>
{ {
CookieName = "Preferences" services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
}; });
options.RequestCultureProviders.Insert(0, provider); }).Build();
app.UseRequestLocalization(options);
app.Run(context => Task.CompletedTask);
})
.ConfigureServices(services =>
{
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var culture = "??"; var culture = "??";
@ -206,35 +235,42 @@ namespace Microsoft.Extensions.Localization
TestSink.EnableWithTypeName<RequestLocalizationMiddleware>, TestSink.EnableWithTypeName<RequestLocalizationMiddleware>,
TestSink.EnableWithTypeName<RequestLocalizationMiddleware>); TestSink.EnableWithTypeName<RequestLocalizationMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-YE") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-YE")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
var provider = new CookieRequestCultureProvider
{ {
new CultureInfo("ar-YE") CookieName = "Preferences"
} };
}; options.RequestCultureProviders.Insert(0, provider);
var provider = new CookieRequestCultureProvider app.UseRequestLocalization(options);
app.Run(context => Task.CompletedTask);
})
.ConfigureServices(services =>
{ {
CookieName = "Preferences" services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
}; });
options.RequestCultureProviders.Insert(0, provider); }).Build();
app.UseRequestLocalization(options);
app.Run(context => Task.CompletedTask);
})
.ConfigureServices(services =>
{
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var culture = "ar-YE"; var culture = "ar-YE";

60
src/Middleware/Localization/test/UnitTests/CustomRequestCultureProviderTest.cs
View File

@ -10,6 +10,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Localization; using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.Extensions.Localization namespace Microsoft.Extensions.Localization
@ -19,38 +20,45 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task CustomRequestCultureProviderThatGetsCultureInfoFromUrl() public async Task CustomRequestCultureProviderThatGetsCultureInfoFromUrl()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar")
}
};
options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context =>
{ {
new CultureInfo("ar") var culture = GetCultureInfoFromUrl(context, options.SupportedCultures);
} var requestCulture = new ProviderCultureResult(culture);
}; return Task.FromResult(requestCulture);
options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(context => }));
{ app.UseRequestLocalization(options);
var culture = GetCultureInfoFromUrl(context, options.SupportedCultures); app.Run(context =>
var requestCulture = new ProviderCultureResult(culture); {
return Task.FromResult(requestCulture); var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
})); var requestCulture = requestCultureFeature.RequestCulture;
app.UseRequestLocalization(options); Assert.Equal("ar", requestCulture.Culture.Name);
app.Run(context => return Task.FromResult(0);
{ });
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar", requestCulture.Culture.Name);
return Task.FromResult(0);
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/ar/page"); var response = await client.GetAsync("/ar/page");

383
src/Middleware/Localization/test/UnitTests/QueryStringRequestCultureProviderTest.cs
View File

@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Localization; using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.Extensions.Localization namespace Microsoft.Extensions.Localization
@ -17,32 +18,39 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetCultureInfoFromQueryString() public async Task GetCultureInfoFromQueryString()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-YE") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-YE", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-YE", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-YE"); var response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-YE");
@ -52,24 +60,31 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetDefaultCultureInfoIfCultureKeysAreMissing() public async Task GetDefaultCultureInfoIfCultureKeysAreMissing()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US") app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new RequestCulture("en-US")
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
Assert.Equal("en-US", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
Assert.Equal("en-US", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page"); var response = await client.GetAsync("/page");
@ -79,31 +94,38 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetDefaultCultureInfoIfCultureIsInSupportedCultureList() public async Task GetDefaultCultureInfoIfCultureIsInSupportedCultureList()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-SA") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.Culture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?culture=ar-XY&ui-culture=ar-SA"); var response = await client.GetAsync("/page?culture=ar-XY&ui-culture=ar-SA");
@ -113,31 +135,38 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetDefaultCultureInfoIfUICultureIsNotInSupportedList() public async Task GetDefaultCultureInfoIfUICultureIsNotInSupportedList()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-SA") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-XY"); var response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-XY");
@ -147,32 +176,39 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetSameCultureInfoIfCultureKeyIsMissing() public async Task GetSameCultureInfoIfCultureKeyIsMissing()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-SA") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-SA", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-SA", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?ui-culture=ar-SA"); var response = await client.GetAsync("/page?ui-culture=ar-SA");
@ -182,32 +218,39 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetSameCultureInfoIfUICultureKeyIsMissing() public async Task GetSameCultureInfoIfUICultureKeyIsMissing()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRequestLocalization(new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), app.UseRequestLocalization(new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
}
});
app.Run(context =>
{ {
new CultureInfo("ar-SA") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-SA", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
}); });
app.Run(context => }).Build();
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-SA", requestCulture.UICulture.Name);
return Task.FromResult(0);
});
});
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?culture=ar-SA"); var response = await client.GetAsync("/page?culture=ar-SA");
@ -217,37 +260,44 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetCultureInfoFromQueryStringWithCustomKeys() public async Task GetCultureInfoFromQueryStringWithCustomKeys()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("ar-SA") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
var provider = new QueryStringRequestCultureProvider();
provider.QueryStringKey = "c";
provider.UIQueryStringKey = "uic";
options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options);
app.Run(context =>
{ {
new CultureInfo("ar-YE") var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
} var requestCulture = requestCultureFeature.RequestCulture;
}; Assert.Equal("ar-SA", requestCulture.Culture.Name);
var provider = new QueryStringRequestCultureProvider(); Assert.Equal("ar-YE", requestCulture.UICulture.Name);
provider.QueryStringKey = "c"; return Task.FromResult(0);
provider.UIQueryStringKey = "uic"; });
options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", requestCulture.Culture.Name);
Assert.Equal("ar-YE", requestCulture.UICulture.Name);
return Task.FromResult(0);
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?c=ar-SA&uic=ar-YE"); var response = await client.GetAsync("/page?c=ar-SA&uic=ar-YE");
@ -257,38 +307,45 @@ namespace Microsoft.Extensions.Localization
[Fact] [Fact]
public async Task GetTheRightCultureInfoRegardlessOfCultureNameCasing() public async Task GetTheRightCultureInfoRegardlessOfCultureNameCasing()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
var options = new RequestLocalizationOptions webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
DefaultRequestCulture = new RequestCulture("en-US"), var options = new RequestLocalizationOptions
SupportedCultures = new List<CultureInfo>
{ {
new CultureInfo("FR") DefaultRequestCulture = new RequestCulture("en-US"),
}, SupportedCultures = new List<CultureInfo>
SupportedUICultures = new List<CultureInfo> {
{ new CultureInfo("FR")
new CultureInfo("FR") },
} SupportedUICultures = new List<CultureInfo>
}; {
var provider = new QueryStringRequestCultureProvider(); new CultureInfo("FR")
}
};
var provider = new QueryStringRequestCultureProvider();
provider.QueryStringKey = "c"; provider.QueryStringKey = "c";
provider.UIQueryStringKey = "uic"; provider.UIQueryStringKey = "uic";
options.RequestCultureProviders.Insert(0, provider); options.RequestCultureProviders.Insert(0, provider);
app.UseRequestLocalization(options); app.UseRequestLocalization(options);
app.Run(context => app.Run(context =>
{ {
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>(); var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture; var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("fr", requestCulture.Culture.ToString()); Assert.Equal("fr", requestCulture.Culture.ToString());
Assert.Equal("fr", requestCulture.UICulture.ToString()); Assert.Equal("fr", requestCulture.UICulture.ToString());
return Task.FromResult(0); return Task.FromResult(0);
});
}); });
}); }).Build();
using (var server = new TestServer(builder)) await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var response = await client.GetAsync("/page?c=FR&uic=FR"); var response = await client.GetAsync("/page?c=FR&uic=FR");

24
src/Middleware/Localization/testassets/LocalizationWebsite/Program.cs
View File

@ -1,32 +1,38 @@
// Copyright (c) .NET Foundation. All rights reserved. // Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace LocalizationWebsite namespace LocalizationWebsite
{ {
public static class Program public static class Program
{ {
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var config = new ConfigurationBuilder() var config = new ConfigurationBuilder()
.AddCommandLine(args) .AddCommandLine(args)
.Build(); .Build();
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging((_, factory) => .ConfigureWebHost(webHostBuilder =>
{ {
factory.AddConsole(); webHostBuilder
factory.AddFilter("Console", level => level >= LogLevel.Warning); .ConfigureLogging((_, factory) =>
{
factory.AddConsole();
factory.AddFilter("Console", level => level >= LogLevel.Warning);
})
.UseKestrel()
.UseConfiguration(config)
.UseStartup("LocalizationWebsite");
}) })
.UseKestrel()
.UseConfiguration(config)
.UseStartup("LocalizationWebsite")
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

27
src/Middleware/MiddlewareAnalysis/samples/MiddlewareAnalysisSample/Startup.cs
View File

@ -1,10 +1,12 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DiagnosticAdapter; using Microsoft.Extensions.DiagnosticAdapter;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace MiddlewareAnaysisSample namespace MiddlewareAnaysisSample
@ -79,20 +81,23 @@ namespace MiddlewareAnaysisSample
// Note there's always a default 404 middleware at the end of the pipeline. // Note there's always a default 404 middleware at the end of the pipeline.
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging((_, factory) => .ConfigureWebHost(webHostBuilder =>
{ {
factory.AddConsole(); webHostBuilder
factory.AddFilter("Console", level => level >= LogLevel.Debug); .ConfigureLogging((_, factory) =>
}) {
.UseKestrel() factory.AddConsole();
.UseIISIntegration() factory.AddFilter("Console", level => level >= LogLevel.Debug);
.UseStartup<Startup>() })
.Build(); .UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
public class TestDiagnosticListener public class TestDiagnosticListener

31
src/Middleware/MiddlewareAnalysis/test/MiddlewareAnalysisTests.cs
View File

@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.MiddlewareAnalysis namespace Microsoft.AspNetCore.MiddlewareAnalysis
@ -19,19 +20,27 @@ namespace Microsoft.AspNetCore.MiddlewareAnalysis
{ {
DiagnosticListener diagnosticListener = null; DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>(); webHostBuilder
.UseTestServer()
app.UseDeveloperExceptionPage(); .Configure(app =>
app.Run(context =>
{ {
throw new Exception("Test exception"); diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
});
}) app.UseDeveloperExceptionPage();
.ConfigureServices(services => services.AddMiddlewareAnalysis()); app.Run(context =>
var server = new TestServer(builder); {
throw new Exception("Test exception");
});
})
.ConfigureServices(services => services.AddMiddlewareAnalysis());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener(); var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener); diagnosticListener.SubscribeWithAdapter(listener);

29
src/Middleware/NodeServices/samples/NodeServicesExamples/Startup.cs
View File

@ -3,11 +3,13 @@
using System; using System;
using System.IO; using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.NodeServices; using Microsoft.AspNetCore.NodeServices;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace NodeServicesExamples namespace NodeServicesExamples
@ -58,21 +60,24 @@ namespace NodeServicesExamples
} }
#pragma warning restore 0618 #pragma warning restore 0618
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging(factory => .ConfigureWebHost(webHostBuilder =>
{ {
factory.AddConsole(); webHostBuilder
factory.AddDebug(); .ConfigureLogging(factory =>
}) {
.UseContentRoot(Directory.GetCurrentDirectory()) factory.AddConsole();
.UseIISIntegration() factory.AddDebug();
.UseKestrel() })
.UseStartup<Startup>() .UseContentRoot(Directory.GetCurrentDirectory())
.Build(); .UseIISIntegration()
.UseKestrel()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

21
src/Middleware/ResponseCaching/samples/ResponseCachingSample/Startup.cs
View File

@ -3,10 +3,12 @@
using System; using System;
using System.IO; using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
namespace ResponseCachingSample namespace ResponseCachingSample
@ -34,16 +36,19 @@ namespace ResponseCachingSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseContentRoot(Directory.GetCurrentDirectory()) {
.UseIISIntegration() webHostBuilder
.UseStartup<Startup>() .UseKestrel()
.Build(); .UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

222
src/Middleware/ResponseCaching/test/ResponseCachingTests.cs
View File

@ -22,7 +22,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "")); var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, ""));
@ -42,7 +46,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "")); var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, ""));
@ -60,7 +68,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.PostAsync("", new StringContent(string.Empty)); var initialResponse = await client.PostAsync("", new StringContent(string.Empty));
@ -78,7 +90,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var subsequentResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Head, "")); var subsequentResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Head, ""));
@ -96,7 +112,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "")); var initialResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, ""));
@ -116,7 +136,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
@ -145,7 +169,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
@ -174,7 +202,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "path")); var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "path"));
@ -194,7 +226,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "?Expires=0")); var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "?Expires=0"));
@ -214,7 +250,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("abc"); client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("abc");
@ -233,7 +273,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.From = "user@example.com"; client.DefaultRequestHeaders.From = "user@example.com";
@ -252,7 +296,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.From = "user@example.com"; client.DefaultRequestHeaders.From = "user@example.com";
@ -272,7 +320,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?query=value"); var initialResponse = await client.GetAsync("?query=value");
@ -290,7 +342,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb"); var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -308,7 +364,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb"); var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -326,7 +386,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB"); var initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB");
@ -344,7 +408,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB"); var initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB");
@ -362,7 +430,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?query=value"); var initialResponse = await client.GetAsync("?query=value");
@ -380,7 +452,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb"); var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -398,7 +474,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb"); var initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -416,7 +496,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -438,7 +522,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -461,7 +549,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -479,7 +571,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -501,7 +597,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.CacheControl = new System.Net.Http.Headers.CacheControlHeaderValue() client.DefaultRequestHeaders.CacheControl = new System.Net.Http.Headers.CacheControlHeaderValue()
@ -523,7 +623,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -546,7 +650,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?Expires=90"); var initialResponse = await client.GetAsync("?Expires=90");
@ -567,7 +675,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -591,7 +703,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("?Expires=90"); var initialResponse = await client.GetAsync("?Expires=90");
@ -612,7 +728,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -634,7 +754,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -655,7 +779,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync(""); var initialResponse = await client.GetAsync("");
@ -676,7 +804,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.GetAsync("/path"); var initialResponse = await client.GetAsync("/path");
@ -694,7 +826,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.From = "user@example.com"; client.DefaultRequestHeaders.From = "user@example.com";
@ -716,7 +852,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.From = "user@example.com"; client.DefaultRequestHeaders.From = "user@example.com";
@ -747,7 +887,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
client.DefaultRequestHeaders.From = "user@example.com"; client.DefaultRequestHeaders.From = "user@example.com";
@ -778,7 +922,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var builder in builders) foreach (var builder in builders)
{ {
using (var server = new TestServer(builder)) using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{ {
var client = server.CreateClient(); var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest("HEAD", "?contentLength=10")); var initialResponse = await client.SendAsync(TestUtils.CreateRequest("HEAD", "?contentLength=10"));

39
src/Middleware/ResponseCaching/test/TestUtils.cs
View File

@ -12,7 +12,9 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
@ -116,7 +118,7 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
return new ResponseCachingKeyProvider(new DefaultObjectPoolProvider(), Options.Create(options)); return new ResponseCachingKeyProvider(new DefaultObjectPoolProvider(), Options.Create(options));
} }
internal static IEnumerable<IWebHostBuilder> CreateBuildersWithResponseCaching( internal static IEnumerable<IHostBuilder> CreateBuildersWithResponseCaching(
Action<IApplicationBuilder> configureDelegate = null, Action<IApplicationBuilder> configureDelegate = null,
ResponseCachingOptions options = null, ResponseCachingOptions options = null,
Action<HttpContext> contextAction = null) Action<HttpContext> contextAction = null)
@ -141,7 +143,7 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
}); });
} }
private static IEnumerable<IWebHostBuilder> CreateBuildersWithResponseCaching( private static IEnumerable<IHostBuilder> CreateBuildersWithResponseCaching(
Action<IApplicationBuilder> configureDelegate = null, Action<IApplicationBuilder> configureDelegate = null,
ResponseCachingOptions options = null, ResponseCachingOptions options = null,
IEnumerable<RequestDelegate> requestDelegates = null) IEnumerable<RequestDelegate> requestDelegates = null)
@ -162,24 +164,29 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var requestDelegate in requestDelegates) foreach (var requestDelegate in requestDelegates)
{ {
// Test with in memory ResponseCache // Test with in memory ResponseCache
yield return new WebHostBuilder() yield return new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCaching(responseCachingOptions => webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{ {
if (options != null) services.AddResponseCaching(responseCachingOptions =>
{ {
responseCachingOptions.MaximumBodySize = options.MaximumBodySize; if (options != null)
responseCachingOptions.UseCaseSensitivePaths = options.UseCaseSensitivePaths; {
responseCachingOptions.SystemClock = options.SystemClock; responseCachingOptions.MaximumBodySize = options.MaximumBodySize;
} responseCachingOptions.UseCaseSensitivePaths = options.UseCaseSensitivePaths;
responseCachingOptions.SystemClock = options.SystemClock;
}
});
})
.Configure(app =>
{
configureDelegate(app);
app.UseResponseCaching();
app.Run(requestDelegate);
}); });
})
.Configure(app =>
{
configureDelegate(app);
app.UseResponseCaching();
app.Run(requestDelegate);
}); });
} }
} }

24
src/Middleware/ResponseCompression/sample/Startup.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.ResponseCompression; using Microsoft.AspNetCore.ResponseCompression;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace ResponseCompressionSample namespace ResponseCompressionSample
@ -71,19 +72,22 @@ namespace ResponseCompressionSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.ConfigureLogging(factory =>
{ {
factory.AddConsole() webHostBuilder
.SetMinimumLevel(LogLevel.Debug); .UseKestrel()
}) .ConfigureLogging(factory =>
.UseStartup<Startup>() {
.Build(); factory.AddConsole()
.SetMinimumLevel(LogLevel.Debug);
})
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

705
src/Middleware/ResponseCompression/test/ResponseCompressionMiddlewareTest.cs
View File

@ -17,6 +17,7 @@ using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.AspNetCore.Testing; using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
@ -134,24 +135,31 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
[Fact] [Fact]
public async Task GZipCompressionProvider_OptionsSetInDI_Compress() public async Task GZipCompressionProvider_OptionsSetInDI_Compress()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.Configure<GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.NoCompression); webHostBuilder
services.AddResponseCompression(); .UseTestServer()
}) .ConfigureServices(services =>
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.Configure<GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.NoCompression);
context.Response.ContentType = TextPlain; services.AddResponseCompression();
return context.Response.WriteAsync(new string('a', 100)); })
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -286,23 +294,30 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
[InlineData("text/plain2")] [InlineData("text/plain2")]
public async Task NoBody_NotCompressed(string contentType) public async Task NoBody_NotCompressed(string contentType)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = contentType; })
return Task.FromResult(0); .Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = contentType;
return Task.FromResult(0);
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -413,30 +428,35 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>); TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
services.AddResponseCompression(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.EnableForHttps = enableHttps; services.AddSingleton<ILoggerFactory>(loggerFactory);
options.MimeTypes = new[] { TextPlain }; services.AddResponseCompression(options =>
}); {
}) options.EnableForHttps = enableHttps;
.Configure(app => options.MimeTypes = new[] { TextPlain };
{ });
app.UseResponseCompression(); })
app.Run(context => .Configure(app =>
{ {
context.Response.ContentType = TextPlain; app.UseResponseCompression();
return context.Response.WriteAsync(new string('a', 100)); app.Run(context =>
{
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder) await host.StartAsync();
{
BaseAddress = new Uri("https://localhost/") var server = host.GetTestServer();
}; server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient(); var client = server.CreateClient();
@ -469,32 +489,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>); TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
services.AddResponseCompression(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.EnableForHttps = false; services.AddSingleton<ILoggerFactory>(loggerFactory);
options.MimeTypes = new[] { TextPlain }; services.AddResponseCompression(options =>
}); {
}) options.EnableForHttps = false;
.Configure(app => options.MimeTypes = new[] { TextPlain };
{ });
app.UseResponseCompression(); })
app.Run(context => .Configure(app =>
{ {
var feature = context.Features.Get<IHttpsCompressionFeature>(); app.UseResponseCompression();
feature.Mode = mode; app.Run(context =>
context.Response.ContentType = TextPlain; {
return context.Response.WriteAsync(new string('a', 100)); var feature = context.Features.Get<IHttpsCompressionFeature>();
feature.Mode = mode;
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder) await host.StartAsync();
{
BaseAddress = new Uri("https://localhost/") var server = host.GetTestServer();
}; server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient(); var client = server.CreateClient();
@ -527,32 +552,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>); TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddSingleton<ILoggerFactory>(loggerFactory); webHostBuilder
services.AddResponseCompression(options => .UseTestServer()
.ConfigureServices(services =>
{ {
options.EnableForHttps = true; services.AddSingleton<ILoggerFactory>(loggerFactory);
options.MimeTypes = new[] { TextPlain }; services.AddResponseCompression(options =>
}); {
}) options.EnableForHttps = true;
.Configure(app => options.MimeTypes = new[] { TextPlain };
{ });
app.UseResponseCompression(); })
app.Run(context => .Configure(app =>
{ {
var feature = context.Features.Get<IHttpsCompressionFeature>(); app.UseResponseCompression();
feature.Mode = mode; app.Run(context =>
context.Response.ContentType = TextPlain; {
return context.Response.WriteAsync(new string('a', 100)); var feature = context.Features.Get<IHttpsCompressionFeature>();
feature.Mode = mode;
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder) await host.StartAsync();
{
BaseAddress = new Uri("https://localhost/") var server = host.GetTestServer();
}; server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient(); var client = server.CreateClient();
@ -580,28 +610,33 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = TextPlain; })
context.Response.Body.Flush(); .Configure(app =>
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); {
await context.Response.WriteAsync(new string('a', 100)); app.UseResponseCompression();
app.Run(async context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
context.Response.Body.Flush();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
await context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder) await host.StartAsync();
{
AllowSynchronousIO = true // needed for synchronous flush var server = host.GetTestServer();
}; server.AllowSynchronousIO = true; // needed for synchronous flush
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -621,25 +656,32 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = TextPlain; })
await context.Response.Body.FlushAsync(); .Configure(app =>
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); {
await context.Response.WriteAsync(new string('a', 100)); app.UseResponseCompression();
app.Run(async context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
await context.Response.Body.FlushAsync();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
await context.Response.WriteAsync(new string('a', 100));
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -659,32 +701,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
var feature = context.Features.Get<IHttpBodyControlFeature>(); services.AddResponseCompression();
if (feature != null) })
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
feature.AllowSynchronousIO = true; var feature = context.Features.Get<IHttpBodyControlFeature>();
} if (feature != null)
{
feature.AllowSynchronousIO = true;
}
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain; context.Response.ContentType = TextPlain;
context.Response.Body.Write(new byte[10], 0, 10); context.Response.Body.Write(new byte[10], 0, 10);
context.Response.Body.Flush(); context.Response.Body.Flush();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
context.Response.Body.Write(new byte[90], 0, 90); context.Response.Body.Write(new byte[90], 0, 90);
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -711,26 +760,33 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = TextPlain; })
await context.Response.WriteAsync(new string('a', 10)); .Configure(app =>
await context.Response.Body.FlushAsync(); {
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); app.UseResponseCompression();
await context.Response.WriteAsync(new string('a', 90)); app.Run(async context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
await context.Response.WriteAsync(new string('a', 10));
await context.Response.Body.FlushAsync();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
await context.Response.WriteAsync(new string('a', 90));
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -764,36 +820,43 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously), new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously),
}; };
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = TextPlain; })
context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering(); .Configure(app =>
{
var feature = context.Features.Get<IHttpBodyControlFeature>(); app.UseResponseCompression();
if (feature != null) app.Run(async context =>
{ {
feature.AllowSynchronousIO = true; context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
} context.Response.ContentType = TextPlain;
context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering();
foreach (var signal in responseReceived) var feature = context.Features.Get<IHttpBodyControlFeature>();
{ if (feature != null)
context.Response.Body.Write(new byte[1], 0, 1); {
context.Response.Body.Flush(); feature.AllowSynchronousIO = true;
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); }
}
foreach (var signal in responseReceived)
{
context.Response.Body.Write(new byte[1], 0, 1);
context.Response.Body.Flush();
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -827,30 +890,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously), new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously),
}; };
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression();
context.Response.ContentType = TextPlain; })
context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering(); .Configure(app =>
{
foreach (var signal in responseReceived) app.UseResponseCompression();
app.Run(async context =>
{ {
await context.Response.WriteAsync("a"); context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
await context.Response.Body.FlushAsync(); context.Response.ContentType = TextPlain;
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering();
}
});
});
var server = new TestServer(builder); foreach (var signal in responseReceived)
{
await context.Response.WriteAsync("a");
await context.Response.Body.FlushAsync();
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
});
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -876,32 +946,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
FakeSendFileFeature fakeSendFile = null; FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use((context, next) =>
{ {
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>()); services.AddResponseCompression();
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile); })
return next(); .Configure(app =>
});
app.UseResponseCompression();
app.Run(context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; app.Use((context, next) =>
context.Response.ContentType = "custom/type"; {
context.Response.ContentLength = 1024; fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
var sendFile = context.Features.Get<IHttpResponseBodyFeature>(); context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
Assert.NotNull(sendFile); return next();
return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); });
app.UseResponseCompression();
app.Run(context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = "custom/type";
context.Response.ContentLength = 1024;
var sendFile = context.Features.Get<IHttpResponseBodyFeature>();
Assert.NotNull(sendFile);
return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -919,32 +996,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
FakeSendFileFeature fakeSendFile = null; FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use((context, next) =>
{ {
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>()); services.AddResponseCompression();
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile); })
return next(); .Configure(app =>
});
app.UseResponseCompression();
app.Run(context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; app.Use((context, next) =>
context.Response.ContentType = TextPlain; {
context.Response.ContentLength = 1024; fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
var sendFile = context.Features.Get<IHttpResponseBodyFeature>(); context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
Assert.NotNull(sendFile); return next();
return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); });
app.UseResponseCompression();
app.Run(context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
context.Response.ContentLength = 1024;
var sendFile = context.Features.Get<IHttpResponseBodyFeature>();
Assert.NotNull(sendFile);
return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -962,32 +1046,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
FakeSendFileFeature fakeSendFile = null; FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use((context, next) =>
{ {
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>()); services.AddResponseCompression();
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile); })
return next(); .Configure(app =>
});
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; app.Use((context, next) =>
context.Response.ContentType = TextPlain; {
var feature = context.Features.Get<IHttpResponseBodyFeature>(); fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
app.UseResponseCompression();
app.Run(async context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
var feature = context.Features.Get<IHttpResponseBodyFeature>();
await context.Response.WriteAsync(new string('a', 100)); await context.Response.WriteAsync(new string('a', 100));
await feature.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); await feature.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -1006,31 +1097,38 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{ {
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(); webHostBuilder
}) .UseTestServer()
.Configure(app => .ConfigureServices(services =>
{
app.Use((context, next) =>
{ {
context.Response.Body = new NoSyncWrapperStream(context.Response.Body); services.AddResponseCompression();
return next(); })
}); .Configure(app =>
app.UseResponseCompression();
app.Run(async context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; app.Use((context, next) =>
context.Response.ContentType = TextPlain; {
await context.Response.WriteAsync(new string('a', 10)); context.Response.Body = new NoSyncWrapperStream(context.Response.Body);
await context.Response.Body.FlushAsync(); return next();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3)); });
await context.Response.WriteAsync(new string('a', 90)); app.UseResponseCompression();
app.Run(async context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
await context.Response.WriteAsync(new string('a', 10));
await context.Response.Body.FlushAsync();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
await context.Response.WriteAsync(new string('a', 90));
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -1063,25 +1161,32 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>); TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true); var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddResponseCompression(configure ?? (_ => { })); webHostBuilder
services.AddSingleton<ILoggerFactory>(loggerFactory); .UseTestServer()
}) .ConfigureServices(services =>
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
{ {
context.Response.Headers[HeaderNames.ContentMD5] = "MD5"; services.AddResponseCompression(configure ?? (_ => { }));
context.Response.ContentType = responseType; services.AddSingleton<ILoggerFactory>(loggerFactory);
addResponseAction?.Invoke(context.Response); })
return context.Response.WriteAsync(new string('a', uncompressedBodyLength)); .Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = responseType;
addResponseAction?.Invoke(context.Response);
return context.Response.WriteAsync(new string('a', uncompressedBodyLength));
});
}); });
}); }).Build();
var server = new TestServer(builder); await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient(); var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, ""); var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -1090,7 +1195,9 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
request.Headers.AcceptEncoding.Add(System.Net.Http.Headers.StringWithQualityHeaderValue.Parse(requestAcceptEncodings[i])); request.Headers.AcceptEncoding.Add(System.Net.Http.Headers.StringWithQualityHeaderValue.Parse(requestAcceptEncodings[i]));
} }
return (await client.SendAsync(request), sink.Writes.ToList()); var response = await client.SendAsync(request);
return (response, sink.Writes.ToList());
} }
private void CheckResponseCompressed(HttpResponseMessage response, int expectedBodyLength, string expectedEncoding) private void CheckResponseCompressed(HttpResponseMessage response, int expectedBodyLength, string expectedEncoding)

31
src/Middleware/Rewrite/sample/Startup.cs
View File

@ -3,11 +3,13 @@
using System.IO; using System.IO;
using System.Net; using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Rewrite; using Microsoft.AspNetCore.Rewrite;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace RewriteSample namespace RewriteSample
{ {
@ -42,23 +44,26 @@ namespace RewriteSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel(options => .ConfigureWebHost(webHostBuilder =>
{ {
options.Listen(IPAddress.Loopback, 5000); webHostBuilder
options.Listen(IPAddress.Loopback, 5001, listenOptions => .UseKestrel(options =>
{ {
// Configure SSL options.Listen(IPAddress.Loopback, 5000);
listenOptions.UseHttps("testCert.pfx", "testPassword"); options.Listen(IPAddress.Loopback, 5001, listenOptions =>
}); {
}) // Configure SSL
.UseStartup<Startup>() listenOptions.UseHttps("testCert.pfx", "testPassword");
.UseContentRoot(Directory.GetCurrentDirectory()) });
.Build(); })
.UseStartup<Startup>()
.UseContentRoot(Directory.GetCurrentDirectory());
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

377
src/Middleware/Rewrite/test/ApacheModRewrite/ModRewriteMiddlewareTest.cs
View File

@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
@ -19,13 +20,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_RewritePathWhenMatching() public async Task Invoke_RewritePathWhenMatching()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 ")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 "));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/hey/hello"); var response = await server.CreateClient().GetStringAsync("/hey/hello");
@ -37,13 +46,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 [L]")) var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 [L]"))
.AddApacheModRewrite(new StringReader("RewriteRule /hello /what")); .AddApacheModRewrite(new StringReader("RewriteRule /hello /what"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/hey/hello"); var response = await server.CreateClient().GetStringAsync("/hey/hello");
@ -55,13 +72,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1")) var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1"))
.AddApacheModRewrite(new StringReader("RewriteRule /hello /what")); .AddApacheModRewrite(new StringReader("RewriteRule /hello /what"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/hey/hello"); var response = await server.CreateClient().GetStringAsync("/hey/hello");
@ -72,13 +97,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldIgnoreComments() public async Task Invoke_ShouldIgnoreComments()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("#RewriteRule ^/hey/(.*) /$1 ")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader("#RewriteRule ^/hey/(.*) /$1 "));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/hey/hello"); var response = await server.CreateClient().GetStringAsync("/hey/hello");
@ -89,13 +122,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldRewriteHomepage() public async Task Invoke_ShouldRewriteHomepage()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org/"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org/");
@ -106,13 +147,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldIgnorePorts() public async Task Invoke_ShouldIgnorePorts()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org:42/"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org:42/");
@ -123,13 +172,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_HandleNegatedRewriteRules() public async Task Invoke_HandleNegatedRewriteRules()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule !^/$ /homepage.html")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule !^/$ /homepage.html"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org/"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org/");
@ -142,13 +199,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_BackReferencesShouldBeApplied(string url, string rule, string expected) public async Task Invoke_BackReferencesShouldBeApplied(string url, string rule, string expected)
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule)); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(url); var response = await server.CreateClient().GetStringAsync(url);
@ -165,13 +230,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldHandleFlagNoCase(string url, string rule, string expected) public async Task Invoke_ShouldHandleFlagNoCase(string url, string rule, string expected)
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule)); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(url); var response = await server.CreateClient().GetStringAsync(url);
@ -183,13 +256,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/")); .AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun");
@ -201,13 +282,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/")); .AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun");
@ -219,13 +308,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/")); .AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun"); var response = await server.CreateClient().GetStringAsync("http://www.foo.org/blog/2016-jun");
@ -238,13 +335,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteCond %{REQUEST_URI} /foo/ \nRewriteCond %{HTTPS} !on \nRewriteRule ^(.*)$ https://www.example.com$1 [R=301,L]")); .AddApacheModRewrite(new StringReader("RewriteCond %{REQUEST_URI} /foo/ \nRewriteCond %{HTTPS} !on \nRewriteRule ^(.*)$ https://www.example.com$1 [R=301,L]"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(input); var response = await server.CreateClient().GetAsync(input);
@ -258,13 +363,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [R=301,L]")); .AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [R=301,L]"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(input); var response = await server.CreateClient().GetAsync(input);
@ -278,13 +391,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{ {
var options = new RewriteOptions() var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [L]")); .AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [L]"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(input); var response = await server.CreateClient().GetStringAsync(input);
Assert.Equal("/", response); Assert.Equal("/", response);
@ -294,15 +415,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_CaptureEmptyStringInRegexAssertLocationHeaderContainsPathBase() public async Task Invoke_CaptureEmptyStringInRegexAssertLocationHeaderContainsPathBase()
{ {
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^(.*)$ $1 [R=301,L]")); var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^(.*)$ $1 [R=301,L]"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Path + .Configure(app =>
context.Request.QueryString)); {
}); app.UseRewriter(options);
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") }; app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("http://localhost:5000/foo");
var response = await server.CreateClient().GetAsync(""); var response = await server.CreateClient().GetAsync("");
@ -315,15 +445,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteCond %{REQUEST_URI} /home var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteCond %{REQUEST_URI} /home
RewriteCond %{QUERY_STRING} report_id=(.+) RewriteCond %{QUERY_STRING} report_id=(.+)
RewriteRule (.*) http://localhost:80/home/report/%1 [R=301,L,QSD]")); RewriteRule (.*) http://localhost:80/home/report/%1 [R=301,L,QSD]"));
var builder = new WebHostBuilder().Configure(app => using var host = new HostBuilder()
{ .ConfigureWebHost(webHostBuilder =>
app.UseRewriter(options); {
app.Run(context => context.Response.WriteAsync( webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path + context.Request.Path +
context.Request.QueryString)); context.Request.QueryString));
}); });
}).Build();
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") }; await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("http://localhost:5000/foo");
var response = await server.CreateClient().GetAsync("/home?report_id=123"); var response = await server.CreateClient().GetAsync("/home?report_id=123");
Assert.Equal("http://localhost:80/home/report/123", response.Headers.Location.OriginalString); Assert.Equal("http://localhost:80/home/report/123", response.Headers.Location.OriginalString);

428
src/Middleware/Rewrite/test/IISUrlRewrite/MiddleWareTests.cs
View File

@ -15,6 +15,7 @@ using Microsoft.AspNetCore.Rewrite.IISUrlRewrite;
using Microsoft.AspNetCore.Rewrite.UrlActions; using Microsoft.AspNetCore.Rewrite.UrlActions;
using Microsoft.AspNetCore.Rewrite.UrlMatches; using Microsoft.AspNetCore.Rewrite.UrlMatches;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
using Xunit; using Xunit;
@ -33,13 +34,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location])); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location]));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("article/10/hey"); var response = await server.CreateClient().GetAsync("article/10/hey");
@ -57,13 +66,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("/article/10/hey"); var response = await server.CreateClient().GetStringAsync("/article/10/hey");
@ -85,13 +102,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString)); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("page.asp?p2=321&p1=123"); var response = await server.CreateClient().GetStringAsync("page.asp?p2=321&p1=123");
@ -109,13 +134,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location])); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location]));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("HElLo"); var response = await server.CreateClient().GetAsync("HElLo");
@ -137,12 +170,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello/"); var response = await server.CreateClient().GetAsync("hey/hello/");
@ -164,12 +205,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello"); var response = await server.CreateClient().GetAsync("hey/hello");
@ -190,12 +239,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com")); var response = await server.CreateClient().GetAsync(new Uri("http://example.com"));
@ -216,18 +273,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Scheme + .Configure(app =>
"://" + {
context.Request.Host + app.UseRewriter(options);
context.Request.Path + app.Run(context => context.Response.WriteAsync(
context.Request.QueryString)); context.Request.Scheme +
}); "://" +
var server = new TestServer(builder); context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com")); var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com"));
@ -245,18 +310,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Scheme + .Configure(app =>
"://" + {
context.Request.Host + app.UseRewriter(options);
context.Request.Path + app.Run(context => context.Response.WriteAsync(
context.Request.QueryString)); context.Request.Scheme +
}); "://" +
var server = new TestServer(builder); context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com/")); var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com/"));
@ -274,18 +347,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Scheme + .Configure(app =>
"://" + {
context.Request.Host + app.UseRewriter(options);
context.Request.Path + app.Run(context => context.Response.WriteAsync(
context.Request.QueryString)); context.Request.Scheme +
}); "://" +
var server = new TestServer(builder); context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com/")); var response = await server.CreateClient().GetAsync(new Uri("http://example.com/"));
@ -303,15 +384,23 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Path + .Configure(app =>
context.Request.QueryString)); {
}); app.UseRewriter(options);
var server = new TestServer(builder); app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com/")); var response = await server.CreateClient().GetStringAsync(new Uri("http://example.com/"));
@ -329,15 +418,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Path + .Configure(app =>
context.Request.QueryString)); {
}); app.UseRewriter(options);
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") }; app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("http://localhost:5000/foo");
var response = await server.CreateClient().GetAsync(""); var response = await server.CreateClient().GetAsync("");
@ -362,12 +460,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello"); var response = await server.CreateClient().GetAsync("hey/hello");
@ -390,12 +496,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("article/23?p1=123&p2=abc"); var response = await server.CreateClient().GetAsync("article/23?p1=123&p2=abc");
@ -418,12 +532,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("article/23?p1=123&p2=abc"); var response = await server.CreateClient().GetAsync("article/23?p1=123&p2=abc");
@ -447,12 +569,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var ex = await Assert.ThrowsAsync<IndexOutOfRangeException>(() => server.CreateClient().GetAsync("article/23?p1=123&p2=abc")); var ex = await Assert.ThrowsAsync<IndexOutOfRangeException>(() => server.CreateClient().GetAsync("article/23?p1=123&p2=abc"));
@ -475,13 +605,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</globalRules> </globalRules>
</rewrite>"; </rewrite>";
var options = new RewriteOptions().AddIISUrlRewrite(new StringReader(xml)); var options = new RewriteOptions().AddIISUrlRewrite(new StringReader(xml));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl())); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// act // act
var response = await server.CreateClient().GetStringAsync($"http://localhost/{Guid.NewGuid()}/foo/bar"); var response = await server.CreateClient().GetStringAsync($"http://localhost/{Guid.NewGuid()}/foo/bar");
@ -512,13 +650,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rewriteMap> </rewriteMap>
</rewriteMaps> </rewriteMaps>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl())); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(new Uri(requestUri)); var response = await server.CreateClient().GetStringAsync(new Uri(requestUri));
@ -536,12 +682,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule> </rule>
</rules> </rules>
</rewrite>")); </rewrite>"));
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("article/10/hey"); var response = await server.CreateClient().GetAsync("article/10/hey");
var content = await response.Content.ReadAsStringAsync(); var content = await response.Content.ReadAsStringAsync();
@ -583,13 +737,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
ruleBuilder.AddUrlAction(action); ruleBuilder.AddUrlAction(action);
var options = new RewriteOptions().Add(ruleBuilder.Build()); var options = new RewriteOptions().Add(ruleBuilder.Build());
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl())); .UseTestServer()
}); .Configure(app =>
var server = new TestServer(builder); {
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// act // act
var response = await server.CreateClient().GetStringAsync("http://localhost/foo/bar"); var response = await server.CreateClient().GetStringAsync("http://localhost/foo/bar");

442
src/Middleware/Rewrite/test/MiddlewareTests.cs
View File

@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit; using Xunit;
namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
@ -18,18 +19,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRewritePath() public async Task CheckRewritePath()
{ {
var options = new RewriteOptions().AddRewrite("(.*)", "http://example.com/$1", skipRemainingRules: false); var options = new RewriteOptions().AddRewrite("(.*)", "http://example.com/$1", skipRemainingRules: false);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Scheme + .Configure(app =>
"://" + {
context.Request.Host + app.UseRewriter(options);
context.Request.Path + app.Run(context => context.Response.WriteAsync(
context.Request.QueryString)); context.Request.Scheme +
}); "://" +
var server = new TestServer(builder); context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("foo"); var response = await server.CreateClient().GetStringAsync("foo");
@ -40,12 +49,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectPath() public async Task CheckRedirectPath()
{ {
var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently); var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("foo"); var response = await server.CreateClient().GetAsync("foo");
@ -55,19 +72,27 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
[Fact] [Fact]
public async Task RewriteRulesCanComeFromConfigureOptions() public async Task RewriteRulesCanComeFromConfigureOptions()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{
services.Configure<RewriteOptions>(options =>
{ {
options.AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently); webHostBuilder
}); .UseTestServer()
}) .ConfigureServices(services =>
.Configure(app => {
{ services.Configure<RewriteOptions>(options =>
app.UseRewriter(); {
}); options.AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
var server = new TestServer(builder); });
})
.Configure(app =>
{
app.UseRewriter();
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("foo"); var response = await server.CreateClient().GetAsync("foo");
@ -78,12 +103,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectPathWithQueryString() public async Task CheckRedirectPathWithQueryString()
{ {
var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently); var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("foo?bar=1"); var response = await server.CreateClient().GetAsync("foo?bar=1");
@ -98,12 +131,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToHttps(int statusCode) public async Task CheckRedirectToHttps(int statusCode)
{ {
var options = new RewriteOptions().AddRedirectToHttps(statusCode: statusCode); var options = new RewriteOptions().AddRedirectToHttps(statusCode: statusCode);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com")); var response = await server.CreateClient().GetAsync(new Uri("http://example.com"));
@ -115,12 +156,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToHttps() public async Task CheckPermanentRedirectToHttps()
{ {
var options = new RewriteOptions().AddRedirectToHttpsPermanent(); var options = new RewriteOptions().AddRedirectToHttpsPermanent();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com")); var response = await server.CreateClient().GetAsync(new Uri("http://example.com"));
@ -134,12 +183,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToHttpsWithSslPort(int sslPort, string expected) public async Task CheckRedirectToHttpsWithSslPort(int sslPort, string expected)
{ {
var options = new RewriteOptions().AddRedirectToHttps(statusCode: StatusCodes.Status301MovedPermanently, sslPort: sslPort); var options = new RewriteOptions().AddRedirectToHttps(statusCode: StatusCodes.Status301MovedPermanently, sslPort: sslPort);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com")); var response = await server.CreateClient().GetAsync(new Uri("http://example.com"));
@ -155,12 +212,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToWwwWithStatusCode(int statusCode) public async Task CheckRedirectToWwwWithStatusCode(int statusCode)
{ {
var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode); var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://example.com"));
@ -176,12 +241,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToWww(string requestUri, string redirectUri) public async Task CheckRedirectToWww(string requestUri, string redirectUri)
{ {
var options = new RewriteOptions().AddRedirectToWww(); var options = new RewriteOptions().AddRedirectToWww();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri)); var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -193,12 +266,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToWww() public async Task CheckPermanentRedirectToWww()
{ {
var options = new RewriteOptions().AddRedirectToWwwPermanent(); var options = new RewriteOptions().AddRedirectToWwwPermanent();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://example.com"));
@ -220,12 +301,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckNoRedirectToWww(string requestUri) public async Task CheckNoRedirectToWww(string requestUri)
{ {
var options = new RewriteOptions().AddRedirectToWww(); var options = new RewriteOptions().AddRedirectToWww();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri)); var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -240,12 +329,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToNonWwwWithStatusCode(int statusCode) public async Task CheckRedirectToNonWwwWithStatusCode(int statusCode)
{ {
var options = new RewriteOptions().AddRedirectToNonWww(statusCode: statusCode); var options = new RewriteOptions().AddRedirectToNonWww(statusCode: statusCode);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://www.example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://www.example.com"));
@ -261,12 +358,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToNonWww(string requestUri, string redirectUri) public async Task CheckRedirectToNonWww(string requestUri, string redirectUri)
{ {
var options = new RewriteOptions().AddRedirectToNonWww(); var options = new RewriteOptions().AddRedirectToNonWww();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri)); var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -278,12 +383,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToNonWww() public async Task CheckPermanentRedirectToNonWww()
{ {
var options = new RewriteOptions().AddRedirectToNonWwwPermanent(); var options = new RewriteOptions().AddRedirectToNonWwwPermanent();
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://www.example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://www.example.com"));
@ -295,12 +408,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckIfEmptyStringRedirectCorrectly() public async Task CheckIfEmptyStringRedirectCorrectly()
{ {
var options = new RewriteOptions().AddRedirect("(.*)", "$1", statusCode: StatusCodes.Status301MovedPermanently); var options = new RewriteOptions().AddRedirect("(.*)", "$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(""); var response = await server.CreateClient().GetAsync("");
Assert.Equal("/", response.Headers.Location.OriginalString); Assert.Equal("/", response.Headers.Location.OriginalString);
@ -310,15 +431,23 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckIfEmptyStringRewriteCorrectly() public async Task CheckIfEmptyStringRewriteCorrectly()
{ {
var options = new RewriteOptions().AddRewrite("(.*)", "$1", skipRemainingRules: false); var options = new RewriteOptions().AddRewrite("(.*)", "$1", skipRemainingRules: false);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Path + .Configure(app =>
context.Request.QueryString)); {
}); app.UseRewriter(options);
var server = new TestServer(builder); app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync(""); var response = await server.CreateClient().GetStringAsync("");
@ -329,15 +458,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task SettingPathBase() public async Task SettingPathBase()
{ {
var options = new RewriteOptions().AddRedirect("(.*)", "$1"); var options = new RewriteOptions().AddRedirect("(.*)", "$1");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
app.Run(context => context.Response.WriteAsync( .UseTestServer()
context.Request.Path + .Configure(app =>
context.Request.QueryString)); {
}); app.UseRewriter(options);
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") }; app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("http://localhost:5000/foo");
var response = await server.CreateClient().GetAsync(""); var response = await server.CreateClient().GetAsync("");
@ -353,12 +491,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckNoRedirectToWwwInNonWhitelistedDomains(string requestUri) public async Task CheckNoRedirectToWwwInNonWhitelistedDomains(string requestUri)
{ {
var options = new RewriteOptions().AddRedirectToWww("example2.com"); var options = new RewriteOptions().AddRedirectToWww("example2.com");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri)); var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -373,12 +519,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToWwwInWhitelistedDomains(string requestUri, string redirectUri) public async Task CheckRedirectToWwwInWhitelistedDomains(string requestUri, string redirectUri)
{ {
var options = new RewriteOptions().AddRedirectToWww("example.com"); var options = new RewriteOptions().AddRedirectToWww("example.com");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri)); var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -390,12 +544,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToWwwInWhitelistedDomains() public async Task CheckPermanentRedirectToWwwInWhitelistedDomains()
{ {
var options = new RewriteOptions().AddRedirectToWwwPermanent("example.com"); var options = new RewriteOptions().AddRedirectToWwwPermanent("example.com");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://example.com"));
@ -411,12 +573,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToWwwWithStatusCodeInWhitelistedDomains(int statusCode) public async Task CheckRedirectToWwwWithStatusCodeInWhitelistedDomains(int statusCode)
{ {
var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode, "example.com"); var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode, "example.com");
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.UseRewriter(options); webHostBuilder
}); .UseTestServer()
var server = new TestServer(builder); .Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("https://example.com")); var response = await server.CreateClient().GetAsync(new Uri("https://example.com"));

21
src/Middleware/Session/samples/Startup.cs
View File

@ -2,10 +2,12 @@
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace SessionSample namespace SessionSample
@ -81,16 +83,19 @@ namespace SessionSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging(factory => factory.AddConsole()) .ConfigureWebHost(webHostBuilder =>
.UseKestrel() {
.UseIISIntegration() webHostBuilder
.UseStartup<Startup>() .ConfigureLogging(factory => factory.AddConsole())
.Build(); .UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

990
src/Middleware/Session/test/SessionTests.cs
View File

File diff suppressed because it is too large Load Diff

31
src/Middleware/StaticFiles/samples/StaticFileSample/Startup.cs
View File

@ -1,8 +1,10 @@
using System; using System;
using System.IO; using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace StaticFilesSample namespace StaticFilesSample
@ -25,22 +27,25 @@ namespace StaticFilesSample
}); });
} }
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureLogging(factory => .ConfigureWebHost(webHostBuilder =>
{ {
factory.AddFilter("Console", level => level >= LogLevel.Debug); webHostBuilder
factory.AddConsole(); .ConfigureLogging(factory =>
}) {
.UseContentRoot(Directory.GetCurrentDirectory()) factory.AddFilter("Console", level => level >= LogLevel.Debug);
.UseKestrel() factory.AddConsole();
// .UseHttpSys() })
.UseIISIntegration() .UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup<Startup>() .UseKestrel()
.Build(); // .UseHttpSys()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run(); return host.RunAsync();
} }
} }
} }

131
src/Middleware/StaticFiles/test/FunctionalTests/FallbackStaticFileTest.cs
View File

@ -15,6 +15,7 @@ using Microsoft.AspNetCore.Server.IntegrationTesting.Common;
using Microsoft.AspNetCore.Testing; using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.FileProviders; using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
@ -25,94 +26,102 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task ReturnsFileForDefaultPattern() public async Task ReturnsFileForDefaultPattern()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddRouting(); webHostBuilder
services.AddSingleton(LoggerFactory); .ConfigureServices(services =>
})
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
var environment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
app.UseRouting();
app.UseEndpoints(endpoints =>
{ {
endpoints.Map("/hello", context => services.AddRouting();
services.AddSingleton(LoggerFactory);
})
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
var environment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
app.UseRouting();
app.UseEndpoints(endpoints =>
{ {
return context.Response.WriteAsync("Hello, world!"); endpoints.Map("/hello", context =>
}); {
return context.Response.WriteAsync("Hello, world!");
});
endpoints.MapFallbackToFile("default.html", new StaticFileOptions() endpoints.MapFallbackToFile("default.html", new StaticFileOptions()
{ {
FileProvider = new PhysicalFileProvider(Path.Combine(environment.WebRootPath, "SubFolder")), FileProvider = new PhysicalFileProvider(Path.Combine(environment.WebRootPath, "SubFolder")),
});
}); });
}); });
}); }).Build();
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel))) await host.StartAsync();
var environment = host.Services.GetRequiredService<IWebHostEnvironment>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{ {
var environment = server.Services.GetRequiredService<IWebHostEnvironment>(); var response = await client.GetAsync("hello");
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) }) var responseText = await response.Content.ReadAsStringAsync();
{
var response = await client.GetAsync("hello");
var responseText = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hello, world!", responseText); Assert.Equal("Hello, world!", responseText);
response = await client.GetAsync("/"); response = await client.GetAsync("/");
var responseContent = await response.Content.ReadAsByteArrayAsync(); var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "SubFolder/default.html", responseContent); AssertFileEquals(environment, "SubFolder/default.html", responseContent);
}
} }
} }
[Fact] [Fact]
public async Task ReturnsFileForCustomPattern() public async Task ReturnsFileForCustomPattern()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => .ConfigureWebHost(webHostBuilder =>
{ {
services.AddRouting(); webHostBuilder
services.AddSingleton(LoggerFactory); .ConfigureServices(services =>
})
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{ {
endpoints.Map("/hello", context => services.AddRouting();
services.AddSingleton(LoggerFactory);
})
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{ {
return context.Response.WriteAsync("Hello, world!"); endpoints.Map("/hello", context =>
{
return context.Response.WriteAsync("Hello, world!");
});
endpoints.MapFallbackToFile("/prefix/{*path:nonfile}", "TestDocument.txt");
}); });
endpoints.MapFallbackToFile("/prefix/{*path:nonfile}", "TestDocument.txt");
}); });
}); }).Build();
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel))) await host.StartAsync();
var environment = host.Services.GetRequiredService<IWebHostEnvironment>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{ {
var environment = server.Services.GetRequiredService<IWebHostEnvironment>(); var response = await client.GetAsync("hello");
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) }) var responseText = await response.Content.ReadAsStringAsync();
{
var response = await client.GetAsync("hello");
var responseText = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hello, world!", responseText); Assert.Equal("Hello, world!", responseText);
response = await client.GetAsync("prefix/Some-Path"); response = await client.GetAsync("prefix/Some-Path");
var responseContent = await response.Content.ReadAsByteArrayAsync(); var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "TestDocument.txt", responseContent); AssertFileEquals(environment, "TestDocument.txt", responseContent);
}
} }
} }

7
src/Middleware/StaticFiles/test/FunctionalTests/Helpers.cs
View File

@ -3,15 +3,18 @@
using System.Linq; using System.Linq;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features; using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.StaticFiles namespace Microsoft.AspNetCore.StaticFiles
{ {
public static class Helpers public static class Helpers
{ {
public static string GetAddress(IWebHost server) public static string GetAddress(IHost server)
{ {
return server.ServerFeatures.Get<IServerAddressesFeature>().Addresses.First(); return server.Services.GetService<IServer>().Features.Get<IServerAddressesFeature>().Addresses.First();
} }
} }
} }

300
src/Middleware/StaticFiles/test/FunctionalTests/StaticFileMiddlewareTests.cs
View File

@ -18,6 +18,7 @@ using Microsoft.AspNetCore.Server.IntegrationTesting;
using Microsoft.AspNetCore.Server.IntegrationTesting.Common; using Microsoft.AspNetCore.Server.IntegrationTesting.Common;
using Microsoft.AspNetCore.Testing; using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging.Testing; using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
@ -28,84 +29,96 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task ReturnsNotFoundWithoutWwwroot() public async Task ReturnsNotFoundWithoutWwwroot()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory)) .ConfigureWebHost(webHostBuilder =>
.UseKestrel()
.Configure(app => app.UseStaticFiles());
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
{
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) })
{ {
var response = await client.GetAsync("TestDocument.txt"); webHostBuilder
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.Configure(app => app.UseStaticFiles());
}).Build();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); await host.StartAsync();
}
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{
var response = await client.GetAsync("TestDocument.txt");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
} }
} }
[Fact] [Fact]
public async Task Endpoint_PassesThrough() public async Task Endpoint_PassesThrough()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => { services.AddSingleton(LoggerFactory); services.AddRouting(); }) .ConfigureWebHost(webHostBuilder =>
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{ {
// Routing first => static files noops webHostBuilder
app.UseRouting(); .ConfigureServices(services => { services.AddSingleton(LoggerFactory); services.AddRouting(); })
.UseKestrel()
app.Use(next => context => .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{ {
// Assign an endpoint, this will make the default files noop. // Routing first => static files noops
context.SetEndpoint(new Endpoint((c) => app.UseRouting();
app.Use(next => context =>
{ {
return context.Response.WriteAsync("Hi from endpoint."); // Assign an endpoint, this will make the default files noop.
}, context.SetEndpoint(new Endpoint((c) =>
new EndpointMetadataCollection(), {
"test")); return context.Response.WriteAsync("Hi from endpoint.");
},
new EndpointMetadataCollection(),
"test"));
return next(context); return next(context);
});
app.UseStaticFiles();
app.UseEndpoints(endpoints => { });
}); });
}).Build();
app.UseStaticFiles(); await host.StartAsync();
app.UseEndpoints(endpoints => {}); using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
});
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
{ {
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) }) var response = await client.GetAsync("TestDocument.txt");
{
var response = await client.GetAsync("TestDocument.txt");
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync()); Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync());
}
} }
} }
[Fact] [Fact]
public async Task FoundFile_LastModifiedTrimsSeconds() public async Task FoundFile_LastModifiedTrimsSeconds()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory)) .ConfigureWebHost(webHostBuilder =>
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app => app.UseStaticFiles());
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
{
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) })
{ {
var last = File.GetLastWriteTimeUtc(Path.Combine(AppContext.BaseDirectory, "TestDocument.txt")); webHostBuilder
var response = await client.GetAsync("TestDocument.txt"); .ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app => app.UseStaticFiles());
}).Build();
var trimmed = new DateTimeOffset(last.Year, last.Month, last.Day, last.Hour, last.Minute, last.Second, TimeSpan.Zero).ToUniversalTime(); await host.StartAsync();
Assert.Equal(response.Content.Headers.LastModified.Value, trimmed); using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
} {
var last = File.GetLastWriteTimeUtc(Path.Combine(AppContext.BaseDirectory, "TestDocument.txt"));
var response = await client.GetAsync("TestDocument.txt");
var trimmed = new DateTimeOffset(last.Year, last.Month, last.Day, last.Hour, last.Minute, last.Second, TimeSpan.Zero).ToUniversalTime();
Assert.Equal(response.Content.Headers.LastModified.Value, trimmed);
} }
} }
@ -130,36 +143,40 @@ namespace Microsoft.AspNetCore.StaticFiles
private async Task FoundFile_Served(string baseUrl, string baseDir, string requestUrl) private async Task FoundFile_Served(string baseUrl, string baseDir, string requestUrl)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory)) .ConfigureWebHost(webHostBuilder =>
.UseKestrel()
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
{ {
RequestPath = new PathString(baseUrl), webHostBuilder
})); .ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel))) .UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
{ .UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
var hostingEnvironment = server.Services.GetService<IWebHostEnvironment>(); .Configure(app => app.UseStaticFiles(new StaticFileOptions
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) })
{
var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var response = await client.GetAsync(requestUrl);
var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
Assert.Equal(response.Content.Headers.ContentLength, responseContent.Length);
using (var stream = fileInfo.CreateReadStream())
{ {
var fileContents = new byte[stream.Length]; RequestPath = new PathString(baseUrl),
stream.Read(fileContents, 0, (int)stream.Length); }));
Assert.True(responseContent.SequenceEqual(fileContents)); }).Build();
}
await host.StartAsync();
var hostingEnvironment = host.Services.GetService<IWebHostEnvironment>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{
var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var response = await client.GetAsync(requestUrl);
var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
Assert.Equal(response.Content.Headers.ContentLength, responseContent.Length);
using (var stream = fileInfo.CreateReadStream())
{
var fileContents = new byte[stream.Length];
stream.Read(fileContents, 0, (int)stream.Length);
Assert.True(responseContent.SequenceEqual(fileContents));
} }
} }
} }
@ -168,30 +185,33 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(ExistingFiles))] [MemberData(nameof(ExistingFiles))]
public async Task HeadFile_HeadersButNotBodyServed(string baseUrl, string baseDir, string requestUrl) public async Task HeadFile_HeadersButNotBodyServed(string baseUrl, string baseDir, string requestUrl)
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory)) .ConfigureWebHost(webHostBuilder =>
.UseKestrel()
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
{ {
RequestPath = new PathString(baseUrl), webHostBuilder
})); .ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
{
RequestPath = new PathString(baseUrl),
}));
}).Build();
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel))) await host.StartAsync();
var hostingEnvironment = host.Services.GetService<IWebHostEnvironment>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{ {
var hostingEnvironment = server.Services.GetService<IWebHostEnvironment>(); var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var request = new HttpRequestMessage(HttpMethod.Head, requestUrl);
var response = await client.SendAsync(request);
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) }) Assert.Equal(HttpStatusCode.OK, response.StatusCode);
{ Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl)); Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
var request = new HttpRequestMessage(HttpMethod.Head, requestUrl); Assert.Empty((await response.Content.ReadAsByteArrayAsync()));
var response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());
Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);
Assert.Empty((await response.Content.ReadAsByteArrayAsync()));
}
} }
} }
@ -226,51 +246,55 @@ namespace Microsoft.AspNetCore.StaticFiles
var requestCancelled = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var requestCancelled = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var responseComplete = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously); var responseComplete = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
Exception exception = null; Exception exception = null;
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory)) .ConfigureWebHost(webHostBuilder =>
.UseWebRoot(Path.Combine(AppContext.BaseDirectory))
.Configure(app =>
{ {
app.Use(async (context, next) => webHostBuilder
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseWebRoot(Path.Combine(AppContext.BaseDirectory))
.Configure(app =>
{ {
try app.Use(async (context, next) =>
{ {
requestReceived.SetResult(0); try
await requestCancelled.Task.TimeoutAfter(interval); {
Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted"); requestReceived.SetResult(0);
await next(); await requestCancelled.Task.TimeoutAfter(interval);
} Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");
catch (Exception ex) await next();
{ }
exception = ex; catch (Exception ex)
} {
responseComplete.SetResult(0); exception = ex;
}); }
app.UseStaticFiles(); responseComplete.SetResult(0);
}); });
app.UseStaticFiles();
})
.UseUrls(TestUrlHelper.GetTestUrl(serverType));
if (serverType == ServerType.HttpSys) if (serverType == ServerType.HttpSys)
{ {
builder.UseHttpSys(); webHostBuilder.UseHttpSys();
} }
else if (serverType == ServerType.Kestrel) else if (serverType == ServerType.Kestrel)
{ {
builder.UseKestrel(); webHostBuilder.UseKestrel();
} }
}).Build();
using (var server = builder.Start(TestUrlHelper.GetTestUrl(serverType))) await host.StartAsync();
{
// We don't use HttpClient here because it's disconnect behavior varies across platforms.
var socket = SendSocketRequestAsync(Helpers.GetAddress(server), "/TestDocument1MB.txt");
await requestReceived.Task.TimeoutAfter(interval);
socket.LingerState = new LingerOption(true, 0); // We don't use HttpClient here because it's disconnect behavior varies across platforms.
socket.Dispose(); var socket = SendSocketRequestAsync(Helpers.GetAddress(host), "/TestDocument1MB.txt");
requestCancelled.SetResult(0); await requestReceived.Task.TimeoutAfter(interval);
await responseComplete.Task.TimeoutAfter(interval); socket.LingerState = new LingerOption(true, 0);
Assert.Null(exception); socket.Dispose();
} requestCancelled.SetResult(0);
await responseComplete.Task.TimeoutAfter(interval);
Assert.Null(exception);
} }
private Socket SendSocketRequestAsync(string address, string path, string method = "GET") private Socket SendSocketRequestAsync(string address, string path, string method = "GET")

63
src/Middleware/StaticFiles/test/UnitTests/CacheHeaderTests.cs
View File

@ -18,7 +18,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task ServerShouldReturnETag() public async Task ServerShouldReturnETag()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
Assert.NotNull(response.Headers.ETag); Assert.NotNull(response.Headers.ETag);
@ -28,7 +29,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task SameETagShouldBeReturnedAgain() public async Task SameETagShouldBeReturnedAgain()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage response1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage response1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
HttpResponseMessage response2 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage response2 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
@ -47,7 +49,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfMatchShouldReturn412WhenNotListed(HttpMethod method) public async Task IfMatchShouldReturn412WhenNotListed(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
req.Headers.Add("If-Match", "\"fake\""); req.Headers.Add("If-Match", "\"fake\"");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -58,7 +61,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfMatchShouldBeServedWhenListed(HttpMethod method) public async Task IfMatchShouldBeServedWhenListed(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -71,7 +75,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfMatchShouldBeServedForAsterisk(HttpMethod method) public async Task IfMatchShouldBeServedForAsterisk(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
req.Headers.Add("If-Match", "*"); req.Headers.Add("If-Match", "*");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -82,7 +87,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(UnsupportedMethods))] [MemberData(nameof(UnsupportedMethods))]
public async Task IfMatchShouldBeIgnoredForUnsupportedMethods(HttpMethod method) public async Task IfMatchShouldBeIgnoredForUnsupportedMethods(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
req.Headers.Add("If-Match", "*"); req.Headers.Add("If-Match", "*");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -107,7 +113,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfNoneMatchShouldReturn304ForMatching(HttpMethod method) public async Task IfNoneMatchShouldReturn304ForMatching(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -120,7 +127,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfNoneMatchAllShouldReturn304ForMatching(HttpMethod method) public async Task IfNoneMatchAllShouldReturn304ForMatching(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -133,7 +141,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(UnsupportedMethods))] [MemberData(nameof(UnsupportedMethods))]
public async Task IfNoneMatchShouldBeIgnoredForNonTwoHundredAnd304Responses(HttpMethod method) public async Task IfNoneMatchShouldBeIgnoredForNonTwoHundredAnd304Responses(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml"); HttpResponseMessage resp1 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"); var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -156,7 +165,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task ServerShouldReturnLastModified(HttpMethod method) public async Task ServerShouldReturnLastModified(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().SendAsync( HttpResponseMessage response = await server.CreateClient().SendAsync(
new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml")); new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"));
@ -179,7 +189,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task MatchingBothConditionsReturnsNotModified(HttpMethod method) public async Task MatchingBothConditionsReturnsNotModified(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server HttpResponseMessage resp1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method); .SendAsync(method.Method);
@ -198,7 +209,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task MatchingAtLeastOneETagReturnsNotModified(HttpMethod method) public async Task MatchingAtLeastOneETagReturnsNotModified(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server HttpResponseMessage resp1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method); .SendAsync(method.Method);
@ -223,7 +235,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task MissingEitherOrBothConditionsReturnsNormally(HttpMethod method) public async Task MissingEitherOrBothConditionsReturnsNormally(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage resp1 = await server HttpResponseMessage resp1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method); .SendAsync(method.Method);
@ -271,7 +284,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task InvalidIfModifiedSinceDateFormatGivesNormalGet(HttpMethod method) public async Task InvalidIfModifiedSinceDateFormatGivesNormalGet(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res = await server HttpResponseMessage res = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -285,7 +299,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task FutureIfModifiedSinceDateFormatGivesNormalGet(HttpMethod method) public async Task FutureIfModifiedSinceDateFormatGivesNormalGet(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res = await server HttpResponseMessage res = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -306,7 +321,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfModifiedSinceDateGreaterThanLastModifiedShouldReturn304(HttpMethod method) public async Task IfModifiedSinceDateGreaterThanLastModifiedShouldReturn304(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res1 = await server HttpResponseMessage res1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -324,7 +340,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task SupportsIfModifiedDateFormats(HttpMethod method) public async Task SupportsIfModifiedDateFormats(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res1 = await server HttpResponseMessage res1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method); .SendAsync(method.Method);
@ -351,7 +368,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfModifiedSinceDateLessThanLastModifiedShouldReturn200(HttpMethod method) public async Task IfModifiedSinceDateLessThanLastModifiedShouldReturn200(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res1 = await server HttpResponseMessage res1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -369,7 +387,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task InvalidIfUnmodifiedSinceDateFormatGivesNormalGet(HttpMethod method) public async Task InvalidIfUnmodifiedSinceDateFormatGivesNormalGet(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res = await server HttpResponseMessage res = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -383,7 +402,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task FutureIfUnmodifiedSinceDateFormatGivesNormalGet(HttpMethod method) public async Task FutureIfUnmodifiedSinceDateFormatGivesNormalGet(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res = await server HttpResponseMessage res = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")
@ -397,7 +417,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))] [MemberData(nameof(SupportedMethods))]
public async Task IfUnmodifiedSinceDateLessThanLastModifiedShouldReturn412(HttpMethod method) public async Task IfUnmodifiedSinceDateLessThanLastModifiedShouldReturn412(HttpMethod method)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage res1 = await server HttpResponseMessage res1 = await server
.CreateRequest("/SubFolder/extra.xml") .CreateRequest("/SubFolder/extra.xml")

21
src/Middleware/StaticFiles/test/UnitTests/DefaultFilesMiddlewareTests.cs
View File

@ -24,10 +24,12 @@ namespace Microsoft.AspNetCore.StaticFiles
public async Task NullArguments() public async Task NullArguments()
{ {
// No exception, default provided // No exception, default provided
StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions { FileProvider = null })); using (await StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions { FileProvider = null })))
{ }
// PathString(null) is OK. // PathString(null) is OK.
var server = StaticFilesTestServer.Create(app => app.UseDefaultFiles((string)null)); using var host = await StaticFilesTestServer.Create(app => app.UseDefaultFiles((string)null));
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/"); var response = await server.CreateClient().GetAsync("/");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
} }
@ -64,7 +66,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => using var host = await StaticFilesTestServer.Create(app =>
{ {
app.UseDefaultFiles(new DefaultFilesOptions app.UseDefaultFiles(new DefaultFilesOptions
{ {
@ -74,6 +76,7 @@ namespace Microsoft.AspNetCore.StaticFiles
}); });
app.Run(context => context.Response.WriteAsync(context.Request.Path.Value)); app.Run(context => context.Response.WriteAsync(context.Request.Path.Value));
}); });
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(requestUrl); var response = await server.CreateClient().GetAsync(requestUrl);
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -86,7 +89,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, "."))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, ".")))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app =>
{ {
app.UseRouting(); app.UseRouting();
@ -113,6 +116,7 @@ namespace Microsoft.AspNetCore.StaticFiles
app.UseEndpoints(endpoints => { }); app.UseEndpoints(endpoints => { });
}, },
services => { services.AddDirectoryBrowser(); services.AddRouting(); }); services => { services.AddDirectoryBrowser(); services.AddRouting(); });
using var server = host.GetTestServer();
var response = await server.CreateRequest("/SubFolder/").GetAsync(); var response = await server.CreateRequest("/SubFolder/").GetAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -165,7 +169,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => using var host = await StaticFilesTestServer.Create(app =>
{ {
app.UseDefaultFiles(new DefaultFilesOptions app.UseDefaultFiles(new DefaultFilesOptions
{ {
@ -175,6 +179,7 @@ namespace Microsoft.AspNetCore.StaticFiles
}); });
app.Run(context => context.Response.WriteAsync(context.Request.Path.Value)); app.Run(context => context.Response.WriteAsync(context.Request.Path.Value));
}); });
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(requestUrl); var response = await server.CreateClient().GetAsync(requestUrl);
@ -211,11 +216,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions using var host = await StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider FileProvider = fileProvider
})); }));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl + queryString).GetAsync(); var response = await server.CreateRequest(requestUrl + queryString).GetAsync();
Assert.Equal(HttpStatusCode.Moved, response.StatusCode); Assert.Equal(HttpStatusCode.Moved, response.StatusCode);
@ -265,12 +271,13 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions using var host = await StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider, FileProvider = fileProvider,
RedirectToAppendTrailingSlash = appendTrailingSlash RedirectToAppendTrailingSlash = appendTrailingSlash
})); }));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync(); var response = await server.CreateRequest(requestUrl).GetAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); // Passed through Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); // Passed through

37
src/Middleware/StaticFiles/test/UnitTests/DirectoryBrowserMiddlewareTests.cs
View File

@ -21,10 +21,10 @@ namespace Microsoft.AspNetCore.StaticFiles
public class DirectoryBrowserMiddlewareTests public class DirectoryBrowserMiddlewareTests
{ {
[Fact] [Fact]
public void WorksWithoutEncoderRegistered() public async Task WorksWithoutEncoderRegistered()
{ {
// No exception, uses HtmlEncoder.Default // No exception, uses HtmlEncoder.Default
StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser()); app => app.UseDirectoryBrowser());
} }
@ -32,19 +32,24 @@ namespace Microsoft.AspNetCore.StaticFiles
public async Task NullArguments() public async Task NullArguments()
{ {
// No exception, default provided // No exception, default provided
StaticFilesTestServer.Create( using (await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { Formatter = null }), app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { Formatter = null }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser()))
{
}
// No exception, default provided // No exception, default provided
StaticFilesTestServer.Create( using (await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { FileProvider = null }), app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { FileProvider = null }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser()))
{
}
// PathString(null) is OK. // PathString(null) is OK.
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser((string)null), app => app.UseDirectoryBrowser((string)null),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/"); var response = await server.CreateClient().GetAsync("/");
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -82,7 +87,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
@ -90,6 +95,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash RedirectToAppendTrailingSlash = appendTrailingSlash
}), }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync(); var response = await server.CreateRequest(requestUrl).GetAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
} }
@ -100,7 +106,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, "."))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, ".")))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app =>
{ {
app.UseRouting(); app.UseRouting();
@ -128,6 +134,7 @@ namespace Microsoft.AspNetCore.StaticFiles
app.UseEndpoints(endpoints => { }); app.UseEndpoints(endpoints => { });
}, },
services => { services.AddDirectoryBrowser(); services.AddRouting(); }); services => { services.AddDirectoryBrowser(); services.AddRouting(); });
using var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync(); var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode); Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
@ -174,7 +181,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
@ -182,6 +189,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash, RedirectToAppendTrailingSlash = appendTrailingSlash,
}), }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync(); var response = await server.CreateRequest(requestUrl).GetAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -217,13 +225,14 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider FileProvider = fileProvider
}), }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl + queryString).GetAsync(); var response = await server.CreateRequest(requestUrl + queryString).GetAsync();
@ -266,7 +275,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
@ -274,6 +283,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash RedirectToAppendTrailingSlash = appendTrailingSlash
}), }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).PostAsync(); var response = await server.CreateRequest(requestUrl).PostAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
@ -313,7 +323,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create( using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
@ -321,6 +331,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash RedirectToAppendTrailingSlash = appendTrailingSlash
}), }),
services => services.AddDirectoryBrowser()); services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).SendAsync("HEAD"); var response = await server.CreateRequest(requestUrl).SendAsync("HEAD");

66
src/Middleware/StaticFiles/test/UnitTests/RangeHeaderTests.cs
View File

@ -19,7 +19,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfRangeWithCurrentEtagShouldServePartialContent() public async Task IfRangeWithCurrentEtagShouldServePartialContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -39,7 +40,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task HEADIfRangeWithCurrentEtagShouldReturn200Ok() public async Task HEADIfRangeWithCurrentEtagShouldReturn200Ok()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -59,7 +61,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfRangeWithCurrentDateShouldServePartialContent() public async Task IfRangeWithCurrentDateShouldServePartialContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -75,7 +78,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfModifiedSinceWithPastDateShouldServePartialContent() public async Task IfModifiedSinceWithPastDateShouldServePartialContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -91,7 +95,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfModifiedSinceWithCurrentDateShouldReturn304() public async Task IfModifiedSinceWithCurrentDateShouldReturn304()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -107,7 +112,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task HEADIfRangeWithCurrentDateShouldReturn200Ok() public async Task HEADIfRangeWithCurrentDateShouldReturn200Ok()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -127,7 +133,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfRangeWithOldEtagShouldServeFullContent() public async Task IfRangeWithOldEtagShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("If-Range", "\"OldEtag\""); req.Headers.Add("If-Range", "\"OldEtag\"");
req.Headers.Add("Range", "bytes=0-10"); req.Headers.Add("Range", "bytes=0-10");
@ -143,7 +150,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task HEADIfRangeWithOldEtagShouldServeFullContent() public async Task HEADIfRangeWithOldEtagShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("If-Range", "\"OldEtag\""); req.Headers.Add("If-Range", "\"OldEtag\"");
req.Headers.Add("Range", "bytes=0-10"); req.Headers.Add("Range", "bytes=0-10");
@ -159,7 +167,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfRangeWithOldDateShouldServeFullContent() public async Task IfRangeWithOldDateShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -177,7 +186,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task HEADIfRangeWithOldDateShouldServeFullContent() public async Task HEADIfRangeWithOldDateShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -196,7 +206,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task IfRangeWithoutRangeShouldServeFullContent() public async Task IfRangeWithoutRangeShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -222,7 +233,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task HEADIfRangeWithoutRangeShouldServeFullContent() public async Task HEADIfRangeWithoutRangeShouldServeFullContent()
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt"); HttpResponseMessage original = await server.CreateClient().GetAsync("http://localhost/SubFolder/ranges.txt");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -256,7 +268,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("-1001", "0-61", 62, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")] [InlineData("-1001", "0-61", 62, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")]
public async Task SingleValidRangeShouldServePartialContent(string range, string expectedRange, int length, string expectedData) public async Task SingleValidRangeShouldServePartialContent(string range, string expectedRange, int length, string expectedData)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("Range", "bytes=" + range); req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -276,7 +289,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("0-2", "0-0", 1, "A")] [InlineData("0-2", "0-0", 1, "A")]
public async Task SingleValidRangeShouldServePartialContentSingleByteFile(string range, string expectedRange, int length, string expectedData) public async Task SingleValidRangeShouldServePartialContentSingleByteFile(string range, string expectedRange, int length, string expectedData)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/SingleByte.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/SingleByte.txt");
req.Headers.Add("Range", "bytes=" + range); req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -296,7 +310,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("0-2")] [InlineData("0-2")]
public async Task SingleValidRangeShouldServeRequestedRangeNotSatisfiableEmptyFile(string range) public async Task SingleValidRangeShouldServeRequestedRangeNotSatisfiableEmptyFile(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/Empty.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/Empty.txt");
req.Headers.Add("Range", "bytes=" + range); req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -309,7 +324,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("10-35")] [InlineData("10-35")]
public async Task HEADSingleValidRangeShouldReturnOk(string range) public async Task HEADSingleValidRangeShouldReturnOk(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("Range", "bytes=" + range); req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -326,7 +342,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("-0")] // Suffix range must be non-zero [InlineData("-0")] // Suffix range must be non-zero
public async Task SingleNotSatisfiableRange(string range) public async Task SingleNotSatisfiableRange(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range); req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -340,7 +357,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("1000-1001")] // Out of range [InlineData("1000-1001")] // Out of range
public async Task HEADSingleNotSatisfiableRangeReturnsOk(string range) public async Task HEADSingleNotSatisfiableRangeReturnsOk(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range); req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -359,7 +377,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("a-b")] [InlineData("a-b")]
public async Task SingleInvalidRangeIgnored(string range) public async Task SingleInvalidRangeIgnored(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range); req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -380,7 +399,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("a-b")] [InlineData("a-b")]
public async Task HEADSingleInvalidRangeIgnored(string range) public async Task HEADSingleInvalidRangeIgnored(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range); req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -400,7 +420,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("0-0,6-6,8-8,2-2,4-4")] [InlineData("0-0,6-6,8-8,2-2,4-4")]
public async Task MultipleValidRangesShouldServeFullContent(string ranges) public async Task MultipleValidRangesShouldServeFullContent(string ranges)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("Range", "bytes=" + ranges); req.Headers.Add("Range", "bytes=" + ranges);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -419,7 +440,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("2-2,0-0")] // SHOULD send in the requested order. [InlineData("2-2,0-0")] // SHOULD send in the requested order.
public async Task HEADMultipleValidRangesShouldServeFullContent(string range) public async Task HEADMultipleValidRangesShouldServeFullContent(string range)
{ {
TestServer server = StaticFilesTestServer.Create(app => app.UseFileServer()); using var host = await StaticFilesTestServer.Create(app => app.UseFileServer());
using var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt"); var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
req.Headers.Add("Range", "bytes=" + range); req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req); HttpResponseMessage resp = await server.CreateClient().SendAsync(req);

76
src/Middleware/StaticFiles/test/UnitTests/StaticFileMiddlewareTests.cs
View File

@ -16,6 +16,7 @@ using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.AspNetCore.Testing; using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.FileProviders; using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Hosting;
using Moq; using Moq;
using Xunit; using Xunit;
@ -26,9 +27,17 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact] [Fact]
public async Task ReturnsNotFoundWithoutWwwroot() public async Task ReturnsNotFoundWithoutWwwroot()
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => app.UseStaticFiles()); .ConfigureWebHost(webHostBuilder =>
var server = new TestServer(builder); {
webHostBuilder
.UseTestServer()
.Configure(app => app.UseStaticFiles());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/ranges.txt"); var response = await server.CreateClient().GetAsync("/ranges.txt");
@ -47,10 +56,18 @@ namespace Microsoft.AspNetCore.StaticFiles
try try
{ {
var builder = new WebHostBuilder() using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true })) .Configure(app => app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true }))
.UseWebRoot(AppContext.BaseDirectory); .UseWebRoot(AppContext.BaseDirectory);
var server = new TestServer(builder); }).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(Path.GetFileName(badLink)); var response = await server.CreateClient().GetAsync(Path.GetFileName(badLink));
@ -70,18 +87,26 @@ namespace Microsoft.AspNetCore.StaticFiles
mockSendFile.Setup(m => m.SendFileAsync(It.IsAny<string>(), It.IsAny<long>(), It.IsAny<long?>(), It.IsAny<CancellationToken>())) mockSendFile.Setup(m => m.SendFileAsync(It.IsAny<string>(), It.IsAny<long>(), It.IsAny<long?>(), It.IsAny<CancellationToken>()))
.ThrowsAsync(new FileNotFoundException()); .ThrowsAsync(new FileNotFoundException());
mockSendFile.Setup(m => m.Stream).Returns(Stream.Null); mockSendFile.Setup(m => m.Stream).Returns(Stream.Null);
var builder = new WebHostBuilder() using var host = new HostBuilder()
.Configure(app => .ConfigureWebHost(webHostBuilder =>
{ {
app.Use(async (ctx, next) => webHostBuilder
.UseTestServer()
.Configure(app =>
{ {
ctx.Features.Set(mockSendFile.Object); app.Use(async (ctx, next) =>
await next(); {
}); ctx.Features.Set(mockSendFile.Object);
app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true }); await next();
}) });
.UseWebRoot(AppContext.BaseDirectory); app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true });
var server = new TestServer(builder); })
.UseWebRoot(AppContext.BaseDirectory);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("TestDocument.txt"); var response = await server.CreateClient().GetAsync("TestDocument.txt");
@ -94,10 +119,11 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(AppContext.BaseDirectory)) using (var fileProvider = new PhysicalFileProvider(AppContext.BaseDirectory))
{ {
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
{ {
FileProvider = fileProvider FileProvider = fileProvider
})); }));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo("TestDocument.txt"); var fileInfo = fileProvider.GetFileInfo("TestDocument.txt");
var response = await server.CreateRequest("TestDocument.txt").GetAsync(); var response = await server.CreateRequest("TestDocument.txt").GetAsync();
@ -112,13 +138,16 @@ namespace Microsoft.AspNetCore.StaticFiles
public async Task NullArguments() public async Task NullArguments()
{ {
// No exception, default provided // No exception, default provided
StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { ContentTypeProvider = null })); using (await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { ContentTypeProvider = null })))
{ }
// No exception, default provided // No exception, default provided
StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { FileProvider = null })); using (await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { FileProvider = null })))
{ }
// PathString(null) is OK. // PathString(null) is OK.
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles((string)null)); using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles((string)null));
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/"); var response = await server.CreateClient().GetAsync("/");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
} }
@ -146,11 +175,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider FileProvider = fileProvider
})); }));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl)); var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var response = await server.CreateRequest(requestUrl).GetAsync(); var response = await server.CreateRequest(requestUrl).GetAsync();
var responseContent = await response.Content.ReadAsByteArrayAsync(); var responseContent = await response.Content.ReadAsByteArrayAsync();
@ -176,11 +206,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider FileProvider = fileProvider
})); }));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl)); var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var response = await server.CreateRequest(requestUrl).SendAsync("HEAD"); var response = await server.CreateRequest(requestUrl).SendAsync("HEAD");
@ -235,11 +266,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{ {
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir))) using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, baseDir)))
{ {
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
{ {
RequestPath = new PathString(baseUrl), RequestPath = new PathString(baseUrl),
FileProvider = fileProvider FileProvider = fileProvider
})); }));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).SendAsync(method); var response = await server.CreateRequest(requestUrl).SendAsync(method);
Assert.Null(response.Content.Headers.LastModified); Assert.Null(response.Content.Headers.LastModified);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

21
src/Middleware/StaticFiles/test/UnitTests/StaticFilesTestServer.cs
View File

@ -4,17 +4,19 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.StaticFiles namespace Microsoft.AspNetCore.StaticFiles
{ {
public static class StaticFilesTestServer public static class StaticFilesTestServer
{ {
public static TestServer Create(Action<IApplicationBuilder> configureApp, Action<IServiceCollection> configureServices = null) public static async Task<IHost> Create(Action<IApplicationBuilder> configureApp, Action<IServiceCollection> configureServices = null)
{ {
Action<IServiceCollection> defaultConfigureServices = services => { }; Action<IServiceCollection> defaultConfigureServices = services => { };
var configuration = new ConfigurationBuilder() var configuration = new ConfigurationBuilder()
@ -23,11 +25,18 @@ namespace Microsoft.AspNetCore.StaticFiles
new KeyValuePair<string, string>("webroot", ".") new KeyValuePair<string, string>("webroot", ".")
}) })
.Build(); .Build();
var builder = new WebHostBuilder() var host = new HostBuilder()
.UseConfiguration(configuration) .ConfigureWebHost(webHostBuilder =>
.Configure(configureApp) {
.ConfigureServices(configureServices ?? defaultConfigureServices); webHostBuilder
return new TestServer(builder); .UseTestServer()
.UseConfiguration(configuration)
.Configure(configureApp)
.ConfigureServices(configureServices ?? defaultConfigureServices);
}).Build();
await host.StartAsync();
return host;
} }
} }
} }

22
src/Middleware/WebSockets/samples/EchoApp/Program.cs
View File

@ -1,24 +1,26 @@
using System;
using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
namespace EchoApp namespace EchoApp
{ {
public class Program public class Program
{ {
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var host = new WebHostBuilder() var host = new HostBuilder()
.UseKestrel() .ConfigureWebHost(webHostBuilder =>
.UseContentRoot(Directory.GetCurrentDirectory()) {
.UseIISIntegration() webHostBuilder
.UseStartup<Startup>() .UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build(); .Build();
host.Run(); return host.RunAsync();
} }
} }
} }

105
src/Middleware/WebSockets/test/ConformanceTests/AutobahnTestApp/Program.cs
View File

@ -1,76 +1,81 @@
using System; using System;
using System.IO; using System.IO;
using System.Net; using System.Net;
using System.Runtime.Loader; using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace AutobahnTestApp namespace AutobahnTestApp
{ {
public class Program public class Program
{ {
public static void Main(string[] args) public static Task Main(string[] args)
{ {
var scenarioName = "Unknown"; var scenarioName = "Unknown";
var config = new ConfigurationBuilder() var config = new ConfigurationBuilder()
.AddCommandLine(args) .AddCommandLine(args)
.Build(); .Build();
var builder = new WebHostBuilder() var builder = new HostBuilder()
.ConfigureLogging(loggingBuilder => loggingBuilder.AddConsole()) .ConfigureWebHost(webHostBuilder =>
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
if (string.Equals(builder.GetSetting("server"), "Microsoft.AspNetCore.Server.HttpSys", System.StringComparison.Ordinal))
{
scenarioName = "HttpSysServer";
Console.WriteLine("Using HttpSys server");
builder.UseHttpSys();
}
else if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("ASPNETCORE_PORT")))
{
// ANCM is hosting the process.
// The port will not yet be configured at this point, but will also not require HTTPS.
scenarioName = "AspNetCoreModule";
Console.WriteLine("Detected ANCM, using Kestrel");
builder.UseKestrel();
}
else
{
// Also check "server.urls" for back-compat.
var urls = builder.GetSetting(WebHostDefaults.ServerUrlsKey) ?? builder.GetSetting("server.urls");
builder.UseSetting(WebHostDefaults.ServerUrlsKey, string.Empty);
Console.WriteLine($"Using Kestrel, URL: {urls}");
if (urls.Contains(";"))
{ {
throw new NotSupportedException("This test app does not support multiple endpoints."); webHostBuilder
} .ConfigureLogging(loggingBuilder => loggingBuilder.AddConsole())
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
var uri = new Uri(urls); if (string.Equals(webHostBuilder.GetSetting("server"), "Microsoft.AspNetCore.Server.HttpSys", System.StringComparison.Ordinal))
builder.UseKestrel(options =>
{
options.Listen(IPAddress.Loopback, uri.Port, listenOptions =>
{ {
if (uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) scenarioName = "HttpSysServer";
Console.WriteLine("Using HttpSys server");
webHostBuilder.UseHttpSys();
}
else if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("ASPNETCORE_PORT")))
{
// ANCM is hosting the process.
// The port will not yet be configured at this point, but will also not require HTTPS.
scenarioName = "AspNetCoreModule";
Console.WriteLine("Detected ANCM, using Kestrel");
webHostBuilder.UseKestrel();
}
else
{
// Also check "server.urls" for back-compat.
var urls = webHostBuilder.GetSetting(WebHostDefaults.ServerUrlsKey) ?? webHostBuilder.GetSetting("server.urls");
webHostBuilder.UseSetting(WebHostDefaults.ServerUrlsKey, string.Empty);
Console.WriteLine($"Using Kestrel, URL: {urls}");
if (urls.Contains(";"))
{ {
scenarioName = "Kestrel(SSL)"; throw new NotSupportedException("This test app does not support multiple endpoints.");
var certPath = Path.Combine(AppContext.BaseDirectory, "TestResources", "testCert.pfx");
Console.WriteLine($"Using SSL with certificate: {certPath}");
listenOptions.UseHttps(certPath, "testPassword");
} }
else
var uri = new Uri(urls);
webHostBuilder.UseKestrel(options =>
{ {
scenarioName = "Kestrel(NonSSL)"; options.Listen(IPAddress.Loopback, uri.Port, listenOptions =>
} {
}); if (uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
scenarioName = "Kestrel(SSL)";
var certPath = Path.Combine(AppContext.BaseDirectory, "TestResources", "testCert.pfx");
Console.WriteLine($"Using SSL with certificate: {certPath}");
listenOptions.UseHttps(certPath, "testPassword");
}
else
{
scenarioName = "Kestrel(NonSSL)";
}
});
});
}
}); });
}
var host = builder.Build(); var host = builder.Build();
@ -80,7 +85,7 @@ namespace AutobahnTestApp
}; };
Console.WriteLine($"Starting Server for Scenario: {scenarioName}"); Console.WriteLine($"Starting Server for Scenario: {scenarioName}");
host.Run(); return host.RunAsync();
} }
} }
} }

33
src/Middleware/WebSockets/test/UnitTests/IHostPortExtensions.cs Normal file
View File

@ -0,0 +1,33 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.Hosting
{
public static class IHostPortExtensions
{
public static int GetPort(this IHost host)
{
return host.GetPorts().First();
}
public static IEnumerable<int> GetPorts(this IHost host)
{
return host.GetUris()
.Select(u => u.Port);
}
public static IEnumerable<Uri> GetUris(this IHost host)
{
return host.Services.GetService<IServer>().Features.Get<IServerAddressesFeature>().Addresses
.Select(a => new Uri(a));
}
}
}

30
src/Middleware/WebSockets/test/UnitTests/IWebHostPortExtensions.cs
View File

@ -1,30 +0,0 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Hosting.Server.Features;
namespace Microsoft.AspNetCore.Hosting
{
public static class IWebHostPortExtensions
{
public static int GetPort(this IWebHost host)
{
return host.GetPorts().First();
}
public static IEnumerable<int> GetPorts(this IWebHost host)
{
return host.GetUris()
.Select(u => u.Port);
}
public static IEnumerable<Uri> GetUris(this IWebHost host)
{
return host.ServerFeatures.Get<IServerAddressesFeature>().Addresses
.Select(a => new Uri(a));
}
}
}

22
src/Middleware/WebSockets/test/UnitTests/KestrelWebSocketHelpers.cs
View File

@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.WebSockets.Test namespace Microsoft.AspNetCore.WebSockets.Test
{ {
@ -48,16 +49,19 @@ namespace Microsoft.AspNetCore.WebSockets.Test
var config = configBuilder.Build(); var config = configBuilder.Build();
config["server.urls"] = $"http://127.0.0.1:0"; config["server.urls"] = $"http://127.0.0.1:0";
var host = new WebHostBuilder() var host = new HostBuilder()
.ConfigureServices(s => .ConfigureWebHost(webHostBuilder =>
{ {
s.AddWebSockets(configure); webHostBuilder
s.AddSingleton(loggerFactory); .ConfigureServices(s =>
}) {
.UseConfiguration(config) s.AddWebSockets(configure);
.UseKestrel() s.AddSingleton(loggerFactory);
.Configure(startup) })
.Build(); .UseConfiguration(config)
.UseKestrel()
.Configure(startup);
}).Build();
host.Start(); host.Start();
port = host.GetPort(); port = host.GetPort();