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

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

@ -1,9 +1,11 @@
// 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.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace CorsMiddlewareWebSite
{
@ -19,15 +21,19 @@ namespace CorsMiddlewareWebSite
app.UseCors(policy => policy.WithOrigins("http://example.com"));
app.UseMiddleware<EchoMiddleware>();
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build();
host.Run();
return host.RunAsync();
}
}
}
}

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

@ -17,7 +17,7 @@ namespace ConcurrencyLimiterSample
{
services.AddStackPolicy(options =>
{
options.MaxConcurrentRequests = 2;
options.MaxConcurrentRequests = 2;
options.RequestQueueLimit = 25;
});
}
@ -33,13 +33,17 @@ namespace ConcurrencyLimiterSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
new WebHostBuilder()
.UseKestrel()
.UseStartup<Startup>()
return new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseStartup<Startup>();
})
.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.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Xunit;
@ -27,10 +28,19 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact]
public async Task Successful_requests_pass_thru()
{
var builder = new WebHostBuilder().Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<SuccessMiddleware>());
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<SuccessMiddleware>());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
@ -53,10 +63,19 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[Fact]
public async Task Non_database_exceptions_pass_thru()
{
var builder = new WebHostBuilder().Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<ExceptionMiddleware>());
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app
.UseDatabaseErrorPage()
.UseMiddleware<ExceptionMiddleware>());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
await server.CreateClient().GetAsync("http://localhost/"));
@ -82,7 +101,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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 () =>
await server.CreateClient().GetAsync("http://localhost/"));
@ -114,7 +134,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -142,13 +163,13 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
[ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux)]
[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 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());
@ -172,7 +193,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -208,7 +230,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
@ -245,7 +268,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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 expectedMigrationsEndpoint = "/ApplyDatabaseMigrations";
@ -302,7 +326,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
using (var database = SqlTestStore.CreateScratch())
{
var builder = new WebHostBuilder()
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseDatabaseErrorPage(new DatabaseErrorPageOptions
@ -317,7 +345,11 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
services.AddDbContext<BloggingContextWithMigrations>(
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/");
@ -335,16 +367,24 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
var logProvider = new TestLoggerProvider();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseDatabaseErrorPage();
app.UseMiddleware<ContextNotRegisteredInServicesMiddleware>();
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseDatabaseErrorPage();
app.UseMiddleware<ContextNotRegisteredInServicesMiddleware>();
#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
});
var server = new TestServer(builder);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
try
{
@ -391,7 +431,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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
{
@ -430,7 +471,8 @@ namespace Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.Tests
{
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/");
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
{
var builder = new WebHostBuilder()
.Configure(app =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseDatabaseErrorPage();
app.UseMiddleware<TMiddleware>();
if (logProvider != null)
webHostBuilder
.UseTestServer()
.Configure(app =>
{
#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));
});
app.UseDatabaseErrorPage();
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;

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

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.
using System;
@ -6,12 +6,14 @@ using System.Net.Http;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.AspNetCore.Testing;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
{
public class TestFixture<TStartup> : IDisposable
{
private readonly TestServer _server;
private readonly IHost _host;
public TestFixture()
{
@ -20,10 +22,16 @@ namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
// (DefaultRequestCulture) is consistent regardless of system configuration or personal preferences.
using (new CultureReplacer())
{
var builder = new WebHostBuilder()
_host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(typeof(TStartup));
}).Build();
_server = new TestServer(builder);
_host.Start();
_server = _host.GetTestServer();
}
Client = _server.CreateClient();
@ -36,6 +44,7 @@ namespace Microsoft.AspNetCore.Diagnostics.FunctionalTests
{
Client.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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Diagnostics
@ -22,17 +23,25 @@ namespace Microsoft.AspNetCore.Diagnostics
{
// Arrange
DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
throw new Exception("Test exception");
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener);
@ -50,16 +59,24 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ErrorPageWithAcceptHeaderForHtmlReturnsHtml()
{
// Arrange
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
throw new Exception("Test exception");
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// Act
var client = server.CreateClient();
@ -77,16 +94,24 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ErrorPageWithoutAcceptHeaderForHtmlReturnsPlainText()
{
// Arrange
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
throw new Exception("Test exception");
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// Act
var response = await server.CreateClient().GetAsync("/path");
@ -102,20 +127,28 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ExceptionPageFiltersAreApplied()
{
// Arrange
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
throw new Exception("Test exception");
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new Exception("Test exception");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// Act
var response = await server.CreateClient().GetAsync("/path");
@ -128,50 +161,68 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ExceptionFilterCallingNextWorks()
{
// Arrange
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<IDeveloperPageExceptionFilter, PassThroughExceptionFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysBadFormatExceptionFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// Act
var response = await server.CreateClient().GetAsync("/path");
// Assert
Assert.Equal("Bad format exception!", await response.Content.ReadAsStringAsync());
await host.StartAsync();
}
[Fact]
public async Task ExceptionPageFiltersAreAppliedInOrder()
{
// Arrange
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<IDeveloperPageExceptionFilter, AlwaysThrowSameMessageFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionMessageFilter>();
services.AddSingleton<IDeveloperPageExceptionFilter, ExceptionToStringFilter>();
})
.Configure(app =>
{
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// Act
var response = await server.CreateClient().GetAsync("/path");
@ -241,17 +292,25 @@ namespace Microsoft.AspNetCore.Diagnostics
{
// Arrange
DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
throw new CustomCompilationException(failures);
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseDeveloperExceptionPage();
app.Run(context =>
{
throw new CustomCompilationException(failures);
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener();
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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Diagnostics
@ -28,28 +29,35 @@ namespace Microsoft.AspNetCore.Diagnostics
[InlineData(HttpStatusCode.InternalServerError)]
public async Task OnlyHandles_UnhandledExceptions(HttpStatusCode expectedStatusCode)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
webHostBuilder
.UseTestServer()
.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) =>
{
context.Response.StatusCode = (int)expectedStatusCode;
context.Response.ContentType = "text/plain; charset=utf-8";
await context.Response.WriteAsync("An error occurred while adding a product");
}));
});
await host.StartAsync();
using (var server = new TestServer(builder))
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(string.Empty);
@ -61,43 +69,50 @@ namespace Microsoft.AspNetCore.Diagnostics
[Fact]
public async Task DoesNotHandle_UnhandledExceptions_WhenResponseAlreadyStarted()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.Use(async (httpContext, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
Exception exception = null;
try
app.Use(async (httpContext, next) =>
{
await next();
}
catch (InvalidOperationException ex)
Exception exception = null;
try
{
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);
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
app.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 httpContext.Response.WriteAsync("Hello");
throw new InvalidOperationException("Something bad happened");
});
});
await host.StartAsync();
using (var server = new TestServer(builder))
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(string.Empty);
@ -110,54 +125,61 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task ClearsResponseBuffer_BeforeRequestIsReexecuted()
{
var expectedResponseBody = "New response body";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
// add response buffering
app.Use(async (httpContext, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
var response = httpContext.Response;
var originalResponseBody = response.Body;
var bufferingStream = new MemoryStream();
response.Body = bufferingStream;
try
// add response buffering
app.Use(async (httpContext, next) =>
{
await next();
var response = httpContext.Response;
var originalResponseBody = response.Body;
var bufferingStream = new MemoryStream();
response.Body = bufferingStream;
response.Body = originalResponseBody;
bufferingStream.Seek(0, SeekOrigin.Begin);
await bufferingStream.CopyToAsync(response.Body);
}
finally
try
{
await next();
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) =>
{
innerAppBuilder.Run(async (httpContext) =>
app.Run(async (context) =>
{
Assert.True(httpContext.Response.Body.CanSeek);
Assert.Equal(0, httpContext.Response.Body.Position);
// Write some content into the response before throwing exception
await context.Response.WriteAsync(new string('a', 100));
await httpContext.Response.WriteAsync(expectedResponseBody);
throw new InvalidOperationException("Invalid input provided.");
});
});
}).Build();
app.Run(async (context) =>
{
// Write some content into the response before throwing exception
await context.Response.WriteAsync(new string('a', 100));
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 response = await client.GetAsync(string.Empty);
@ -181,32 +203,39 @@ namespace Microsoft.AspNetCore.Diagnostics
{
var expiresTime = DateTime.UtcNow.AddDays(5).ToString("R");
var expectedResponseBody = "Handled error in a custom way.";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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" });
app.UseExceptionHandler("/handle-errors");
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) =>
{
throw new InvalidOperationException("Invalid input provided.");
});
});
await host.StartAsync();
using (var server = new TestServer(builder))
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(string.Empty);
@ -230,31 +259,38 @@ namespace Microsoft.AspNetCore.Diagnostics
{
var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R");
var expectedResponseBody = "Hello world!";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
webHostBuilder
.UseTestServer()
.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) =>
{
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 host.StartAsync();
await httpContext.Response.WriteAsync(expectedResponseBody);
});
});
using (var server = new TestServer(builder))
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(string.Empty);
@ -280,49 +316,56 @@ namespace Microsoft.AspNetCore.Diagnostics
public async Task DoesNotClearCacheHeaders_WhenResponseHasAlreadyStarted()
{
var expiresTime = DateTime.UtcNow.AddDays(10).ToString("R");
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.Use(async (httpContext, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
Exception exception = null;
try
app.Use(async (httpContext, next) =>
{
await next();
}
catch (InvalidOperationException ex)
Exception exception = null;
try
{
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);
Assert.Equal("Something bad happened", exception.Message);
});
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
{
innerAppBuilder.Run(async (httpContext) =>
app.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) =>
{
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 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 response = await client.GetAsync(string.Empty);
@ -350,25 +393,33 @@ namespace Microsoft.AspNetCore.Diagnostics
// Arrange
DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseExceptionHandler("/handle-errors");
app.Map("/handle-errors", (innerAppBuilder) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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 =>
{
throw new Exception("Test exception");
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var listener = new TestDiagnosticListener();
diagnosticListener.SubscribeWithAdapter(listener);
@ -395,15 +446,20 @@ namespace Microsoft.AspNetCore.Diagnostics
// Arrange
DiagnosticListener diagnosticListener = null;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseExceptionHandler();
});
webHostBuilder
.UseTestServer()
.Configure(app =>
{
diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
app.UseExceptionHandler();
});
}).Build();
// Act
var exception = Assert.Throws<InvalidOperationException>(() => new TestServer(builder));
var exception = Assert.Throws<InvalidOperationException>(() => host.Start());
// Assert
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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Diagnostics
@ -21,36 +22,44 @@ namespace Microsoft.AspNetCore.Diagnostics
{
var expectedStatusCode = 432;
var destination = "/location";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseStatusCodePagesWithRedirects("/errorPage?id={0}");
app.Map(destination, (innerAppBuilder) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
innerAppBuilder.Run((httpContext) =>
app.UseStatusCodePagesWithRedirects("/errorPage?id={0}");
app.Map(destination, (innerAppBuilder) =>
{
httpContext.Response.StatusCode = expectedStatusCode;
return Task.FromResult(1);
innerAppBuilder.Run((httpContext) =>
{
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) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
await httpContext.Response.WriteAsync(httpContext.Request.QueryString.Value);
});
});
await host.StartAsync();
app.Run((context) =>
{
throw new InvalidOperationException($"Invalid input provided. {context.Request.Path}");
});
});
var expectedQueryString = $"?id={expectedStatusCode}";
var expectedUri = $"/errorPage{expectedQueryString}";
using var server = new TestServer(builder);
using var server = host.GetTestServer();
var client = server.CreateClient();
var response = await client.GetAsync(destination);
Assert.Equal(HttpStatusCode.Found, response.StatusCode);
@ -67,49 +76,56 @@ namespace Microsoft.AspNetCore.Diagnostics
{
var expectedStatusCode = 432;
var destination = "/location";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
var beforeNext = context.Request.QueryString;
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) =>
app.Use(async (context, next) =>
{
httpContext.Response.StatusCode = expectedStatusCode;
return Task.FromResult(1);
var beforeNext = context.Request.QueryString;
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) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
await host.StartAsync();
app.Run((context) =>
{
throw new InvalidOperationException("Invalid input provided.");
});
});
using var server = new TestServer(builder);
using var server = host.GetTestServer();
var client = server.CreateClient();
var response = await client.GetAsync(destination + "?name=James");
var content = await response.Content.ReadAsStringAsync();
@ -121,50 +137,57 @@ namespace Microsoft.AspNetCore.Diagnostics
{
var expectedStatusCode = 432;
var destination = "/location";
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}");
app.Use((context, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
Assert.Empty(context.Request.RouteValues);
Assert.Null(context.GetEndpoint());
return next();
});
app.UseStatusCodePagesWithReExecute(pathFormat: "/errorPage", queryFormat: "?id={0}");
app.Map(destination, (innerAppBuilder) =>
{
innerAppBuilder.Run((httpContext) =>
app.Use((context, next) =>
{
httpContext.SetEndpoint(new Endpoint((_) => Task.CompletedTask, new EndpointMetadataCollection(), "Test"));
httpContext.Request.RouteValues["John"] = "Doe";
httpContext.Response.StatusCode = expectedStatusCode;
return Task.CompletedTask;
Assert.Empty(context.Request.RouteValues);
Assert.Null(context.GetEndpoint());
return next();
});
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) =>
{
innerAppBuilder.Run(async (httpContext) =>
{
var statusCodeReExecuteFeature = httpContext.Features.Get<IStatusCodeReExecuteFeature>();
await httpContext.Response.WriteAsync(
httpContext.Request.QueryString.Value
+ ", "
+ statusCodeReExecuteFeature.OriginalPath
+ ", "
+ statusCodeReExecuteFeature.OriginalQueryString);
});
});
await host.StartAsync();
app.Run((context) =>
{
throw new InvalidOperationException("Invalid input provided.");
});
});
using var server = new TestServer(builder);
using var server = host.GetTestServer();
var client = server.CreateClient();
var response = await client.GetAsync(destination + "?name=James");
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.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace DatabaseErrorPageSample
{
@ -26,15 +27,19 @@ namespace DatabaseErrorPageSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.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.Routing;
using Microsoft.AspNetCore.Routing.Patterns;
using Microsoft.Extensions.Hosting;
namespace DeveloperExceptionPageSample
{
@ -44,15 +45,19 @@ namespace DeveloperExceptionPageSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.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.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Hosting;
namespace ExceptionHandlerSample
{
@ -56,15 +58,19 @@ namespace ExceptionHandlerSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
})
.Build();
host.Run();
return host.RunAsync();
}
}
}

20
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.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Hosting;
namespace StatusCodePagesSample
{
@ -37,7 +38,7 @@ namespace StatusCodePagesSample
{
context.Response.StatusCode = int.Parse(requestedStatusCode);
// To turn off the StatusCode feature - For example the below code turns off the StatusCode middleware
// To turn off the StatusCode feature - For example the below code turns off the StatusCode middleware
// if the query contains a disableStatusCodePages=true parameter.
var disableStatusCodePages = context.Request.Query["disableStatusCodePages"];
if (disableStatusCodePages == "true")
@ -102,15 +103,18 @@ namespace StatusCodePagesSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.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.Hosting;
using Microsoft.Extensions.Hosting;
namespace WelcomePageSample
{
@ -10,15 +12,18 @@ namespace WelcomePageSample
app.UseWelcomePage();
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.HeaderPropagation.Tests
@ -24,34 +25,41 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
// Arrange
Exception captured = null;
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHttpClient("test").AddHeaderPropagation();
services.AddHeaderPropagation(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.Headers.Add("X-TraceId");
});
})
.Configure(app =>
{
// note: no header propagation middleware
app.Run(async context =>
services.AddHttpClient("test").AddHeaderPropagation();
services.AddHeaderPropagation(options =>
{
options.Headers.Add("X-TraceId");
});
})
.Configure(app =>
{
try
{
var client = context.RequestServices.GetRequiredService<IHttpClientFactory>().CreateClient("test");
await client.GetAsync("http://localhost/"); // will throw
}
catch (Exception ex)
{
captured = ex;
}
});
});
// note: no header propagation middleware
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 request = new HttpRequestMessage();
@ -96,10 +104,10 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{
// Arrange
var handler = new SimpleHandler();
var builder = CreateBuilder(c =>
using var host = await CreateHost(c =>
c.Headers.Add("in", "out"),
handler);
var server = new TestServer(builder);
var server = host.GetTestServer();
var client = server.CreateClient();
var request = new HttpRequestMessage();
@ -119,13 +127,13 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{
// Arrange
var handler = new SimpleHandler();
var builder = CreateBuilder(c =>
using var host = await CreateHost(c =>
{
c.Headers.Add("first");
c.Headers.Add("second");
},
handler);
var server = new TestServer(builder);
var server = host.GetTestServer();
var client = server.CreateClient();
var request = new HttpRequestMessage();
@ -144,15 +152,20 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
}
[Fact]
public void Builder_UseHeaderPropagation_Without_AddHeaderPropagation_Throws()
public async Task Builder_UseHeaderPropagation_Without_AddHeaderPropagation_Throws()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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(
"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);
@ -163,11 +176,11 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
{
// Arrange
var handler = new SimpleHandler();
var builder = CreateBuilder(
using var host = await CreateHost(
c => c.Headers.Add("in", "out"),
handler,
c => c.Headers.Add("out", "different"));
var server = new TestServer(builder);
var server = host.GetTestServer();
var client = server.CreateClient();
var request = new HttpRequestMessage();
@ -182,32 +195,41 @@ namespace Microsoft.AspNetCore.HeaderPropagation.Tests
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()
.Configure(app =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseHeaderPropagation();
app.UseMiddleware<SimpleMiddleware>();
})
.ConfigureServices(services =>
{
services.AddHeaderPropagation(configure);
var client = services.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
.ConfigureHttpMessageHandlerBuilder(b =>
{
b.PrimaryHandler = primaryHandler;
});
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseHeaderPropagation();
app.UseMiddleware<SimpleMiddleware>();
})
.ConfigureServices(services =>
{
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)
{
client.AddHeaderPropagation(configureClient);
}
else
{
client.AddHeaderPropagation();
}
});
if (configureClient != null)
{
client.AddHeaderPropagation(configureClient);
}
else
{
client.AddHeaderPropagation();
}
});
}).Build();
await host.StartAsync();
return host;
}
private class SimpleHandler : DelegatingHandler

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

@ -13,6 +13,7 @@ using Moq;
using Xunit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
{
@ -21,21 +22,26 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact]
public void ThrowFriendlyErrorWhenServicesNotRegistered()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
endpoints.MapHealthChecks("/healthz");
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/healthz");
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
}).Build();
var ex = Assert.Throws<InvalidOperationException>(() => new TestServer(builder));
var ex = Assert.Throws<InvalidOperationException>(() => host.Start());
Assert.Equal(
"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()
{
// Arrange
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
endpoints.MapHealthChecks("/healthz");
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/healthz");
});
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
});
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient();
// Act
@ -78,28 +92,36 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
public async Task MapHealthChecks_WithOptions_ReturnsOk()
{
// Arrange
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
webHostBuilder
.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";
await context.Response.WriteAsync("Custom!");
}
ResponseWriter = async (context, report) =>
{
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync("Custom!");
}
});
});
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
});
})
.ConfigureServices(services =>
{
services.AddRouting();
services.AddHealthChecks();
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient();
// 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.
using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
@ -14,10 +15,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact]
public async Task BasicStartup()
{
var builder = new WebHostBuilder()
.UseStartup<HealthChecksSample.BasicStartup>();
using var host = new HostBuilder()
.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 response = await client.GetAsync("/health");
@ -29,10 +37,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact]
public async Task CustomWriterStartup()
{
var builder = new WebHostBuilder()
.UseStartup<HealthChecksSample.CustomWriterStartup>();
using var host = new HostBuilder()
.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 response = await client.GetAsync("/health");
@ -45,10 +60,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact]
public async Task LivenessProbeStartup_Liveness()
{
var builder = new WebHostBuilder()
.UseStartup<HealthChecksSample.LivenessProbeStartup>();
using var host = new HostBuilder()
.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 response = await client.GetAsync("/health/live");
@ -60,10 +82,17 @@ namespace Microsoft.AspNetCore.Diagnostics.HealthChecks
[Fact]
public async Task LivenessProbeStartup_Readiness()
{
var builder = new WebHostBuilder()
.UseStartup<HealthChecksSample.LivenessProbeStartup>();
using var host = new HostBuilder()
.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 response = await client.GetAsync("/health/ready");

817
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.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
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()
.SetBasePath(Directory.GetCurrentDirectory())
@ -45,16 +47,20 @@ namespace HealthChecksSample
startupType = typeof(BasicStartup);
}
return new WebHostBuilder()
.UseConfiguration(config)
.ConfigureLogging(builder =>
return new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddConfiguration(config);
builder.AddConsole();
webHostBuilder
.UseConfiguration(config)
.ConfigureLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddConfiguration(config);
builder.AddConsole();
})
.UseKestrel()
.UseStartup(startupType);
})
.UseKestrel()
.UseStartup(startupType)
.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.
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace HostFilteringSample
{
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()
.ConfigureLogging((_, factory) =>
var hostBuilder = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.SetMinimumLevel(LogLevel.Debug);
factory.AddConsole();
})
.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
})
.UseKestrel()
.UseStartup<Startup>();
webHostBuilder
.ConfigureLogging((_, factory) =>
{
factory.SetMinimumLevel(LogLevel.Debug);
factory.AddConsole();
})
.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
})
.UseKestrel()
.UseStartup<Startup>();
});
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.
using System;
@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
@ -21,12 +22,20 @@ namespace Microsoft.AspNetCore.HostFiltering
[Fact]
public async Task MissingConfigThrows()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseHostFiltering();
});
await Assert.ThrowsAsync<InvalidOperationException>(() => new TestServer(builder).SendAsync(_ => { }));
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseHostFiltering();
});
}).Build();
await host.StartAsync();
await Assert.ThrowsAsync<InvalidOperationException>(() => host.GetTestServer().SendAsync(_ => { }));
}
[Theory]
@ -34,30 +43,38 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData(false, 400)]
public async Task AllowsMissingHost(bool allowed, int status)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHostFiltering(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.AllowEmptyHosts = allowed;
options.AllowedHosts.Add("Localhost");
});
})
.Configure(app =>
{
app.Use((ctx, next) =>
services.AddHostFiltering(options =>
{
options.AllowEmptyHosts = allowed;
options.AllowedHosts.Add("Localhost");
});
})
.Configure(app =>
{
ctx.Request.Headers.Remove(HeaderNames.Host);
return next();
app.Use((ctx, 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();
app.Run(c =>
{
Assert.False(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
return Task.CompletedTask;
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/");
Assert.Equal(status, (int)response.StatusCode);
}
@ -67,32 +84,40 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData(false, 400)]
public async Task AllowsEmptyHost(bool allowed, int status)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHostFiltering(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.AllowEmptyHosts = allowed;
options.AllowedHosts.Add("Localhost");
});
})
.Configure(app =>
{
app.Use((ctx, next) =>
services.AddHostFiltering(options =>
{
options.AllowEmptyHosts = allowed;
options.AllowedHosts.Add("Localhost");
});
})
.Configure(app =>
{
ctx.Request.Headers[HeaderNames.Host] = "";
return next();
app.Use((ctx, 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();
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);
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/");
Assert.Equal(status, (int)response.StatusCode);
}
@ -113,29 +138,37 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData("xn--c1yn36f:443", "點看")]
[InlineData("[::ABC]", "[::aBc]")]
[InlineData("[::1]:80", "[::1]")]
public async Task AllowsSpecifiedHost(string host, string allowedHost)
public async Task AllowsSpecifiedHost(string hosturl, string allowedHost)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHostFiltering(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
});
})
.Configure(app =>
{
app.Use((ctx, next) =>
services.AddHostFiltering(options =>
{
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
});
})
.Configure(app =>
{
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
// and that would over-normalize some of our test conditions like casing.
ctx.Request.Headers[HeaderNames.Host] = host;
return next();
app.Use((ctx, next) =>
{
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
// 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();
app.Run(c => Task.CompletedTask);
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(200, (int)response.StatusCode);
}
@ -157,29 +190,37 @@ namespace Microsoft.AspNetCore.HostFiltering
[InlineData("點看", "點看")]
[InlineData("[::1", "[::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()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHostFiltering(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
});
})
.Configure(app =>
{
app.Use((ctx, next) =>
services.AddHostFiltering(options =>
{
options.AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
});
})
.Configure(app =>
{
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
// and that would reject some of our test conditions.
ctx.Request.Headers[HeaderNames.Host] = host;
return next();
app.Use((ctx, next) =>
{
// TestHost's ClientHandler doesn't let you set the host header, only the host in the URI
// 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();
app.Run(c => throw new NotImplementedException("App"));
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(400, (int)response.StatusCode);
}
@ -191,26 +232,34 @@ namespace Microsoft.AspNetCore.HostFiltering
config["AllowedHosts"] = "localhost";
var currentHost = "otherHost";
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHostFiltering(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.AllowedHosts = new[] { config["AllowedHosts"] };
});
services.AddSingleton<IOptionsChangeTokenSource<HostFilteringOptions>>(new ConfigurationChangeTokenSource<HostFilteringOptions>(config));
})
.Configure(app =>
{
app.Use((ctx, next) =>
services.AddHostFiltering(options =>
{
options.AllowedHosts = new[] { config["AllowedHosts"] };
});
services.AddSingleton<IOptionsChangeTokenSource<HostFilteringOptions>>(new ConfigurationChangeTokenSource<HostFilteringOptions>(config));
})
.Configure(app =>
{
ctx.Request.Headers[HeaderNames.Host] = currentHost;
return next();
app.Use((ctx, next) =>
{
ctx.Request.Headers[HeaderNames.Host] = currentHost;
return next();
});
app.UseHostFiltering();
app.Run(c => Task.CompletedTask);
});
app.UseHostFiltering();
app.Run(c => Task.CompletedTask);
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync();
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.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpOverrides;
using Microsoft.Extensions.Hosting;
namespace HttpOverridesSample
{
@ -30,15 +32,19 @@ namespace HttpOverridesSample
}
// Entry point for the application.
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
// .UseIIS() // This repo can no longer reference IIS because IISIntegration depends on it.
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
// .UseIIS() // This repo can no longer reference IIS because IISIntegration depends on it.
.UseStartup<Startup>();
})
.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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Microsoft.Net.Http.Headers;
using Xunit;
@ -42,26 +43,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task VerifyHeaderIsUsedIfNoCertificateAlreadySet()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -72,27 +81,35 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task VerifyHeaderOverridesCertificateEvenAlreadySet()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
Assert.Null(context.Connection.ClientCertificate);
context.Connection.ClientCertificate = Certificates.SelfSignedNotYetValid;
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
app.Use(async (context, 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();
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -103,26 +120,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task VerifySettingTheAzureHeaderOnTheForwarderOptionsWorks()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddCertificateForwarding(options => options.CertificateHeader = "X-ARR-ClientCert");
})
.Configure(app =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
services.AddCertificateForwarding(options => options.CertificateHeader = "X-ARR-ClientCert");
})
.Configure(app =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);
await next();
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -133,26 +158,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task VerifyACustomHeaderFailsIfTheHeaderIsNotPresent()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddCertificateForwarding(options => options.CertificateHeader = "some-random-header");
})
.Configure(app =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
services.AddCertificateForwarding(options => options.CertificateHeader = "some-random-header");
})
.Configure(app =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -163,26 +196,34 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task VerifyArrHeaderEncodedCertFailsOnBadEncoding()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
app.Use(async (context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
services.AddCertificateForwarding(options => { });
})
.Configure(app =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
app.UseCertificateForwarding();
app.Use(async (context, next) =>
{
Assert.Null(context.Connection.ClientCertificate);
await next();
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers;
using Xunit;
@ -19,15 +20,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task XForwardedForDefaultSettingsChangeRemoteIpAndPort()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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
public async Task XForwardedForFirstValueIsInvalid(int limit, string header, string expectedIp, int expectedPort)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
ForwardLimit = limit,
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
ForwardLimit = limit,
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)]
public async Task XForwardedForForwardLimit(int limit, string header, string expectedIp, int expectedPort, string remainingHeader, bool requireSymmetry)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = requireSymmetry,
ForwardLimit = limit,
};
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
app.UseForwardedHeaders(options);
});
var server = new TestServer(builder);
var options = new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = requireSymmetry,
ForwardLimit = limit,
};
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -127,15 +152,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("::", false)]
public async Task XForwardedForLoopback(string originalIp, bool expectForwarded)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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
public async Task XForwardedForForwardKnownIps(int limit, string header, string knownIPs, string expectedIp, int expectedPort, bool requireSymmetry)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = requireSymmetry,
ForwardLimit = limit,
};
foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text)))
{
options.KnownProxies.Add(ip);
}
app.UseForwardedHeaders(options);
});
var server = new TestServer(builder);
var options = new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = requireSymmetry,
ForwardLimit = limit,
};
foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text)))
{
options.KnownProxies.Add(ip);
}
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -216,15 +257,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task XForwardedForOverrideBadIpDoesntChangeRemoteIp()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -237,15 +286,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task XForwardedHostOverrideChangesRequestHost()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -291,29 +348,37 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Theory]
[MemberData(nameof(HostHeaderData))]
public async Task XForwardedHostAllowsValidCharacters(string host)
public async Task XForwardedHostAllowsValidCharacters(string hostHeader)
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal(host, context.Request.Host.ToString());
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
await server.SendAsync(c =>
{
c.Request.Headers["X-Forwarded-Host"] = host;
c.Request.Headers["X-Forwarded-Host"] = hostHeader;
});
Assert.True(assertsExecuted);
}
@ -368,29 +433,37 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Theory]
[MemberData(nameof(HostHeaderInvalidData))]
public async Task XForwardedHostFailsForInvalidCharacters(string host)
public async Task XForwardedHostFailsForInvalidCharacters(string hostHeader)
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.NotEqual(host, context.Request.Host.Value);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
await server.SendAsync(c =>
{
c.Request.Headers["X-Forwarded-Host"] = host;
c.Request.Headers["X-Forwarded-Host"] = hostHeader;
});
Assert.True(assertsExecuted);
}
@ -411,28 +484,36 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("xn--c1yn36f:443", "點看")]
[InlineData("[::ABC]", "[::aBc]")]
[InlineData("[::1]:80", "[::1]")]
public async Task XForwardedHostAllowsSpecifiedHost(string host, string allowedHost)
public async Task XForwardedHostAllowsSpecifiedHost(string hostHeader, string allowedHost)
{
bool assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost,
AllowedHosts = allowedHost.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
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 =>
{
Assert.Equal(host, context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.SendAsync(ctx =>
{
ctx.Request.Headers["X-forwarded-Host"] = host;
ctx.Request.Headers["X-forwarded-Host"] = hostHeader;
});
Assert.True(assertsExecuted);
}
@ -454,28 +535,36 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("點看", "點看")]
[InlineData("[::1", "[::1]")]
[InlineData("[::1:80", "[::1]")]
public async Task XForwardedHostFailsMismatchedHosts(string host, string allowedHost)
public async Task XForwardedHostFailsMismatchedHosts(string hostHeader, string allowedHost)
{
bool assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost,
AllowedHosts = new[] { allowedHost }
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
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 =>
{
Assert.NotEqual<string>(host, context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.SendAsync(ctx =>
{
ctx.Request.Headers["X-forwarded-Host"] = host;
ctx.Request.Headers["X-forwarded-Host"] = hostHeader;
});
Assert.True(assertsExecuted);
}
@ -484,23 +573,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XForwardedHostStopsAtFirstUnspecifiedHost()
{
bool assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost,
ForwardLimit = 10,
AllowedHosts = new[] { "bar.com", "*.foo.com" }
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
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 =>
{
Assert.Equal("bar.foo.com:432", context.Request.Headers[HeaderNames.Host]);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.SendAsync(ctx =>
{
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")]
public async Task XForwardedProtoOverrideChangesRequestProtocol(int limit, string header, string expected)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
ForwardLimit = limit,
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
ForwardLimit = limit,
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -559,21 +664,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal(scheme, context.Request.Scheme);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
await server.SendAsync(c =>
{
@ -608,21 +721,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal("http", context.Request.Scheme);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
await server.SendAsync(c =>
{
@ -642,17 +763,25 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")]
public async Task XForwardedProtoOverrideLimitedByXForwardedForCount(int limit, string protoHeader, string forHeader, string expected)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = true,
ForwardLimit = limit,
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = true,
ForwardLimit = limit,
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -676,17 +805,25 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(10, "h3, h2, h1", "::1, badip, ::1", "h1")]
public async Task XForwardedProtoOverrideCanBeIndependentOfXForwardedForCount(int limit, string protoHeader, string forHeader, string expected)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = false,
ForwardLimit = limit,
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = false,
ForwardLimit = limit,
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -712,23 +849,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData("h2, h1", "E::, D::", "F::", true, "http")]
public async Task XForwardedProtoOverrideLimitedByLoopback(string protoHeader, string forHeader, string remoteIp, bool loopback, string expected)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = true,
ForwardLimit = 5,
};
if (!loopback)
{
options.KnownNetworks.Clear();
options.KnownProxies.Clear();
}
app.UseForwardedHeaders(options);
});
var server = new TestServer(builder);
var options = new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor,
RequireHeaderSymmetry = true,
ForwardLimit = 5,
};
if (!loopback)
{
options.KnownNetworks.Clear();
options.KnownProxies.Clear();
}
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -753,15 +898,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task AllForwardsEnabledChangeRequestRemoteIpHostandProtocol()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.All
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.All
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -778,15 +931,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task AllOptionsDisabledRequestDoesntChange()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.None
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.None
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -803,15 +964,23 @@ namespace Microsoft.AspNetCore.HttpOverrides
[Fact]
public async Task PartiallyEnabledForwardsPartiallyChangesRequest()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -852,12 +1021,20 @@ namespace Microsoft.AspNetCore.HttpOverrides
options.KnownNetworks.Add(new IPNetwork(networkIp, prefixLength));
}
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseForwardedHeaders(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -872,23 +1049,31 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(2, "httpa, httpb, httpc", "httpb", "httpa")]
public async Task ForwardersWithDIOptionsRunsOnce(int limit, string header, string expectedScheme, string remainingHeader)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.Configure<ForwardedHeadersOptions>(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedProto;
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
options.ForwardLimit = limit;
services.Configure<ForwardedHeadersOptions>(options =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedProto;
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
options.ForwardLimit = limit;
});
})
.Configure(app =>
{
app.UseForwardedHeaders();
app.UseForwardedHeaders();
});
})
.Configure(app =>
{
app.UseForwardedHeaders();
app.UseForwardedHeaders();
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var context = await server.SendAsync(c =>
{
@ -904,20 +1089,28 @@ namespace Microsoft.AspNetCore.HttpOverrides
[InlineData(2, "httpa, httpb, httpc", "httpa", "")]
public async Task ForwardersWithDirectOptionsRunsTwice(int limit, string header, string expectedScheme, string remainingHeader)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new ForwardedHeadersOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
ForwardLimit = limit,
};
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
app.UseForwardedHeaders(options);
app.UseForwardedHeaders(options);
});
var server = new TestServer(builder);
var options = new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedProto,
ForwardLimit = limit,
};
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
app.UseForwardedHeaders(options);
app.UseForwardedHeaders(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.HttpOverrides
@ -17,18 +18,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideHeaderAvaiableChangesRequestMethod()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseHttpMethodOverride();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
assertsExecuted = true;
Assert.Equal("DELETE", context.Request.Method);
return Task.FromResult(0);
app.UseHttpMethodOverride();
app.Run(context =>
{
assertsExecuted = true;
Assert.Equal("DELETE", context.Request.Method);
return Task.FromResult(0);
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Headers.Add("X-Http-Method-Override", "DELETE");
@ -40,18 +49,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideHeaderUnavaiableDoesntChangeRequestMethod()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseHttpMethodOverride();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
Assert.Equal("POST",context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
app.UseHttpMethodOverride();
app.Run(context =>
{
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, "");
await server.CreateClient().SendAsync(req);
@ -62,18 +79,26 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task XHttpMethodOverrideFromGetRequestDoesntChangeMethodType()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseHttpMethodOverride();
app.Run(context =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
Assert.Equal("GET", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
app.UseHttpMethodOverride();
app.Run(context =>
{
Assert.Equal("GET", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Get, "");
await server.CreateClient().SendAsync(req);
@ -85,21 +110,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldAvailableChangesRequestMethod()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal("DELETE", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new FormUrlEncodedContent(new Dictionary<string, string>()
@ -116,21 +149,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldUnavailableDoesNotChangeRequestMethod()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new FormUrlEncodedContent(new Dictionary<string, string>()
@ -146,21 +187,29 @@ namespace Microsoft.AspNetCore.HttpOverrides
public async Task FormFieldEmptyDoesNotChangeRequestMethod()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
Assert.Equal("POST", context.Request.Method);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var req = new HttpRequestMessage(HttpMethod.Post, "");
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.
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel(
options =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
options.Listen(new IPEndPoint(IPAddress.Loopback, 5001), listenOptions =>
webHostBuilder
.UseKestrel(
options =>
{
listenOptions.UseHttps("testCert.pfx", "testPassword");
});
options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), listenOptions =>
options.Listen(new IPEndPoint(IPAddress.Loopback, 5001), 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();
host.Run();
return host.RunAsync();
}
}
}

292
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.
using System;
@ -12,6 +12,7 @@ using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing;
using Microsoft.Net.Http.Headers;
@ -24,20 +25,27 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[Fact]
public async Task SetOptionsWithDefault_SetsMaxAgeToCorrectValue()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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();
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")]
public async Task SetOptionsThroughConfigure_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.Configure<HstsOptions>(options => {
options.Preload = preload;
options.IncludeSubDomains = includeSubDomains;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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();
client.BaseAddress = new Uri("https://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -96,25 +112,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData(50000, true, true, "max-age=50000; includeSubDomains; preload")]
public async Task SetOptionsThroughHelper_SetsHeaderCorrectly(int maxAge, bool includeSubDomains, bool preload, string expected)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddHsts(options => {
options.Preload = preload;
options.IncludeSubDomains = includeSubDomains;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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();
client.BaseAddress = new Uri("https://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -131,29 +155,37 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
[InlineData("LOCALHOST")]
[InlineData("127.0.0.1")]
[InlineData("[::1]")]
public async Task DefaultExcludesCommonLocalhostDomains_DoesNotSetHstsHeader(string host)
public async Task DefaultExcludesCommonLocalhostDomains_DoesNotSetHstsHeader(string hostUrl)
{
var sink = new TestSink(
TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
return context.Response.WriteAsync("Hello world");
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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 response = await client.SendAsync(request);
@ -166,41 +198,49 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
Assert.Single(logMessages);
var message = logMessages.Single();
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]
[InlineData("localhost")]
[InlineData("127.0.0.1")]
[InlineData("[::1]")]
public async Task AllowLocalhostDomainsIfListIsReset_SetHstsHeader(string host)
public async Task AllowLocalhostDomainsIfListIsReset_SetHstsHeader(string hostUrl)
{
var sink = new TestSink(
TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.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");
});
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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 response = await client.SendAsync(request);
@ -215,38 +255,47 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
Assert.Equal(LogLevel.Trace, message.LogLevel);
Assert.Equal("Adding HSTS header to response.", message.State.ToString());
}
[Theory]
[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(
TestSink.EnableWithTypeName<HstsMiddleware>,
TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddHsts(options => {
options.ExcludedHosts.Add(host);
});
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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 response = await client.SendAsync(request);
@ -259,7 +308,7 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
Assert.Single(logMessages);
var message = logMessages.Single();
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]
@ -270,20 +319,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
return context.Response.WriteAsync("Hello world");
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient();
client.BaseAddress = new Uri("http://example.com:5050");
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -309,20 +366,27 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HstsMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
return context.Response.WriteAsync("Hello world");
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
});
var server = new TestServer(builder);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var client = server.CreateClient();
client.BaseAddress = new Uri("https://example.com:5050");
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.
using System;
@ -13,6 +13,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers;
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/")]
public async Task SetsBothHstsAndHttpsRedirection_RedirectOnFirstRequest_HstsOnSecondRequest(int statusCode, int? tlsPort, int maxAge, bool includeSubDomains, bool preload, string expectedHstsHeader, string expectedUrl)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.Configure<HttpsRedirectionOptions>(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.RedirectStatusCode = statusCode;
options.HttpsPort = tlsPort;
});
services.Configure<HstsOptions>(options =>
services.Configure<HttpsRedirectionOptions>(options =>
{
options.RedirectStatusCode = statusCode;
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;
options.MaxAge = TimeSpan.FromSeconds(maxAge);
options.Preload = preload;
options.ExcludedHosts.Clear(); // allowing localhost for testing
app.UseHttpsRedirection();
app.UseHsts();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.UseHsts();
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);
await host.StartAsync();
var server = host.GetTestServer();
server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var client = server.CreateClient();
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.
using System;
@ -8,11 +8,13 @@ using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing;
using Xunit;
@ -28,21 +30,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -71,26 +80,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.Configure<HttpsRedirectionOptions>(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.RedirectStatusCode = statusCode;
options.HttpsPort = httpsPort;
});
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.Configure<HttpsRedirectionOptions>(options =>
{
options.RedirectStatusCode = statusCode;
options.HttpsPort = httpsPort;
});
})
.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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -120,26 +136,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddHttpsRedirection(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.RedirectStatusCode = statusCode;
options.HttpsPort = httpsPort;
});
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddHttpsRedirection(options =>
{
options.RedirectStatusCode = statusCode;
options.HttpsPort = httpsPort;
});
})
.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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -169,34 +192,39 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
public async Task SetHttpsPortEnvironmentVariableAndServerFeature_ReturnsCorrectStatusCodeOnResponse(
int? optionsHttpsPort, string configHttpsPort, string serverAddressFeatureUrl, string expectedUrl)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
{
services.AddHttpsRedirection(options =>
{
options.HttpsPort = optionsHttpsPort;
});
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.AddHttpsRedirection(options =>
{
options.HttpsPort = optionsHttpsPort;
});
})
.Configure(app =>
{
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();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
var server = host.GetTestServer();
server.Features.Set<IServerAddressesFeature>(new ServerAddressesFeature());
if (serverAddressFeatureUrl != null)
{
server.Features.Get<IServerAddressesFeature>().Addresses.Add(serverAddressFeatureUrl);
}
await host.StartAsync();
var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -213,25 +241,30 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.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");
await host.StartAsync();
var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -259,27 +292,33 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.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:5051");
await host.StartAsync();
var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -303,27 +342,32 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
return context.Response.WriteAsync("Hello world");
app.UseHttpsRedirection();
app.Run(context =>
{
return context.Response.WriteAsync("Hello world");
});
});
});
var featureCollection = new FeatureCollection();
featureCollection.Set<IServerAddressesFeature>(new ServerAddressesFeature());
var server = new TestServer(builder, featureCollection);
}).Build();
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://example.com:5050");
await host.StartAsync();
var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -351,21 +395,28 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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 request = new HttpRequestMessage(HttpMethod.Get, "");
var response = await client.SendAsync(request);
@ -386,23 +437,29 @@ namespace Microsoft.AspNetCore.HttpsPolicy.Tests
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>,
TestSink.EnableWithTypeName<HttpsRedirectionMiddleware>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseHttpsRedirection();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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();
featureCollection.Set<IServerAddressesFeature>(null);
var server = new TestServer(builder, featureCollection);
var server = host.GetTestServer();
server.Features.Set<IServerAddressesFeature>(null);
await host.StartAsync();
var client = server.CreateClient();
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.
using System.Collections.Generic;
@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Localization.Routing
@ -30,50 +31,57 @@ namespace Microsoft.AspNetCore.Localization.Routing
string expectedCulture,
string expectedUICulture)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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"),
SupportedCultures = new List<CultureInfo>
var options = new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{
new RouteDataRequestCultureProvider()
{
Options = options
}
};
fork.UseRequestLocalization(options);
new RouteDataRequestCultureProvider()
{
Options = options
}
};
fork.UseRequestLocalization(options);
fork.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
fork.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
});
});
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(requestUrl);
@ -87,32 +95,39 @@ namespace Microsoft.AspNetCore.Localization.Routing
[Fact]
public async Task GetDefaultCultureInfo_IfCultureKeysAreMissing()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US")
};
options.RequestCultureProviders = new[]
{
new RouteDataRequestCultureProvider()
var options = new RequestLocalizationOptions
{
Options = options
}
};
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
DefaultRequestCulture = new RequestCulture("en-US")
};
options.RequestCultureProviders = new[]
{
new RouteDataRequestCultureProvider()
{
Options = options
}
};
app.UseRequestLocalization(options);
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
return context.Response.WriteAsync(
$"{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 response = await client.GetAsync("/page");
@ -135,53 +150,60 @@ namespace Microsoft.AspNetCore.Localization.Routing
string expectedCulture,
string expectedUICulture)
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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"),
SupportedCultures = new List<CultureInfo>
var options = new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{
new CultureInfo("ar-YE")
}
};
options.RequestCultureProviders = new[]
{
new RouteDataRequestCultureProvider()
{
Options = options,
RouteDataStringKey = "c",
UIRouteDataStringKey = "uic"
}
};
fork.UseRequestLocalization(options);
new RouteDataRequestCultureProvider()
{
Options = options,
RouteDataStringKey = "c",
UIRouteDataStringKey = "uic"
}
};
fork.UseRequestLocalization(options);
fork.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
fork.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
return context.Response.WriteAsync(
$"{requestCulture.Culture.Name},{requestCulture.UICulture.Name}");
});
});
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
})
.ConfigureServices(services =>
{
services.AddRouting();
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync(requestUrl);

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

@ -1,14 +1,16 @@
// 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.
// 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.Globalization;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Localization;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Localization;
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>");
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.ConfigureLogging(factory => factory.AddConsole())
.UseKestrel()
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.ConfigureLogging(factory => factory.AddConsole())
.UseKestrel()
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup<Startup>();
})
.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 Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Localization.FunctionalTests
@ -19,8 +20,17 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
public async Task LocalizationSampleSmokeTest()
{
// Arrange
var webHostBuilder = new WebHostBuilder().UseStartup(typeof(Startup));
var testHost = new TestServer(webHostBuilder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(typeof(Startup));
}).Build();
await host.StartAsync();
var testHost = host.GetTestServer();
var locale = "fr-FR";
var client = testHost.CreateClient();
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 Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Localization.FunctionalTests
@ -97,8 +98,17 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
private async Task RunTest(Type startupType, string culture, string expected)
{
var webHostBuilder = new WebHostBuilder().UseStartup(startupType);
var testHost = new TestServer(webHostBuilder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.UseStartup(startupType);
}).Build();
await host.StartAsync();
var testHost = host.GetTestServer();
var client = testHost.CreateClient();
var request = new HttpRequestMessage();
@ -109,6 +119,6 @@ namespace Microsoft.AspNetCore.Localization.FunctionalTests
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expected, await response.Content.ReadAsStringAsync());
}
}
}
}

