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

Enable all tests in HttpsConnectionFilterTests to run on all platforms 

- Move HttpClientSlim.cs to test\shared
- Change HttpClientSlim to static class to simplify calling code
- Add HttpClientSlim.PostAsync()
This commit is contained in:
Mike Harder 2016-07-18 12:38:19 -07:00 committed by GitHub
parent 8399910a6e
commit 41e50ba688
9 changed files with 278 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
KestrelHttpServer.sln
View File

@ -1,6 +1,6 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.25123.0
VisualStudioVersion = 14.0.25420.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.AspNetCore.Server.Kestrel", "src\Microsoft.AspNetCore.Server.Kestrel\Microsoft.AspNetCore.Server.Kestrel.xproj", "{F510611A-3BEE-4B88-A613-5F4A74ED82A1}"
EndProject
@ -32,6 +32,11 @@ Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.AspNetCore.Server
EndProject
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.AspNetCore.Server.Kestrel.FunctionalTests", "test\Microsoft.AspNetCore.Server.Kestrel.FunctionalTests\Microsoft.AspNetCore.Server.Kestrel.FunctionalTests.xproj", "{9559A5F1-080C-4909-B6CF-7E4B3DC55748}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "shared", "shared", "{0EF2ACDF-012F-4472-A13A-4272419E2903}"
ProjectSection(SolutionItems) = preProject
test\shared\HttpClientSlim.cs = test\shared\HttpClientSlim.cs
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -78,5 +83,6 @@ Global
{BD2D4D29-1BD9-40D0-BB31-337D5416B63C} = {327F7880-D9AF-46BD-B45C-3B7E34A01DFD}
{5F64B3C3-0C2E-431A-B820-A81BBFC863DA} = {2D5D5227-4DBD-499A-96B1-76A36B03B750}
{9559A5F1-080C-4909-B6CF-7E4B3DC55748} = {D3273454-EA07-41D2-BF0B-FCC3675C2483}
{0EF2ACDF-012F-4472-A13A-4272419E2903} = {D3273454-EA07-41D2-BF0B-FCC3675C2483}
EndGlobalSection
EndGlobal

4
test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/AddressRegistrationTests.cs
View File

@ -14,6 +14,7 @@ using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.Server.Kestrel.Internal.Networking;
using Microsoft.AspNetCore.Testing;
using Microsoft.AspNetCore.Testing.xunit;
using Xunit;
@ -85,10 +86,9 @@ namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
{
host.Start();
var client = new HttpClientSlim() { ValidateCertificate = false };
foreach (var testUrl in testUrls(host.ServerFeatures.Get<IServerAddressesFeature>()))
{
var response = await client.GetStringAsync(testUrl);
var response = await HttpClientSlim.GetStringAsync(testUrl, validateCertificate: false);
// Compare the response with Uri.ToString(), rather than testUrl directly.
// Required to handle IPv6 addresses with zone index, like "fe80::3%1"

88
test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/HttpClientSlim.cs
View File

@ -1,88 +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.IO;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Threading.Tasks;
namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
{
// Lightweight version of HttpClient implemented using Socket and SslStream
public class HttpClientSlim
{
public bool ValidateCertificate { get; set; } = true;
public Task<string> GetStringAsync(string requestUri) => GetStringAsync(new Uri(requestUri));
public async Task<string> GetStringAsync(Uri requestUri)
{
using (var stream = await GetStream(requestUri))
{
using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true))
{
await writer.WriteAsync($"GET {requestUri.PathAndQuery} HTTP/1.0\r\n");
await writer.WriteAsync($"Host: {requestUri.Authority}\r\n");
await writer.WriteAsync("\r\n");
}
using (var reader = new StreamReader(stream, Encoding.ASCII))
{
var response = await reader.ReadToEndAsync();
var body = response.Substring(response.IndexOf("\r\n\r\n") + 4);
return body;
}
}
}
private async Task<Stream> GetStream(Uri requestUri)
{
var socket = await GetSocket(requestUri);
Stream stream = new NetworkStream(socket, ownsSocket: true);
if (requestUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
var sslStream = new SslStream(stream, leaveInnerStreamOpen: false, userCertificateValidationCallback:
ValidateCertificate ? null : (RemoteCertificateValidationCallback)((a, b, c, d) => true));
await sslStream.AuthenticateAsClientAsync(requestUri.Host, clientCertificates: null,
enabledSslProtocols: SslProtocols.Tls11 | SslProtocols.Tls12,
checkCertificateRevocation: ValidateCertificate);
return sslStream;
}
else
{
return stream;
}
}
private static async Task<Socket> GetSocket(Uri requestUri)
{
var tcs = new TaskCompletionSource<Socket>();
var socketArgs = new SocketAsyncEventArgs();
socketArgs.RemoteEndPoint = new DnsEndPoint(requestUri.DnsSafeHost, requestUri.Port);
socketArgs.Completed += (s, e) => tcs.TrySetResult(e.ConnectSocket);
// Must use static ConnectAsync(), since instance Connect() does not support DNS names on OSX/Linux.
if (Socket.ConnectAsync(SocketType.Stream, ProtocolType.Tcp, socketArgs))
{
await tcs.Task;
}
var socket = socketArgs.ConnectSocket;
if (socket == null)
{
throw new SocketException((int)socketArgs.SocketError);
}
else
{
return socket;
}
}
}
}

