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);
}