177
src/Middleware/Localization/test/UnitTests/AcceptLanguageHeaderRequestCultureProviderTest.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.
using System.Collections.Generic;
@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.Extensions.Localization
@ -17,28 +18,35 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetFallbackLanguage_ReturnsFirstNonNullCultureFromSupportedCultureList()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA"),
new CultureInfo("en-US")
}
DefaultRequestCulture = new RequestCulture("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 =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", 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();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("jp,ar-SA,en-US");
@ -51,28 +59,35 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetFallbackLanguage_ReturnsFromSupportedCulture_AcceptLanguageListContainsSupportedCultures()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("fr-FR"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA"),
new CultureInfo("en-US")
}
DefaultRequestCulture = new RequestCulture("fr-FR"),
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 =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-SA", 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();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-SA,en-US");
@ -84,28 +99,35 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetFallbackLanguage_ReturnsDefault_AcceptLanguageListDoesnotContainSupportedCultures()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("fr-FR"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA"),
new CultureInfo("af-ZA")
}
DefaultRequestCulture = new RequestCulture("fr-FR"),
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 =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("fr-FR", 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();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-MA,en-US");
@ -114,37 +136,44 @@ namespace Microsoft.Extensions.Localization
Assert.Equal(3, count);
}
}
[Fact]
public async Task OmitDefaultRequestCultureShouldNotThrowNullReferenceException_And_ShouldGetTheRightCulture()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-YE")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("ar-YE")
}
});
app.Run(context =>
{
new CultureInfo("ar-YE")
}
});
app.Run(context =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("ar-YE", requestCulture.Culture.Name);
Assert.Equal("ar-YE", requestCulture.UICulture.Name);
return Task.FromResult(0);
Assert.Equal("ar-YE", 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();
client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-GB,ar-YE,en-US");
@ -154,4 +183,4 @@ namespace Microsoft.Extensions.Localization
}
}
}
}
}

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

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

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