106
test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/HttpClientSlimTests.cs Normal file
View File

@ -0,0 +1,106 @@
// 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.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Testing;
using Xunit;
namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
{
public class HttpClientSlimTests
{
[Fact]
public async Task GetStringAsyncHttp()
{
using (var host = StartHost())
{
Assert.Equal("test", await HttpClientSlim.GetStringAsync(host.GetUri()));
}
}
[Fact]
public async Task GetStringAsyncHttps()
{
using (var host = StartHost(protocol: "https"))
{
Assert.Equal("test", await HttpClientSlim.GetStringAsync(host.GetUri(), validateCertificate: false));
}
}
[Fact]
public async Task GetStringAsyncThrowsForErrorResponse()
{
using (var host = StartHost(statusCode: 500))
{
await Assert.ThrowsAnyAsync<HttpRequestException>(() => HttpClientSlim.GetStringAsync(host.GetUri()));
}
}
[Fact]
public async Task PostAsyncHttp()
{
using (var host = StartHost(handler: (context) => context.Request.Body.CopyToAsync(context.Response.Body)))
{
Assert.Equal("test post", await HttpClientSlim.PostAsync(host.GetUri(), new StringContent("test post")));
}
}
[Fact]
public async Task PostAsyncHttps()
{
using (var host = StartHost(protocol: "https",
handler: (context) => context.Request.Body.CopyToAsync(context.Response.Body)))
{
Assert.Equal("test post", await HttpClientSlim.PostAsync(host.GetUri(),
new StringContent("test post"), validateCertificate: false));
}
}
[Fact]
public async Task PostAsyncThrowsForErrorResponse()
{
using (var host = StartHost(statusCode: 500))
{
await Assert.ThrowsAnyAsync<HttpRequestException>(
() => HttpClientSlim.PostAsync(host.GetUri(), new StringContent("")));
}
}
private IWebHost StartHost(string protocol = "http", int statusCode = 200, Func<HttpContext, Task> handler = null)
{
var host = new WebHostBuilder()
.UseUrls($"{protocol}://127.0.0.1:0")
.UseKestrel(options =>
{
options.UseHttps(@"TestResources/testCert.pfx", "testPassword");
})
.Configure((app) =>
{
app.Run(context =>
{
context.Response.StatusCode = statusCode;
if (handler == null)
{
return context.Response.WriteAsync("test");
}
else
{
return handler(context);
}
});
})
.Build();
host.Start();
return host;
}
}
}

7
test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/IWebHostPortExtensions.cs
View File

@ -12,7 +12,7 @@ namespace Microsoft.AspNetCore.Hosting
{
public static string GetHost(this IWebHost host)
{
return host.GetUris().First().Host;
return host.GetUri().Host;
}
public static int GetPort(this IWebHost host)
@ -40,5 +40,10 @@ namespace Microsoft.AspNetCore.Hosting
.Select(a => a.Replace("://+", "://localhost"))
.Select(a => new Uri(a));
}
public static Uri GetUri(this IWebHost host)
{
return host.GetUris().First();
}
}
}

5
test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/project.json
View File

