public async Task ShouldNotBlockThirdPartyCookies() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetHeadfulOptions()); var page = await browser.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); await page.EvaluateAsync(@"src => { let fulfill; const promise = new Promise(x => fulfill = x); const iframe = document.createElement('iframe'); document.body.appendChild(iframe); iframe.onload = fulfill; iframe.src = src; return promise; }", TestConstants.CrossProcessUrl + "/grid.html"); string documentCookie = await page.Frames[1].EvaluateAsync <string>(@"() => { document.cookie = 'username=John Doe'; return document.cookie; }"); await page.WaitForTimeoutAsync(2000); bool allowsThirdParty = TestConstants.IsChromium || TestConstants.IsFirefox; Assert.Equal(allowsThirdParty ? "username=John Doe" : string.Empty, documentCookie); var cookies = await page.Context.GetCookiesAsync(TestConstants.CrossProcessUrl + "/grid.html"); if (allowsThirdParty) { Assert.Single(cookies); var cookie = cookies.First(); Assert.Equal("127.0.0.1", cookie.Domain); Assert.Equal(cookie.Expires, -1); Assert.False(cookie.HttpOnly); Assert.Equal("username", cookie.Name); Assert.Equal("/", cookie.Path); Assert.Equal(SameSite.None, cookie.SameSite); Assert.False(cookie.Secure); Assert.Equal("John Doe", cookie.Value); } else { Assert.Empty(cookies); } }
public async Task ShouldLoadOopifIframesWithSubresourcesAndRequestInterception() { var options = TestConstants.GetDefaultBrowserOptions(); options.Args = options.Args.Prepend("--site-per-process").ToArray(); await using var browser = await BrowserType.LaunchAsync(options); var page = await browser.DefaultContext.NewPageAsync(); await page.SetRequestInterceptionAsync(true); page.Request += (sender, e) => _ = e.Request.ContinueAsync(); await page.GoToAsync(TestConstants.ServerUrl + "/dynamic-oopif.html"); Assert.Single(browser.GetTargets().Where(target => target.Type == TargetType.IFrame)); }
public async Task ShouldWorkWithIgnoreDefaultArgs() { var options = TestConstants.GetDefaultBrowserOptions(); options.IgnoreAllDefaultArgs = true; options.Args = new[] { "--remote-debugging-pipe", "--headless", "--hide-scrollbars", "--mute-audio", "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4" }; await using var browser = await BrowserType.LaunchAsync(options); }
public async Task ShouldUseProxy() { Server.SetRoute("/target.html", ctx => ctx.Response.WriteAsync("<html><title>Served by the proxy</title></html>")); var proxy = new Proxy { Server = $"localhost:{TestConstants.Port}" }; await using var browser = await BrowserType.LaunchAsync(proxy : proxy); var page = await browser.NewPageAsync(); await page.GoToAsync("http://non-existent.com/target.html"); Assert.Equal("Served by the proxy", await page.TitleAsync()); }
public async Task ShouldPassFirefoxUserPreferences() { var firefoxUserPrefs = new Dictionary <string, object> { ["network.proxy.type"] = 1, ["network.proxy.http"] = "127.0.0.1", ["network.proxy.http_port"] = 333, }; await using var browser = await BrowserType.LaunchAsync(new BrowserTypeLaunchOptions { FirefoxUserPrefs = firefoxUserPrefs }); var page = await browser.NewPageAsync(); var exception = await Assert.ThrowsAnyAsync <PlaywrightException>(() => page.GotoAsync("http://example.com")); Assert.Contains("NS_ERROR_PROXY_CONNECTION_REFUSED", exception.Message); }
public async Task ShouldWorkWithRequestInterception() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var context = await browser.NewContextAsync(new BrowserContextOptions { IgnoreHTTPSErrors = true }); var page = await context.NewPageAsync(); await page.RouteAsync("**/*", (route, request) => route.ContinueAsync()); var response = await page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html"); Assert.Equal(HttpStatusCode.OK, response.Status); }
public async Task ShouldReturnAllOfThePages() { Server.SetRoute("/target.html", ctx => ctx.Response.WriteAsync("<html><title>Served by the proxy</title></html>")); var defaultBrowserOptions = TestConstants.GetDefaultBrowserOptions(); defaultBrowserOptions.Proxy = new ProxySettings { Server = $"localhost:{TestConstants.Port}" }; await using var browser = await BrowserType.LaunchAsync(defaultBrowserOptions); var page = await browser.NewPageAsync(); await page.GoToAsync("http://non-existent.com/target.html"); Assert.Equal("Served by the proxy", await page.GetTitleAsync()); }
public async Task ShouldReportDownloadsWithInterception() { var browser = await BrowserType.LaunchAsync(); var page = await browser.NewPageAsync(new() { AcceptDownloads = true }); await page.RouteAsync("*", r => r.ContinueAsync()); await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>"); var download = await page.RunAndWaitForDownloadAsync(() => page.ClickAsync("a")); var path = await download.PathAsync(); Assert.IsTrue(File.Exists(path)); await page.CloseAsync(); }
public async Task ShouldBeAbleToCancelPendingDownload() { var browser = await BrowserType.LaunchAsync(); var page = await browser.NewPageAsync(new() { AcceptDownloads = true }); await page.SetContentAsync($"<a href=\"{Server.Prefix}/downloadWithDelay\">download</a>"); var download = await page.RunAndWaitForDownloadAsync(() => page.ClickAsync("a")); await download.CancelAsync(); var failure = await download.FailureAsync(); Assert.AreEqual("canceled", failure); await page.CloseAsync(); }
public async Task ShouldPropagateDefaultViewportToThePage() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var page = await NewPageAsync(browser, new BrowserContextOptions { Viewport = new Viewport { Width = 456, Height = 789 } }); Assert.Equal(456, page.Viewport.Width); Assert.Equal(789, page.Viewport.Height); Assert.Equal(456, await page.EvaluateAsync <int>("window.innerWidth")); Assert.Equal(789, await page.EvaluateAsync <int>("window.innerHeight")); }
public async Task HeadlessShouldBeAbleToReadCookiesWrittenByHeadful() { // "Too" complex for our skip attribute if ((TestConstants.IsWindows && TestConstants.IsChromium) || TestConstants.IsFirefox) { return; } using var userDataDir = new TempDirectory(); // Write a cookie in headful chrome var headfulOptions = TestConstants.GetHeadfulOptions(); headfulOptions.UserDataDir = userDataDir.Path; var headfulBrowser = await BrowserType.LaunchAsync(headfulOptions); var headfulPage = await headfulBrowser.DefaultContext.NewPageAsync(); await headfulPage.GoToAsync(TestConstants.EmptyPage); await headfulPage.EvaluateAsync("() => document.cookie = 'foo=true; expires=Fri, 31 Dec 9999 23:59:59 GMT'"); await headfulBrowser.CloseAsync(); // Read the cookie from headless chrome var headlessOptions = TestConstants.GetDefaultBrowserOptions(); headlessOptions.UserDataDir = userDataDir.Path; var headlessBrowser = await BrowserType.LaunchAsync(headlessOptions); var headlessPage = await headlessBrowser.DefaultContext.NewPageAsync(); await headlessPage.GoToAsync(TestConstants.EmptyPage); string cookie = await headlessPage.EvaluateAsync <string>("() => document.cookie"); await headlessBrowser.CloseAsync(); Assert.Equal("foo=true", cookie); }
public async Task ShouldWork() { var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var events = new List <string>(); browser.TargetCreated += (sender, e) => events.Add("CREATED: " + e.Target.Url); browser.TargetChanged += (sender, e) => events.Add("CHANGED: " + e.Target.Url); browser.TargetDestroyed += (sender, e) => events.Add("DESTROYED: " + e.Target.Url); var page = await browser.DefaultContext.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); await page.CloseAsync(); Assert.Equal(new[] { $"CREATED: {TestConstants.AboutBlank}", $"CHANGED: {TestConstants.EmptyPage}", $"DESTROYED: {TestConstants.EmptyPage}" }, events); await browser.CloseAsync(); }
public async Task WindowOpenShouldUseParentTabContext() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var context = await browser.NewContextAsync(); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); var popupTargetCompletion = new TaskCompletionSource <IPage>(); page.Popup += (sender, e) => popupTargetCompletion.SetResult(e.Page); var(popupTarget, _) = await TaskUtils.WhenAll( popupTargetCompletion.Task, page.EvaluateAsync("url => window.open(url)", TestConstants.EmptyPage) ); Assert.Same(context, popupTarget.BrowserContext); await context.CloseAsync(); }
public async Task ShouldTakeFullPageScreenshotsWhenDefaultViewportIsNull() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var page = await NewPageAsync(browser, new BrowserContextOptions { Viewport = null }); await page.GoToAsync(TestConstants.EmptyPage + "/grid.html"); var sizeBefore = await page.EvaluateAsync <Viewport>("() => ({ width: document.body.offsetWidth, height: document.body.offsetHeight })"); byte[] screenshot = await page.ScreenshotAsync(new ScreenshotOptions { FullPage = true }); Assert.NotEmpty(screenshot); var sizeAfter = await page.EvaluateAsync <Viewport>("() => ({ width: document.body.offsetWidth, height: document.body.offsetHeight })"); Assert.Equal(sizeBefore, sizeAfter); }
public async Task ShouldReportGoogleComFrameWithHeadful() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetHeadfulOptions()); var page = await browser.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); await page.RouteAsync("**/*", (route, _) => route.FulfillAsync(body: "YO, GOOGLE.COM")); await page.EvaluateAsync(@"() => { const frame = document.createElement('iframe'); frame.setAttribute('src', 'https://google.com/'); document.body.appendChild(frame); return new Promise(x => frame.onload = x); }"); await page.WaitForSelectorAsync("iframe[src=\"https://google.com/\"]"); Assert.Equal(1, await CountOOPIFsASync(browser)); var urls = page.Frames.Select(f => f.Url); Assert.Equal(new[] { TestConstants.EmptyPage, "https://google.com/" }, urls.ToArray()); }
public async Task PageBringToFrontShouldWork() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetHeadfulOptions()); var context = await browser.NewContextAsync(new BrowserContextOptions { Viewport = null }); var page1 = await context.NewPageAsync(); await page1.SetContentAsync("Page1"); var page2 = await context.NewPageAsync(); await page2.SetContentAsync("Page2"); await page1.BringToFrontAsync(); Assert.Equal("visible", await page1.EvaluateAsync <string>("document.visibilityState")); Assert.Equal("visible", await page2.EvaluateAsync <string>("document.visibilityState")); await page2.BringToFrontAsync(); Assert.Equal("visible", await page1.EvaluateAsync <string>("document.visibilityState")); Assert.Equal("visible", await page2.EvaluateAsync <string>("document.visibilityState")); }
public async Task ShouldNotOverrideViewportSizeWhenPassedNull() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetHeadfulOptions()); var context = await browser.NewContextAsync(new BrowserContextOptions { Viewport = null }); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); var popupTask = page.WaitForEventAsync(PageEvent.Popup); await TaskUtils.WhenAll( popupTask, page.EvaluateAsync(@"() => { const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=600,height=300,top=0,left=0'); win.resizeTo(500, 450); }")); var popup = popupTask.Result.Page; await popup.WaitForLoadStateAsync(); await popup.WaitForFunctionAsync("() => window.outerWidth === 500 && window.outerHeight === 450"); }
public async Task ShouldNotCreatePagesAutomatically() { await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var browserSession = await((IChromiumBrowser)browser).NewBrowserCDPSessionAsync(); var targets = new List <JsonElement?>(); browserSession.MessageReceived += (sender, e) => { if (e.Method == "Target.targetCreated" && e.Params.Value.GetProperty("targetInfo").GetProperty("type").GetString() != "browser") { targets.Add(e.Params); } }; await browserSession.SendAsync("Target.setDiscoverTargets", new { discover = true }); await browser.NewContextAsync(); await browser.CloseAsync(); Assert.Empty(targets); }
public async Task ShouldExcludePatterns() { Server.SetRoute("/target.html", ctx => ctx.Response.WriteAsync("<html><title>Served by the proxy</title></html>")); var proxy = new Proxy { Server = $"localhost:{TestConstants.Port}", Bypass = "******", }; await using var browser = await BrowserType.LaunchAsync(proxy : proxy); var page = await browser.NewPageAsync(); await page.GoToAsync("http://non-existent.com/target.html"); Assert.Equal("Served by the proxy", await page.TitleAsync()); await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.GoToAsync("http://non-existent1.com/target.html")); await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.GoToAsync("http://sub.non-existent2.com/target.html")); await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.GoToAsync("http://foo.zone/target.html")); }
public async Task ShouldMakeACopyOfDefaultViewport() { var viewport = new Viewport { Width = 456, Height = 789 }; await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions()); var context = await browser.NewContextAsync(new BrowserContextOptions { Viewport = viewport }); viewport.Width = 567; var page = await context.NewPageAsync(); Assert.Equal(456, page.Viewport.Width); Assert.Equal(789, page.Viewport.Height); Assert.Equal(456, await page.EvaluateAsync <int>("window.innerWidth")); Assert.Equal(789, await page.EvaluateAsync <int>("window.innerHeight")); }
public async Task ShouldNotFailWhenCancellingACompletedDownload() { var browser = await BrowserType.LaunchAsync(); var page = await browser.NewPageAsync(new() { AcceptDownloads = true }); await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>"); var download = await page.RunAndWaitForDownloadAsync(() => page.ClickAsync("a")); using var tmpDir = new TempDirectory(); string userPath = Path.Combine(tmpDir.Path, "download.txt"); await download.SaveAsAsync(userPath); Assert.IsTrue(File.Exists(userPath)); await download.CancelAsync(); var failure = await download.FailureAsync(); Assert.IsNull(failure); await page.CloseAsync(); }
public async Task ShouldThrowIfUserDataDirOptionIsPassed() { var options = TestConstants.GetDefaultBrowserOptions(); options.UserDataDir = "random-invalid-path"; var exception = await Assert.ThrowsAsync <PlaywrightSharpException>(() => BrowserType.LaunchAsync(options)); Assert.Contains("launchPersistentContext", exception.Message); }
public async Task ShouldRejectIfExecutablePathIsInvalid() { var exception = await Assert.ThrowsAsync <PlaywrightSharpException>(() => BrowserType.LaunchAsync(executablePath: "random-invalid-path")); Assert.Contains("Failed to launch", exception.Message); }
public async Task ShouldRejectIfExecutablePathIsInvalid() { var options = TestConstants.GetDefaultBrowserOptions(); options.ExecutablePath = "random-invalid-path"; var exception = await Assert.ThrowsAsync <PlaywrightSharpException>(() => BrowserType.LaunchAsync(options)); Assert.Contains("Failed to launch", exception.Message); }