387
src/Middleware/Localization/test/UnitTests/QueryStringRequestCultureProviderTest.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.
using System.Collections.Generic;
@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.Extensions.Localization
@ -17,32 +18,39 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetCultureInfoFromQueryString()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 =>
{
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 response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-YE");
@ -52,24 +60,31 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetDefaultCultureInfoIfCultureKeysAreMissing()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.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 =>
{
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);
});
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync("/page");
@ -79,31 +94,38 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetDefaultCultureInfoIfCultureIsInSupportedCultureList()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 =>
{
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 response = await client.GetAsync("/page?culture=ar-XY&ui-culture=ar-SA");
@ -113,31 +135,38 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetDefaultCultureInfoIfUICultureIsNotInSupportedList()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 =>
{
var requestCultureFeature = context.Features.Get<IRequestCultureFeature>();
var requestCulture = requestCultureFeature.RequestCulture;
Assert.Equal("en-US", 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 response = await client.GetAsync("/page?culture=ar-SA&ui-culture=ar-XY");
@ -147,32 +176,39 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetSameCultureInfoIfCultureKeyIsMissing()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 =>
{
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);
});
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync("/page?ui-culture=ar-SA");
@ -182,32 +218,39 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetSameCultureInfoIfUICultureKeyIsMissing()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRequestLocalization(new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
app.UseRequestLocalization(new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 =>
{
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);
});
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var response = await client.GetAsync("/page?culture=ar-SA");
@ -217,37 +260,44 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetCultureInfoFromQueryStringWithCustomKeys()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
var options = new RequestLocalizationOptions
{
new CultureInfo("ar-SA")
},
SupportedUICultures = new List<CultureInfo>
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = 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 provider = new QueryStringRequestCultureProvider();
provider.QueryStringKey = "c";
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);
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 response = await client.GetAsync("/page?c=ar-SA&uic=ar-YE");
@ -257,42 +307,49 @@ namespace Microsoft.Extensions.Localization
[Fact]
public async Task GetTheRightCultureInfoRegardlessOfCultureNameCasing()
{
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var options = new RequestLocalizationOptions
webHostBuilder
.UseTestServer()
.Configure(app =>
{
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
var options = new RequestLocalizationOptions
{
new CultureInfo("FR")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("FR")
}
};
var provider = new QueryStringRequestCultureProvider();
DefaultRequestCulture = new RequestCulture("en-US"),
SupportedCultures = new List<CultureInfo>
{
new CultureInfo("FR")
},
SupportedUICultures = new List<CultureInfo>
{
new CultureInfo("FR")
}
};
var provider = new QueryStringRequestCultureProvider();
provider.QueryStringKey = "c";
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("fr", requestCulture.Culture.ToString());
Assert.Equal("fr", requestCulture.UICulture.ToString());
return Task.FromResult(0);
provider.QueryStringKey = "c";
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("fr", requestCulture.Culture.ToString());
Assert.Equal("fr", requestCulture.UICulture.ToString());
return Task.FromResult(0);
});
});
});
}).Build();
using (var server = new TestServer(builder))
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
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.
// 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.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace LocalizationWebsite
{
public static class Program
{
public static void Main(string[] args)
public static Task Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.ConfigureLogging((_, factory) =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.AddConsole();
factory.AddFilter("Console", level => level >= LogLevel.Warning);
webHostBuilder
.ConfigureLogging((_, factory) =>
{
factory.AddConsole();
factory.AddFilter("Console", level => level >= LogLevel.Warning);
})
.UseKestrel()
.UseConfiguration(config)
.UseStartup("LocalizationWebsite");
})
.UseKestrel()
.UseConfiguration(config)
.UseStartup("LocalizationWebsite")
.Build();
host.Run();
return host.RunAsync();
}
}
}

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