@ -31,6 +31,11 @@
},
"buildOptions": {
"allowUnsafe": true,
"compile": {
"include": [
"../shared/**/*.cs"
]
},
"copyToOutput": {
"include": "TestResources/testCert.pfx"
}

94
test/Microsoft.AspNetCore.Server.KestrelTests/HttpsConnectionFilterTests.cs
View File

@ -4,7 +4,6 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Security;
using System.Net.Sockets;
@ -17,47 +16,19 @@ using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.Kestrel.Filter;
using Microsoft.AspNetCore.Server.Kestrel.Https;
using Microsoft.AspNetCore.Server.Kestrel.Internal.Infrastructure;
using Microsoft.AspNetCore.Testing.xunit;
using Microsoft.AspNetCore.Testing;
using Xunit;
namespace Microsoft.AspNetCore.Server.KestrelTests
{
public class HttpsConnectionFilterTests : IDisposable
public class HttpsConnectionFilterTests
{
private static string _serverAddress = "https://127.0.0.1:0/";
private static RemoteCertificateValidationCallback _alwaysValidCallback =
(sender, cert, chain, sslPolicyErrors) => true;
private static X509Certificate2 _x509Certificate2 = new X509Certificate2(@"TestResources/testCert.pfx", "testPassword");
#if NET451
static HttpsConnectionFilterTests()
{
// SecurityProtocolType values below not available in Mono < 4.3
const int SecurityProtocolTypeTls11 = 768;
const int SecurityProtocolTypeTls12 = 3072;
ServicePointManager.SecurityProtocol |= (SecurityProtocolType)(SecurityProtocolTypeTls12 | SecurityProtocolTypeTls11);
}
#endif
public HttpsConnectionFilterTests()
{
#if NET451
ServicePointManager.ServerCertificateValidationCallback += _alwaysValidCallback;
#endif
}
public void Dispose()
{
#if NET451
ServicePointManager.ServerCertificateValidationCallback -= _alwaysValidCallback;
#endif
}
// https://github.com/aspnet/KestrelHttpServer/issues/240
// This test currently fails on mono because of an issue with SslStream.
[ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux, SkipReason = "WinHttpHandler not available on non-Windows.")]
[OSSkipCondition(OperatingSystems.MacOSX, SkipReason = "WinHttpHandler not available on non-Windows.")]
[Fact]
public async Task CanReadAndWriteWithHttpsConnectionFilter()
{
var serviceContext = new TestServiceContext(new HttpsConnectionFilter(
@ -68,20 +39,17 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
using (var server = new TestServer(App, serviceContext, _serverAddress))
{
using (var client = new HttpClient(GetHandler()))
{
var result = await client.PostAsync($"https://localhost:{server.Port}/", new FormUrlEncodedContent(new[] {
new KeyValuePair<string, string>("content", "Hello World?")
}));
var result = await HttpClientSlim.PostAsync($"https://localhost:{server.Port}/",
new FormUrlEncodedContent(new[] {
new KeyValuePair<string, string>("content", "Hello World?")
}),
validateCertificate: false);
Assert.Equal("content=Hello+World%3F", await result.Content.ReadAsStringAsync());
}
Assert.Equal("content=Hello+World%3F", result);
}
}
[ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux, SkipReason = "WinHttpHandler not available on non-Windows.")]
[OSSkipCondition(OperatingSystems.MacOSX, SkipReason = "WinHttpHandler not available on non-Windows.")]
[Fact]
public async Task RequireCertificateFailsWhenNoCertificate()
{
var serviceContext = new TestServiceContext(new HttpsConnectionFilter(
@ -95,17 +63,12 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
using (var server = new TestServer(App, serviceContext, _serverAddress))
{
using (var client = new HttpClient(GetHandler()))
{
await Assert.ThrowsAnyAsync<Exception>(
() => client.GetAsync($"https://localhost:{server.Port}/"));
}
await Assert.ThrowsAnyAsync<Exception>(
() => HttpClientSlim.GetStringAsync($"https://localhost:{server.Port}/"));
}
}
[ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux, SkipReason = "WinHttpHandler not available on non-Windows.")]
[OSSkipCondition(OperatingSystems.MacOSX, SkipReason = "WinHttpHandler not available on non-Windows.")]
[Fact]
public async Task AllowCertificateContinuesWhenNoCertificate()
{
var serviceContext = new TestServiceContext(new HttpsConnectionFilter(
@ -124,12 +87,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
},
serviceContext, _serverAddress))
{
using (var client = new HttpClient(GetHandler()))
{
var result = await client.GetAsync($"https://localhost:{server.Port}/");
Assert.Equal("hello world", await result.Content.ReadAsStringAsync());
}
var result = await HttpClientSlim.GetStringAsync($"https://localhost:{server.Port}/", validateCertificate: false);
Assert.Equal("hello world", result);
}
}
@ -203,9 +162,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
}
}
[ConditionalFact]
[OSSkipCondition(OperatingSystems.Linux, SkipReason = "WinHttpHandler not available on non-Windows.")]
[OSSkipCondition(OperatingSystems.MacOSX, SkipReason = "WinHttpHandler not available on non-Windows.")]
[Fact]
public async Task HttpsSchemePassedToRequestFeature()
{
var serviceContext = new TestServiceContext(
@ -219,12 +176,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
using (var server = new TestServer(context => context.Response.WriteAsync(context.Request.Scheme), serviceContext, _serverAddress))
{
using (var client = new HttpClient(GetHandler()))
{
var result = await client.GetAsync($"https://localhost:{server.Port}/");
Assert.Equal("https", await result.Content.ReadAsStringAsync());
}
var result = await HttpClientSlim.GetStringAsync($"https://localhost:{server.Port}/", validateCertificate: false);
Assert.Equal("https", result);
}
}
@ -423,16 +376,5 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
Assert.Null(line);
}
}
private HttpMessageHandler GetHandler()
{
#if NET451
return new HttpClientHandler();
#else
var handler = new WinHttpHandler();
handler.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
return handler;
#endif
}
}
}

