public async Task ShouldSupportIgnoreHTTPSErrorsOption()
{
await using (var originalBrowser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions()))
await using (var browser = await Puppeteer.ConnectAsync(new ConnectOptions
{
BrowserWSEndpoint = originalBrowser.WebSocketEndpoint,
IgnoreHTTPSErrors = true
}))
await using (var page = await browser.NewPageAsync())
{
var requestTask = HttpsServer.WaitForRequest(
"/empty.html",
request => request.HttpContext.Features.Get <ITlsHandshakeFeature>().Protocol);
var responseTask = page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html");
await Task.WhenAll(
requestTask,
responseTask);
var response = responseTask.Result;
Assert.True(response.Ok);
Assert.NotNull(response.SecurityDetails);
Assert.Equal(
TestUtils.CurateProtocol(requestTask.Result.ToString()),
TestUtils.CurateProtocol(response.SecurityDetails.Protocol));
}
}
public HttpsSession(HttpsServer server)
: base(server)
{
Cache = server.Cache;
Request = new HttpRequest();
Response = new HttpResponse();
}
public void Run(string bindAddress, ushort port)
{
httpsServer = new HttpsServer(SSLVerifyMode.None, "./ssl-cert/server.cer", "./ssl-cert/server.key", "123456", "./ssl-cert/ca.crt", null);
// 需要自己初始化ssl环境
httpsServer.Initialize();
httpsServer.IpAddress = bindAddress;
httpsServer.Port = port;
// 设置http服务器事件
httpsServer.OnMessageBegin += new HttpEvent.OnMessageBeginEventHandler(OnMessageBegin);
httpsServer.OnHeader += new HttpEvent.OnHeaderEventHandler(OnHeader);
httpsServer.OnChunkHeader += new HttpEvent.OnChunkHeaderEventHandler(OnChunkHeader);
httpsServer.OnChunkComplete += new HttpEvent.OnChunkCompleteEventHandler(OnChunkComplete);
httpsServer.OnUpgrade += new HttpEvent.OnUpgradeEventHandler(OnUpgrade);
httpsServer.OnRequestLine += new HttpServerEvent.OnRequestLineEventHandler(OnRequestLine);
httpsServer.OnHeadersComplete += new HttpEvent.OnHeadersCompleteEventHandler(OnHeadersComplete);
httpsServer.OnPointerDataBody += new HttpEvent.OnPointerDataBodyEventHandler(OnPointerDataBody);
httpsServer.OnMessageComplete += new HttpEvent.OnMessageCompleteEventHandler(OnMessageComplete);
httpsServer.OnParseError += new HttpEvent.OnParseErrorEventHandler(OnParseError);
if (!httpsServer.Start())
{
throw new MyException(string.Format("启动失败,错误码:{0},错误信息:{1}", httpsServer.ErrorCode, httpsServer.ErrorMessage));
}
}
public async Task NetworkRedirectsShouldReportSecurityDetails()
{
var responses = new List <Response>();
HttpsServer.SetRedirect("/plzredirect", "/empty.html");
Page.Response += (_, e) => responses.Add(e.Response);
var requestTask = HttpsServer.WaitForRequest(
"/empty.html",
request => request?.HttpContext?.Features?.Get <ITlsHandshakeFeature>()?.Protocol);
var responseTask = Page.GoToAsync(TestConstants.HttpsPrefix + "/plzredirect");
await Task.WhenAll(
requestTask,
responseTask).WithTimeout();
var response = responseTask.Result;
Assert.Equal(2, responses.Count);
Assert.Equal(HttpStatusCode.Found, responses[0].Status);
Assert.Equal(
TestUtils.CurateProtocol(requestTask.Result.ToString()),
TestUtils.CurateProtocol(response.SecurityDetails.Protocol));
}
public async Task NetworkRedirectsShouldReportSecurityDetails()
{
var responses = new List <Response>();
HttpsServer.SetRedirect("/plzredirect", "/empty.html");
Page.Response += (sender, e) => responses.Add(e.Response);
await Page.GoToAsync(TestConstants.HttpsPrefix + "/plzredirect");
Assert.Equal(2, responses.Count);
Assert.Equal(HttpStatusCode.Found, responses[0].Status);
Assert.Equal("TLS 1.2", responses[0].SecurityDetails.Protocol);
}
public async Task ShouldWorkWithMixedContent()
{
HttpsServer.SetRoute("/mixedcontent.html", async(context) =>
{
await context.Response.WriteAsync($"<iframe src='{TestConstants.EmptyPage}'></iframe>");
});
await using var context = await Browser.NewContextAsync(new BrowserContextOptions { IgnoreHTTPSErrors = true });
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.HttpsPrefix + "/mixedcontent.html", LifecycleEvent.DOMContentLoaded);
Assert.Equal(2, page.Frames.Length);
Assert.Equal(3, await page.MainFrame.EvaluateAsync <int>("1 + 2"));
Assert.Equal(5, await page.FirstChildFrame().EvaluateAsync <int>("2 + 3"));
}
public async Task ShouldWorkWithMixedContent()
{
HttpsServer.SetRoute("/mixedcontent.html", async(context) =>
{
await context.Response.WriteAsync($"<iframe src='{Server.EmptyPage}'></iframe>");
});
await using var context = await Browser.NewContextAsync(new() { IgnoreHTTPSErrors = true });
var page = await context.NewPageAsync();
await page.GotoAsync(HttpsServer.Prefix + "/mixedcontent.html", new() { WaitUntil = WaitUntilState.DOMContentLoaded });
Assert.AreEqual(2, page.Frames.Count);
Assert.AreEqual(3, await page.MainFrame.EvaluateAsync <int>("1 + 2"));
Assert.AreEqual(5, await page.FirstChildFrame().EvaluateAsync <int>("2 + 3"));
}
public async Task ShouldWorkWithMixedContent()
{
HttpsServer.SetRoute("/mixedcontent.html", async(context) =>
{
await context.Response.WriteAsync($"<iframe src='{TestConstants.EmptyPage}'></iframe>");
});
var page = await NewPageAsync(new BrowserContextOptions { IgnoreHTTPSErrors = true });
await page.GoToAsync(TestConstants.HttpsPrefix + "/mixedcontent.html", new GoToOptions
{
WaitUntil = new[] { WaitUntilNavigation.Load }
});
Assert.Equal(2, page.Frames.Length);
Assert.Equal(3, await page.MainFrame.EvaluateAsync <int>("1 + 2"));
Assert.Equal(5, await page.FirstChildFrame().EvaluateAsync <int>("2 + 3"));
}
public async Task ShouldWork()
{
var page = await NewPageAsync(new BrowserContextOptions { IgnoreHTTPSErrors = true });
var requestTask = HttpsServer.WaitForRequest(
"/empty.html",
request => request.HttpContext.Features.Get <ITlsHandshakeFeature>().Protocol);
var responseTask = page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html");
await Task.WhenAll(
requestTask,
responseTask);
var response = responseTask.Result;
Assert.Equal(HttpStatusCode.OK, response.Status);
}
public async Task ShouldWorkWithMixedContent()
{
HttpsServer.SetRoute("/mixedcontent.html", async(context) =>
{
await context.Response.WriteAsync($"<iframe src='{TestConstants.EmptyPage}'></iframe>");
});
await Page.GoToAsync(TestConstants.HttpsPrefix + "/mixedcontent.html", new NavigationOptions
{
WaitUntil = new[] { WaitUntilNavigation.Load }
});
Assert.Equal(2, Page.Frames.Length);
// Make sure blocked iframe has functional execution context
// @see https://github.com/GoogleChrome/puppeteer/issues/2709
Assert.Equal(3, await Page.MainFrame.EvaluateExpressionAsync <int>("1 + 2"));
Assert.Equal(5, await Page.FirstChildFrame().EvaluateExpressionAsync <int>("2 + 3"));
}
public async Task ShouldWorkWithWebSocket()
{
HttpsServer.SendOnWebSocketConnection("incoming");
await using var context = await Browser.NewContextAsync(new() { IgnoreHTTPSErrors = true });
var page = await context.NewPageAsync();
string value = await page.EvaluateAsync <string>(@"endpoint => {
let cb;
const result = new Promise(f => cb = f);
const ws = new WebSocket(endpoint);
ws.addEventListener('message', data => { ws.close(); cb(data.data); });
ws.addEventListener('error', error => cb('Error'));
return result;
}", HttpsServer.Prefix.Replace("https", "wss") + "/ws");
Assert.AreEqual("incoming", value);
}
public async Task ShouldWork()
{
var requestTask = HttpsServer.WaitForRequest(
"/empty.html",
request => request?.HttpContext?.Features?.Get <ITlsHandshakeFeature>()?.Protocol);
var responseTask = Page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html");
await Task.WhenAll(
requestTask,
responseTask).WithTimeout();
var response = responseTask.Result;
Assert.Equal(HttpStatusCode.OK, response.Status);
Assert.NotNull(response.SecurityDetails);
Assert.Equal(
TestUtils.CurateProtocol(requestTask.Result.ToString()),
TestUtils.CurateProtocol(response.SecurityDetails.Protocol));
}
public async Task NetworkRedirectsShouldReportSecurityDetails()
{
var responses = new List <Response>();
var options = TestConstants.DefaultBrowserOptions();
options.IgnoreHTTPSErrors = true;
HttpsServer.SetRedirect("/plzredirect", "/empty.html");
using (var browser = await Puppeteer.LaunchAsync(options, TestConstants.LoggerFactory))
using (var page = await browser.NewPageAsync())
{
page.Response += (sender, e) => responses.Add(e.Response);
await page.GoToAsync(TestConstants.HttpsPrefix + "/plzredirect");
Assert.Equal(2, responses.Count);
Assert.Equal(HttpStatusCode.Found, responses[0].Status);
Assert.Equal("TLS 1.2", responses[0].SecurityDetails.Protocol);
}
}
static async Task Main(string[] args)
{
var httpServer = new HttpsServer(1234);
await httpServer.StartAsync();
}
public HttpsCacheSession(HttpsServer server) : base(server)
{
}
public HttpsTraceSession(HttpsServer server) : base(server)
{
}