@ -1,10 +1,12 @@
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DiagnosticAdapter;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace MiddlewareAnaysisSample
@ -79,20 +81,23 @@ namespace MiddlewareAnaysisSample
// 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()
.ConfigureLogging((_, factory) =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.AddConsole();
factory.AddFilter("Console", level => level >= LogLevel.Debug);
})
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
webHostBuilder
.ConfigureLogging((_, factory) =>
{
factory.AddConsole();
factory.AddFilter("Console", level => level >= LogLevel.Debug);
})
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>();
}).Build();
host.Run();
return host.RunAsync();
}
public class TestDiagnosticListener

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

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

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

@ -3,11 +3,13 @@
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.NodeServices;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace NodeServicesExamples
@ -58,21 +60,24 @@ namespace NodeServicesExamples
}
#pragma warning restore 0618
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.ConfigureLogging(factory =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.AddConsole();
factory.AddDebug();
})
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseKestrel()
.UseStartup<Startup>()
.Build();
webHostBuilder
.ConfigureLogging(factory =>
{
factory.AddConsole();
factory.AddDebug();
})
.UseContentRoot(Directory.GetCurrentDirectory())
.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.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers;
namespace ResponseCachingSample
@ -34,16 +36,19 @@ namespace ResponseCachingSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.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)
{
using (var server = new TestServer(builder))
using var host = builder.Build();
await host.StartAsync();
using (var server = host.GetTestServer())
{
var client = server.CreateClient();
var initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, ""));
@ -42,7 +46,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, ""));
@ -60,7 +68,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.PostAsync("", new StringContent(string.Empty));
@ -78,7 +90,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 subsequentResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Head, ""));
@ -96,7 +112,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, ""));
@ -116,7 +136,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
@ -145,7 +169,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
@ -174,7 +202,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "path"));
@ -194,7 +226,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.SendAsync(TestUtils.CreateRequest(method, "?Expires=0"));
@ -214,7 +250,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("abc");
@ -233,7 +273,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.From = "user@example.com";
@ -252,7 +296,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.From = "user@example.com";
@ -272,7 +320,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?query=value");
@ -290,7 +342,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -308,7 +364,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -326,7 +386,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB");
@ -344,7 +408,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?QueryA=ValueA&QueryB=ValueB");
@ -362,7 +430,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?query=value");
@ -380,7 +452,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -398,7 +474,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?querya=valuea&queryb=valueb");
@ -416,7 +496,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -438,7 +522,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -461,7 +549,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -479,7 +571,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -501,7 +597,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.CacheControl = new System.Net.Http.Headers.CacheControlHeaderValue()
@ -523,7 +623,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -546,7 +650,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?Expires=90");
@ -567,7 +675,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -591,7 +703,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("?Expires=90");
@ -612,7 +728,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -634,7 +754,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -655,7 +779,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("");
@ -676,7 +804,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 initialResponse = await client.GetAsync("/path");
@ -694,7 +826,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.From = "user@example.com";
@ -716,7 +852,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.From = "user@example.com";
@ -747,7 +887,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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();
client.DefaultRequestHeaders.From = "user@example.com";
@ -778,7 +922,11 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
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 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.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Logging.Testing;
@ -116,7 +118,7 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
return new ResponseCachingKeyProvider(new DefaultObjectPoolProvider(), Options.Create(options));
}
internal static IEnumerable<IWebHostBuilder> CreateBuildersWithResponseCaching(
internal static IEnumerable<IHostBuilder> CreateBuildersWithResponseCaching(
Action<IApplicationBuilder> configureDelegate = null,
ResponseCachingOptions options = 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,
ResponseCachingOptions options = null,
IEnumerable<RequestDelegate> requestDelegates = null)
@ -162,24 +164,29 @@ namespace Microsoft.AspNetCore.ResponseCaching.Tests
foreach (var requestDelegate in requestDelegates)
{
// Test with in memory ResponseCache
yield return new WebHostBuilder()
.ConfigureServices(services =>
yield return new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCaching(responseCachingOptions =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
if (options != null)
services.AddResponseCaching(responseCachingOptions =>
{
responseCachingOptions.MaximumBodySize = options.MaximumBodySize;
responseCachingOptions.UseCaseSensitivePaths = options.UseCaseSensitivePaths;
responseCachingOptions.SystemClock = options.SystemClock;
}
if (options != null)
{
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.ResponseCompression;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace ResponseCompressionSample
@ -71,19 +72,22 @@ namespace ResponseCompressionSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.ConfigureLogging(factory =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.AddConsole()
.SetMinimumLevel(LogLevel.Debug);
})
.UseStartup<Startup>()
.Build();
webHostBuilder
.UseKestrel()
.ConfigureLogging(factory =>
{
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.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing;
using Microsoft.Net.Http.Headers;
@ -134,24 +135,31 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
[Fact]
public async Task GZipCompressionProvider_OptionsSetInDI_Compress()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.Configure<GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.NoCompression);
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
services.Configure<GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.NoCompression);
services.AddResponseCompression();
})
.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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -286,23 +294,30 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
[InlineData("text/plain2")]
public async Task NoBody_NotCompressed(string contentType)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = contentType;
return Task.FromResult(0);
services.AddResponseCompression();
})
.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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -413,30 +428,35 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.EnableForHttps = enableHttps;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
{
options.EnableForHttps = enableHttps;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
app.UseResponseCompression();
app.Run(context =>
{
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
});
});
});
}).Build();
var server = new TestServer(builder)
{
BaseAddress = new Uri("https://localhost/")
};
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient();
@ -469,32 +489,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.EnableForHttps = false;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
{
options.EnableForHttps = false;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
var feature = context.Features.Get<IHttpsCompressionFeature>();
feature.Mode = mode;
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
app.UseResponseCompression();
app.Run(context =>
{
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)
{
BaseAddress = new Uri("https://localhost/")
};
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient();
@ -527,32 +552,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
options.EnableForHttps = true;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
services.AddSingleton<ILoggerFactory>(loggerFactory);
services.AddResponseCompression(options =>
{
options.EnableForHttps = true;
options.MimeTypes = new[] { TextPlain };
});
})
.Configure(app =>
{
var feature = context.Features.Get<IHttpsCompressionFeature>();
feature.Mode = mode;
context.Response.ContentType = TextPlain;
return context.Response.WriteAsync(new string('a', 100));
app.UseResponseCompression();
app.Run(context =>
{
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)
{
BaseAddress = new Uri("https://localhost/")
};
await host.StartAsync();
var server = host.GetTestServer();
server.BaseAddress = new Uri("https://localhost/");
var client = server.CreateClient();
@ -580,28 +610,33 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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));
services.AddResponseCompression();
})
.Configure(app =>
{
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)
{
AllowSynchronousIO = true // needed for synchronous flush
};
await host.StartAsync();
var server = host.GetTestServer();
server.AllowSynchronousIO = true; // needed for synchronous flush
var client = server.CreateClient();
var request = new HttpRequestMessage(HttpMethod.Get, "");
@ -621,25 +656,32 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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));
services.AddResponseCompression();
})
.Configure(app =>
{
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -659,32 +701,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
var feature = context.Features.Get<IHttpBodyControlFeature>();
if (feature != null)
services.AddResponseCompression();
})
.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.ContentType = TextPlain;
context.Response.Body.Write(new byte[10], 0, 10);
context.Response.Body.Flush();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
context.Response.Body.Write(new byte[90], 0, 90);
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
context.Response.Body.Write(new byte[10], 0, 10);
context.Response.Body.Flush();
await responseReceived.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -711,26 +760,33 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
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));
services.AddResponseCompression();
})
.Configure(app =>
{
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -764,36 +820,43 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously),
};
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering();
var feature = context.Features.Get<IHttpBodyControlFeature>();
if (feature != null)
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
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)
{
context.Response.Body.Write(new byte[1], 0, 1);
context.Response.Body.Flush();
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
var feature = context.Features.Get<IHttpBodyControlFeature>();
if (feature != null)
{
feature.AllowSynchronousIO = true;
}
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -827,30 +890,37 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously),
};
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
context.Features.Get<IHttpResponseBodyFeature>().DisableBuffering();
foreach (var signal in responseReceived)
services.AddResponseCompression();
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(async context =>
{
await context.Response.WriteAsync("a");
await context.Response.Body.FlushAsync();
await signal.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
});
});
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -876,32 +946,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.Use((context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
app.UseResponseCompression();
app.Run(context =>
services.AddResponseCompression();
})
.Configure(app =>
{
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);
app.Use((context, next) =>
{
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -919,32 +996,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.Use((context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
app.UseResponseCompression();
app.Run(context =>
services.AddResponseCompression();
})
.Configure(app =>
{
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);
app.Use((context, next) =>
{
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -962,32 +1046,39 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
FakeSendFileFeature fakeSendFile = null;
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.Use((context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
fakeSendFile = new FakeSendFileFeature(context.Features.Get<IHttpResponseBodyFeature>());
context.Features.Set<IHttpResponseBodyFeature>(fakeSendFile);
return next();
});
app.UseResponseCompression();
app.Run(async context =>
services.AddResponseCompression();
})
.Configure(app =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = TextPlain;
var feature = context.Features.Get<IHttpResponseBodyFeature>();
app.Use((context, next) =>
{
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 feature.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);
await context.Response.WriteAsync(new string('a', 100));
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -1006,31 +1097,38 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
{
var responseReceived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression();
})
.Configure(app =>
{
app.Use((context, next) =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Body = new NoSyncWrapperStream(context.Response.Body);
return next();
});
app.UseResponseCompression();
app.Run(async context =>
services.AddResponseCompression();
})
.Configure(app =>
{
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));
app.Use((context, next) =>
{
context.Response.Body = new NoSyncWrapperStream(context.Response.Body);
return next();
});
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 request = new HttpRequestMessage(HttpMethod.Get, "");
@ -1063,25 +1161,32 @@ namespace Microsoft.AspNetCore.ResponseCompression.Tests
TestSink.EnableWithTypeName<ResponseCompressionProvider>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddResponseCompression(configure ?? (_ => { }));
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.Configure(app =>
{
app.UseResponseCompression();
app.Run(context =>
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
context.Response.ContentType = responseType;
addResponseAction?.Invoke(context.Response);
return context.Response.WriteAsync(new string('a', uncompressedBodyLength));
services.AddResponseCompression(configure ?? (_ => { }));
services.AddSingleton<ILoggerFactory>(loggerFactory);
})
.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 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]));
}
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)

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

@ -3,11 +3,13 @@
using System.IO;
using System.Net;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Rewrite;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace RewriteSample
{
@ -42,23 +44,26 @@ namespace RewriteSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel(options =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
options.Listen(IPAddress.Loopback, 5000);
options.Listen(IPAddress.Loopback, 5001, listenOptions =>
webHostBuilder
.UseKestrel(options =>
{
// Configure SSL
listenOptions.UseHttps("testCert.pfx", "testPassword");
});
})
.UseStartup<Startup>()
.UseContentRoot(Directory.GetCurrentDirectory())
.Build();
options.Listen(IPAddress.Loopback, 5000);
options.Listen(IPAddress.Loopback, 5001, listenOptions =>
{
// Configure SSL
listenOptions.UseHttps("testCert.pfx", "testPassword");
});
})
.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.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
@ -19,13 +20,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_RewritePathWhenMatching()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 "));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -37,13 +46,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1 [L]"))
.AddApacheModRewrite(new StringReader("RewriteRule /hello /what"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -55,13 +72,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("RewriteRule /hey/(.*) /$1"))
.AddApacheModRewrite(new StringReader("RewriteRule /hello /what"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -72,13 +97,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldIgnoreComments()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader("#RewriteRule ^/hey/(.*) /$1 "));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -89,13 +122,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldRewriteHomepage()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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/");
@ -106,13 +147,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldIgnorePorts()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^/$ /homepage.html"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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/");
@ -123,13 +172,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_HandleNegatedRewriteRules()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule !^/$ /homepage.html"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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/");
@ -142,13 +199,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_BackReferencesShouldBeApplied(string url, string rule, string expected)
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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);
@ -165,13 +230,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_ShouldHandleFlagNoCase(string url, string rule, string expected)
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(rule));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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);
@ -183,13 +256,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -201,13 +282,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -219,13 +308,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader(@"RewriteRule (.+) http://www.example.com$1/"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -238,13 +335,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteCond %{REQUEST_URI} /foo/ \nRewriteCond %{HTTPS} !on \nRewriteRule ^(.*)$ https://www.example.com$1 [R=301,L]"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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);
@ -258,13 +363,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [R=301,L]"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Scheme + "://" + context.Request.Host.Host + context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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);
@ -278,13 +391,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
{
var options = new RewriteOptions()
.AddApacheModRewrite(new StringReader("RewriteRule ^(.*)$ $1 [L]"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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);
Assert.Equal("/", response);
@ -294,15 +415,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
public async Task Invoke_CaptureEmptyStringInRegexAssertLocationHeaderContainsPathBase()
{
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteRule ^(.*)$ $1 [R=301,L]"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") };
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
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("");
@ -315,15 +445,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.ModRewrite
var options = new RewriteOptions().AddApacheModRewrite(new StringReader(@"RewriteCond %{REQUEST_URI} /home
RewriteCond %{QUERY_STRING} report_id=(.+)
RewriteRule (.*) http://localhost:80/home/report/%1 [R=301,L,QSD]"));
var builder = new WebHostBuilder().Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
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");
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.UrlMatches;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
using Microsoft.Net.Http.Headers;
using Xunit;
@ -33,13 +34,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location]));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -57,13 +66,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -85,13 +102,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.Path + context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -109,13 +134,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Response.Headers[HeaderNames.Location]));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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");
@ -137,12 +170,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello/");
@ -164,12 +205,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello");
@ -190,12 +239,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri("http://example.com"));
@ -216,18 +273,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
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"));
@ -245,18 +310,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
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/"));
@ -274,18 +347,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
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/"));
@ -303,15 +384,23 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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(new Uri("http://example.com/"));
@ -329,15 +418,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") };
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
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("");
@ -362,12 +460,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("hey/hello");
@ -390,12 +496,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.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");
@ -418,12 +532,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.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");
@ -447,12 +569,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.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"));
@ -475,13 +605,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</globalRules>
</rewrite>";
var options = new RewriteOptions().AddIISUrlRewrite(new StringReader(xml));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// act
var response = await server.CreateClient().GetStringAsync($"http://localhost/{Guid.NewGuid()}/foo/bar");
@ -512,13 +650,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rewriteMap>
</rewriteMaps>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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));
@ -536,12 +682,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
</rule>
</rules>
</rewrite>"));
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("article/10/hey");
var content = await response.Content.ReadAsStringAsync();
@ -583,13 +737,21 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.UrlRewrite
ruleBuilder.AddUrlAction(action);
var options = new RewriteOptions().Add(ruleBuilder.Build());
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(context.Request.GetEncodedUrl()));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
// act
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.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Xunit;
namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
@ -18,18 +19,26 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRewritePath()
{
var options = new RewriteOptions().AddRewrite("(.*)", "http://example.com/$1", skipRemainingRules: false);
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Scheme +
"://" +
context.Request.Host +
context.Request.Path +
context.Request.QueryString));
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetStringAsync("foo");
@ -40,12 +49,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectPath()
{
var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("foo");
@ -55,19 +72,27 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
[Fact]
public async Task RewriteRulesCanComeFromConfigureOptions()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
{
services.Configure<RewriteOptions>(options =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
options.AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
});
})
.Configure(app =>
{
app.UseRewriter();
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.ConfigureServices(services =>
{
services.Configure<RewriteOptions>(options =>
{
options.AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
});
})
.Configure(app =>
{
app.UseRewriter();
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("foo");
@ -78,12 +103,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectPathWithQueryString()
{
var options = new RewriteOptions().AddRedirect("(.*)", "http://example.com/$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToHttps(statusCode: statusCode);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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()
{
var options = new RewriteOptions().AddRedirectToHttpsPermanent();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToHttps(statusCode: StatusCodes.Status301MovedPermanently, sslPort: sslPort);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToWww();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -193,12 +266,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToWww()
{
var options = new RewriteOptions().AddRedirectToWwwPermanent();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToWww();
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToNonWww(statusCode: statusCode);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.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"));
@ -261,12 +358,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckRedirectToNonWww(string requestUri, string redirectUri)
{
var options = new RewriteOptions().AddRedirectToNonWww();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -278,12 +383,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToNonWww()
{
var options = new RewriteOptions().AddRedirectToNonWwwPermanent();
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.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"));
@ -295,12 +408,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckIfEmptyStringRedirectCorrectly()
{
var options = new RewriteOptions().AddRedirect("(.*)", "$1", statusCode: StatusCodes.Status301MovedPermanently);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("");
Assert.Equal("/", response.Headers.Location.OriginalString);
@ -310,15 +431,23 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckIfEmptyStringRewriteCorrectly()
{
var options = new RewriteOptions().AddRewrite("(.*)", "$1", skipRemainingRules: false);
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
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("");
@ -329,15 +458,24 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task SettingPathBase()
{
var options = new RewriteOptions().AddRedirect("(.*)", "$1");
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
app.Run(context => context.Response.WriteAsync(
context.Request.Path +
context.Request.QueryString));
});
var server = new TestServer(builder) { BaseAddress = new Uri("http://localhost:5000/foo") };
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
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("");
@ -353,12 +491,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckNoRedirectToWwwInNonWhitelistedDomains(string requestUri)
{
var options = new RewriteOptions().AddRedirectToWww("example2.com");
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToWww("example.com");
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(new Uri(requestUri));
@ -390,12 +544,20 @@ namespace Microsoft.AspNetCore.Rewrite.Tests.CodeRules
public async Task CheckPermanentRedirectToWwwInWhitelistedDomains()
{
var options = new RewriteOptions().AddRedirectToWwwPermanent("example.com");
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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)
{
var options = new RewriteOptions().AddRedirectToWww(statusCode: statusCode, "example.com");
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseRewriter(options);
});
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app =>
{
app.UseRewriter(options);
});
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
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.
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace SessionSample
@ -81,16 +83,19 @@ namespace SessionSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.ConfigureLogging(factory => factory.AddConsole())
.UseKestrel()
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.ConfigureLogging(factory => factory.AddConsole())
.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.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace StaticFilesSample
@ -25,22 +27,25 @@ namespace StaticFilesSample
});
}
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.ConfigureLogging(factory =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
factory.AddFilter("Console", level => level >= LogLevel.Debug);
factory.AddConsole();
})
.UseContentRoot(Directory.GetCurrentDirectory())
.UseKestrel()
// .UseHttpSys()
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
webHostBuilder
.ConfigureLogging(factory =>
{
factory.AddFilter("Console", level => level >= LogLevel.Debug);
factory.AddConsole();
})
.UseContentRoot(Directory.GetCurrentDirectory())
.UseKestrel()
// .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.Extensions.DependencyInjection;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging.Testing;
using Xunit;
@ -25,94 +26,102 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
public async Task ReturnsFileForDefaultPattern()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddRouting();
services.AddSingleton(LoggerFactory);
})
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
var environment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
app.UseRouting();
app.UseEndpoints(endpoints =>
webHostBuilder
.ConfigureServices(services =>
{
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()
{
FileProvider = new PhysicalFileProvider(Path.Combine(environment.WebRootPath, "SubFolder")),
endpoints.MapFallbackToFile("default.html", new StaticFileOptions()
{
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>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) })
{
var response = await client.GetAsync("hello");
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("Hello, world!", responseText);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hello, world!", responseText);
response = await client.GetAsync("/");
var responseContent = await response.Content.ReadAsByteArrayAsync();
response = await client.GetAsync("/");
var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "SubFolder/default.html", responseContent);
}
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "SubFolder/default.html", responseContent);
}
}
[Fact]
public async Task ReturnsFileForCustomPattern()
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
services.AddRouting();
services.AddSingleton(LoggerFactory);
})
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
webHostBuilder
.ConfigureServices(services =>
{
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>();
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(server)) })
{
var response = await client.GetAsync("hello");
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("Hello, world!", responseText);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hello, world!", responseText);
response = await client.GetAsync("prefix/Some-Path");
var responseContent = await response.Content.ReadAsByteArrayAsync();
response = await client.GetAsync("prefix/Some-Path");
var responseContent = await response.Content.ReadAsByteArrayAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "TestDocument.txt", responseContent);
}
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertFileEquals(environment, "TestDocument.txt", responseContent);
}
}

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