5
test/Microsoft.AspNetCore.Server.KestrelTests/project.json
View File

@ -33,6 +33,11 @@
},
"buildOptions": {
"allowUnsafe": true,
"compile": {
"include": [
"../shared/**/*.cs"
]
},
"keyFile": "../../tools/Key.snk",
"copyToOutput": {
"include": "TestResources/testCert.pfx"

129
test/shared/HttpClientSlim.cs Normal file
View File

@ -0,0 +1,129 @@
// 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.IO;
using System.Net;
using System.Net.Http;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Threading.Tasks;
namespace Microsoft.AspNetCore.Testing
{
// Lightweight version of HttpClient implemented using Socket and SslStream
public static class HttpClientSlim
{
public static Task<string> GetStringAsync(string requestUri, bool validateCertificate = true)
=> GetStringAsync(new Uri(requestUri), validateCertificate);
public static async Task<string> GetStringAsync(Uri requestUri, bool validateCertificate = true)
{
using (var stream = await GetStream(requestUri, validateCertificate))
{
using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true))
{
await writer.WriteAsync($"GET {requestUri.PathAndQuery} HTTP/1.0\r\n");
await writer.WriteAsync($"Host: {requestUri.Authority}\r\n");
await writer.WriteAsync("\r\n");
}
return await ReadResponse(stream);
}
}
public static Task<string> PostAsync(string requestUri, HttpContent content, bool validateCertificate = true)
=> PostAsync(new Uri(requestUri), content, validateCertificate);
public static async Task<string> PostAsync(Uri requestUri, HttpContent content, bool validateCertificate = true)
{
using (var stream = await GetStream(requestUri, validateCertificate))
{
using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1024, leaveOpen: true))
{
await writer.WriteAsync($"POST {requestUri.PathAndQuery} HTTP/1.0\r\n");
await writer.WriteAsync($"Host: {requestUri.Authority}\r\n");
await writer.WriteAsync($"Content-Type: {content.Headers.ContentType}\r\n");
await writer.WriteAsync($"Content-Length: {content.Headers.ContentLength}\r\n");
await writer.WriteAsync("\r\n");
}
await content.CopyToAsync(stream);
return await ReadResponse(stream);
}
}
private static async Task<string> ReadResponse(Stream stream)
{
using (var reader = new StreamReader(stream, Encoding.ASCII, detectEncodingFromByteOrderMarks: true,
bufferSize: 1024, leaveOpen: true))
{
var response = await reader.ReadToEndAsync();
var status = GetStatus(response);
new HttpResponseMessage(status).EnsureSuccessStatusCode();
var body = response.Substring(response.IndexOf("\r\n\r\n") + 4);
return body;
}
}
private static HttpStatusCode GetStatus(string response)
{
var statusStart = response.IndexOf(' ') + 1;
var statusEnd = response.IndexOf(' ', statusStart) - 1;
var statusLength = statusEnd - statusStart + 1;
return (HttpStatusCode)int.Parse(response.Substring(statusStart, statusLength));
}
private static async Task<Stream> GetStream(Uri requestUri, bool validateCertificate)
{
var socket = await GetSocket(requestUri);
Stream stream = new NetworkStream(socket, ownsSocket: true);
if (requestUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
var sslStream = new SslStream(stream, leaveInnerStreamOpen: false, userCertificateValidationCallback:
validateCertificate ? null : (RemoteCertificateValidationCallback)((a, b, c, d) => true));
await sslStream.AuthenticateAsClientAsync(requestUri.Host, clientCertificates: null,
enabledSslProtocols: SslProtocols.Tls11 | SslProtocols.Tls12,
checkCertificateRevocation: validateCertificate);
return sslStream;
}
else
{
return stream;
}
}
private static async Task<Socket> GetSocket(Uri requestUri)
{
var tcs = new TaskCompletionSource<Socket>();
var socketArgs = new SocketAsyncEventArgs();
socketArgs.RemoteEndPoint = new DnsEndPoint(requestUri.DnsSafeHost, requestUri.Port);
socketArgs.Completed += (s, e) => tcs.TrySetResult(e.ConnectSocket);
// Must use static ConnectAsync(), since instance Connect() does not support DNS names on OSX/Linux.
if (Socket.ConnectAsync(SocketType.Stream, ProtocolType.Tcp, socketArgs))
{
await tcs.Task;
}
var socket = socketArgs.ConnectSocket;
if (socket == null)
{
throw new SocketException((int)socketArgs.SocketError);
}
else
{
return socket;
}
}
}
}