@ -3,15 +3,18 @@
using System.Linq;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.StaticFiles
{
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.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging.Testing;
using Xunit;
@ -28,84 +29,96 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
public async Task ReturnsNotFoundWithoutWwwroot()
{
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.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)) })
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
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]
public async Task Endpoint_PassesThrough()
{
var builder = new WebHostBuilder()
.ConfigureServices(services => { services.AddSingleton(LoggerFactory); services.AddRouting(); })
.UseKestrel()
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
// Routing first => static files noops
app.UseRouting();
app.Use(next => context =>
webHostBuilder
.ConfigureServices(services => { services.AddSingleton(LoggerFactory); services.AddRouting(); })
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(AppContext.BaseDirectory)
.Configure(app =>
{
// Assign an endpoint, this will make the default files noop.
context.SetEndpoint(new Endpoint((c) =>
// Routing first => static files noops
app.UseRouting();
app.Use(next => context =>
{
return context.Response.WriteAsync("Hi from endpoint.");
},
new EndpointMetadataCollection(),
"test"));
// Assign an endpoint, this will make the default files noop.
context.SetEndpoint(new Endpoint((c) =>
{
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 server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
using (var client = new HttpClient { BaseAddress = new Uri(Helpers.GetAddress(host)) })
{
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("Hi from endpoint.", await response.Content.ReadAsStringAsync());
}
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync());
}
}
[Fact]
public async Task FoundFile_LastModifiedTrimsSeconds()
{
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.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)) })
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
var last = File.GetLastWriteTimeUtc(Path.Combine(AppContext.BaseDirectory, "TestDocument.txt"));
var response = await client.GetAsync("TestDocument.txt");
webHostBuilder
.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)
{
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
RequestPath = new PathString(baseUrl),
}));
using (var server = builder.Start(TestUrlHelper.GetTestUrl(ServerType.Kestrel)))
{
var hostingEnvironment = server.Services.GetService<IWebHostEnvironment>();
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())
webHostBuilder
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseUrls(TestUrlHelper.GetTestUrl(ServerType.Kestrel))
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
{
var fileContents = new byte[stream.Length];
stream.Read(fileContents, 0, (int)stream.Length);
Assert.True(responseContent.SequenceEqual(fileContents));
}
RequestPath = new PathString(baseUrl),
}));
}).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))]
public async Task HeadFile_HeadersButNotBodyServed(string baseUrl, string baseDir, string requestUrl)
{
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseKestrel()
.UseWebRoot(Path.Combine(AppContext.BaseDirectory, baseDir))
.Configure(app => app.UseStaticFiles(new StaticFileOptions
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
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)) })
{
var fileInfo = hostingEnvironment.WebRootFileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var request = new HttpRequestMessage(HttpMethod.Head, requestUrl);
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()));
}
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 responseComplete = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
Exception exception = null;
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(LoggerFactory))
.UseWebRoot(Path.Combine(AppContext.BaseDirectory))
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
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);
await requestCancelled.Task.TimeoutAfter(interval);
Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");
await next();
}
catch (Exception ex)
{
exception = ex;
}
responseComplete.SetResult(0);
});
app.UseStaticFiles();
});
try
{
requestReceived.SetResult(0);
await requestCancelled.Task.TimeoutAfter(interval);
Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");
await next();
}
catch (Exception ex)
{
exception = ex;
}
responseComplete.SetResult(0);
});
app.UseStaticFiles();
})
.UseUrls(TestUrlHelper.GetTestUrl(serverType));
if (serverType == ServerType.HttpSys)
{
builder.UseHttpSys();
}
else if (serverType == ServerType.Kestrel)
{
builder.UseKestrel();
}
if (serverType == ServerType.HttpSys)
{
webHostBuilder.UseHttpSys();
}
else if (serverType == ServerType.Kestrel)
{
webHostBuilder.UseKestrel();
}
}).Build();
using (var server = builder.Start(TestUrlHelper.GetTestUrl(serverType)))
{
// 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);
await host.StartAsync();
socket.LingerState = new LingerOption(true, 0);
socket.Dispose();
requestCancelled.SetResult(0);
// We don't use HttpClient here because it's disconnect behavior varies across platforms.
var socket = SendSocketRequestAsync(Helpers.GetAddress(host), "/TestDocument1MB.txt");
await requestReceived.Task.TimeoutAfter(interval);
await responseComplete.Task.TimeoutAfter(interval);
Assert.Null(exception);
}
socket.LingerState = new LingerOption(true, 0);
socket.Dispose();
requestCancelled.SetResult(0);
await responseComplete.Task.TimeoutAfter(interval);
Assert.Null(exception);
}
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]
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");
Assert.NotNull(response.Headers.ETag);
@ -28,7 +29,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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 response2 = await server.CreateClient().GetAsync("http://localhost/SubFolder/extra.xml");
@ -47,7 +49,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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");
req.Headers.Add("If-Match", "\"fake\"");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -58,7 +61,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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");
var req = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -71,7 +75,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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");
req.Headers.Add("If-Match", "*");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -82,7 +87,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(UnsupportedMethods))]
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");
req.Headers.Add("If-Match", "*");
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -107,7 +113,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -120,7 +127,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -133,7 +141,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(UnsupportedMethods))]
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");
var req2 = new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml");
@ -156,7 +165,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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(
new HttpRequestMessage(method, "http://localhost/SubFolder/extra.xml"));
@ -179,7 +189,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method);
@ -198,7 +209,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method);
@ -223,7 +235,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method);
@ -271,7 +284,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -285,7 +299,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -306,7 +321,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -324,7 +340,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
.SendAsync(method.Method);
@ -351,7 +368,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -369,7 +387,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -383,7 +402,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.CreateRequest("/SubFolder/extra.xml")
@ -397,7 +417,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[MemberData(nameof(SupportedMethods))]
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
.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()
{
// 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.
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("/");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
@ -64,7 +66,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
@ -74,6 +76,7 @@ namespace Microsoft.AspNetCore.StaticFiles
});
app.Run(context => context.Response.WriteAsync(context.Request.Path.Value));
});
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync(requestUrl);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -86,7 +89,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, ".")))
{
var server = StaticFilesTestServer.Create(
using var host = await StaticFilesTestServer.Create(
app =>
{
app.UseRouting();
@ -113,6 +116,7 @@ namespace Microsoft.AspNetCore.StaticFiles
app.UseEndpoints(endpoints => { });
},
services => { services.AddDirectoryBrowser(); services.AddRouting(); });
using var server = host.GetTestServer();
var response = await server.CreateRequest("/SubFolder/").GetAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -165,7 +169,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
@ -175,6 +179,7 @@ namespace Microsoft.AspNetCore.StaticFiles
});
app.Run(context => context.Response.WriteAsync(context.Request.Path.Value));
});
using var server = host.GetTestServer();
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)))
{
var server = StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions
using var host = await StaticFilesTestServer.Create(app => app.UseDefaultFiles(new DefaultFilesOptions
{
RequestPath = new PathString(baseUrl),
FileProvider = fileProvider
}));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl + queryString).GetAsync();
Assert.Equal(HttpStatusCode.Moved, response.StatusCode);
@ -265,12 +271,13 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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),
FileProvider = fileProvider,
RedirectToAppendTrailingSlash = appendTrailingSlash
}));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync();
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
{
[Fact]
public void WorksWithoutEncoderRegistered()
public async Task WorksWithoutEncoderRegistered()
{
// No exception, uses HtmlEncoder.Default
StaticFilesTestServer.Create(
using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser());
}
@ -32,19 +32,24 @@ namespace Microsoft.AspNetCore.StaticFiles
public async Task NullArguments()
{
// No exception, default provided
StaticFilesTestServer.Create(
using (await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { Formatter = null }),
services => services.AddDirectoryBrowser());
services => services.AddDirectoryBrowser()))
{
}
// No exception, default provided
StaticFilesTestServer.Create(
using (await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions { FileProvider = null }),
services => services.AddDirectoryBrowser());
services => services.AddDirectoryBrowser()))
{
}
// PathString(null) is OK.
var server = StaticFilesTestServer.Create(
using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser((string)null),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -82,7 +87,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
RequestPath = new PathString(baseUrl),
@ -90,6 +95,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash
}),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
@ -100,7 +106,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
using (var fileProvider = new PhysicalFileProvider(Path.Combine(AppContext.BaseDirectory, ".")))
{
var server = StaticFilesTestServer.Create(
using var host = await StaticFilesTestServer.Create(
app =>
{
app.UseRouting();
@ -128,6 +134,7 @@ namespace Microsoft.AspNetCore.StaticFiles
app.UseEndpoints(endpoints => { });
},
services => { services.AddDirectoryBrowser(); services.AddRouting(); });
using var server = host.GetTestServer();
var response = await server.CreateRequest("/").GetAsync();
Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
@ -174,7 +181,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
RequestPath = new PathString(baseUrl),
@ -182,6 +189,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash,
}),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).GetAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -217,13 +225,14 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
RequestPath = new PathString(baseUrl),
FileProvider = fileProvider
}),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
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)))
{
var server = StaticFilesTestServer.Create(
using var host = await StaticFilesTestServer.Create(
app => app.UseDirectoryBrowser(new DirectoryBrowserOptions
{
RequestPath = new PathString(baseUrl),
@ -274,6 +283,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash
}),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).PostAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
@ -313,7 +323,7 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
{
RequestPath = new PathString(baseUrl),
@ -321,6 +331,7 @@ namespace Microsoft.AspNetCore.StaticFiles
RedirectToAppendTrailingSlash = appendTrailingSlash
}),
services => services.AddDirectoryBrowser());
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).SendAsync("HEAD");

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

@ -14,12 +14,13 @@ namespace Microsoft.AspNetCore.StaticFiles
public class RangeHeaderTests
{
// 14.27 If-Range
// If the entity tag given in the If-Range header matches the current entity tag for the entity, then the server SHOULD
// If the entity tag given in the If-Range header matches the current entity tag for the entity, then the server SHOULD
// provide the specified sub-range of the entity using a 206 (Partial content) response.
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -39,7 +40,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -59,7 +61,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -75,7 +78,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -91,7 +95,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -107,7 +112,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -127,7 +133,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
req.Headers.Add("If-Range", "\"OldEtag\"");
req.Headers.Add("Range", "bytes=0-10");
@ -143,7 +150,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
req.Headers.Add("If-Range", "\"OldEtag\"");
req.Headers.Add("Range", "bytes=0-10");
@ -159,7 +167,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -177,7 +186,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Head, "http://localhost/SubFolder/ranges.txt");
@ -191,12 +201,13 @@ namespace Microsoft.AspNetCore.StaticFiles
}
// 14.27 If-Range
// The If-Range header SHOULD only be used together with a Range header, and MUST be ignored if the request
// The If-Range header SHOULD only be used together with a Range header, and MUST be ignored if the request
// does not include a Range header, or if the server does not support the sub-range operation.
[Fact]
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");
var req = new HttpRequestMessage(HttpMethod.Get, "http://localhost/SubFolder/ranges.txt");
@ -222,7 +233,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
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");
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")]
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");
req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -276,7 +289,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("0-2", "0-0", 1, "A")]
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");
req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -296,7 +310,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("0-2")]
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");
req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -309,7 +324,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("10-35")]
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");
req.Headers.Add("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -326,7 +342,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("-0")] // Suffix range must be non-zero
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");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -340,7 +357,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("1000-1001")] // Out of 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");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -359,7 +377,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("a-b")]
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");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
HttpResponseMessage resp = await server.CreateClient().SendAsync(req);
@ -380,7 +399,8 @@ namespace Microsoft.AspNetCore.StaticFiles
[InlineData("a-b")]
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");
req.Headers.TryAddWithoutValidation("Range", "bytes=" + range);
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")]
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");
req.Headers.Add("Range", "bytes=" + ranges);
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.
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");
req.Headers.Add("Range", "bytes=" + range);
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.Testing;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Hosting;
using Moq;
using Xunit;
@ -26,9 +27,17 @@ namespace Microsoft.AspNetCore.StaticFiles
[Fact]
public async Task ReturnsNotFoundWithoutWwwroot()
{
var builder = new WebHostBuilder()
.Configure(app => app.UseStaticFiles());
var server = new TestServer(builder);
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app.UseStaticFiles());
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("/ranges.txt");
@ -47,10 +56,18 @@ namespace Microsoft.AspNetCore.StaticFiles
try
{
var builder = new WebHostBuilder()
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseTestServer()
.Configure(app => app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true }))
.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));
@ -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>()))
.ThrowsAsync(new FileNotFoundException());
mockSendFile.Setup(m => m.Stream).Returns(Stream.Null);
var builder = new WebHostBuilder()
.Configure(app =>
using var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
app.Use(async (ctx, next) =>
webHostBuilder
.UseTestServer()
.Configure(app =>
{
ctx.Features.Set(mockSendFile.Object);
await next();
});
app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true });
})
.UseWebRoot(AppContext.BaseDirectory);
var server = new TestServer(builder);
app.Use(async (ctx, next) =>
{
ctx.Features.Set(mockSendFile.Object);
await next();
});
app.UseStaticFiles(new StaticFileOptions { ServeUnknownFileTypes = true });
})
.UseWebRoot(AppContext.BaseDirectory);
}).Build();
await host.StartAsync();
var server = host.GetTestServer();
var response = await server.CreateClient().GetAsync("TestDocument.txt");
@ -94,10 +119,11 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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
}));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo("TestDocument.txt");
var response = await server.CreateRequest("TestDocument.txt").GetAsync();
@ -112,13 +138,16 @@ namespace Microsoft.AspNetCore.StaticFiles
public async Task NullArguments()
{
// 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
StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { FileProvider = null }));
using (await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions { FileProvider = null })))
{ }
// 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("/");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
@ -146,11 +175,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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),
FileProvider = fileProvider
}));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl));
var response = await server.CreateRequest(requestUrl).GetAsync();
var responseContent = await response.Content.ReadAsByteArrayAsync();
@ -176,11 +206,12 @@ namespace Microsoft.AspNetCore.StaticFiles
{
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),
FileProvider = fileProvider
}));
using var server = host.GetTestServer();
var fileInfo = fileProvider.GetFileInfo(Path.GetFileName(requestUrl));
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)))
{
var server = StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
using var host = await StaticFilesTestServer.Create(app => app.UseStaticFiles(new StaticFileOptions
{
RequestPath = new PathString(baseUrl),
FileProvider = fileProvider
}));
using var server = host.GetTestServer();
var response = await server.CreateRequest(requestUrl).SendAsync(method);
Assert.Null(response.Content.Headers.LastModified);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

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

@ -4,17 +4,19 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.StaticFiles
{
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 => { };
var configuration = new ConfigurationBuilder()
@ -23,11 +25,18 @@ namespace Microsoft.AspNetCore.StaticFiles
new KeyValuePair<string, string>("webroot", ".")
})
.Build();
var builder = new WebHostBuilder()
.UseConfiguration(configuration)
.Configure(configureApp)
.ConfigureServices(configureServices ?? defaultConfigureServices);
return new TestServer(builder);
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.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.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
namespace EchoApp
{
public class Program
{
public static void Main(string[] args)
public static Task Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
})
.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.IO;
using System.Net;
using System.Runtime.Loader;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace AutobahnTestApp
{
public class Program
{
public static void Main(string[] args)
public static Task Main(string[] args)
{
var scenarioName = "Unknown";
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var builder = new WebHostBuilder()
.ConfigureLogging(loggingBuilder => loggingBuilder.AddConsole())
.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(";"))
var builder = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
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);
builder.UseKestrel(options =>
{
options.Listen(IPAddress.Loopback, uri.Port, listenOptions =>
if (string.Equals(webHostBuilder.GetSetting("server"), "Microsoft.AspNetCore.Server.HttpSys", System.StringComparison.Ordinal))
{
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)";
var certPath = Path.Combine(AppContext.BaseDirectory, "TestResources", "testCert.pfx");
Console.WriteLine($"Using SSL with certificate: {certPath}");
listenOptions.UseHttps(certPath, "testPassword");
throw new NotSupportedException("This test app does not support multiple endpoints.");
}
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();
@ -80,7 +85,7 @@ namespace AutobahnTestApp
};
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.Logging;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Microsoft.AspNetCore.WebSockets.Test
{
@ -48,16 +49,19 @@ namespace Microsoft.AspNetCore.WebSockets.Test
var config = configBuilder.Build();
config["server.urls"] = $"http://127.0.0.1:0";
var host = new WebHostBuilder()
.ConfigureServices(s =>
var host = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
s.AddWebSockets(configure);
s.AddSingleton(loggerFactory);
})
.UseConfiguration(config)
.UseKestrel()
.Configure(startup)
.Build();
webHostBuilder
.ConfigureServices(s =>
{
s.AddWebSockets(configure);
s.AddSingleton(loggerFactory);
})
.UseConfiguration(config)
.UseKestrel()
.Configure(startup);
}).Build();
host.Start();
port = host.GetPort();