public async Task UserDataDirOptionShouldRestoreState()
{
using var userDataDir = new TempDirectory();
var options = TestConstants.GetDefaultBrowserOptions();
options.UserDataDir = userDataDir.Path;
await using (var browser = await Playwright.LaunchAsync(options))
{
var page = await browser.DefaultContext.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await page.EvaluateAsync("localStorage.hey = 'hello'");
await browser.CloseAsync();
}
await using (var browser2 = await Playwright.LaunchAsync(options))
{
var page2 = await browser2.DefaultContext.NewPageAsync();
await page2.GoToAsync(TestConstants.EmptyPage);
Assert.Equal("hello", await page2.EvaluateAsync <string>("localStorage.hey"));
}
await using (var browser3 = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions()))
{
var page3 = await browser3.DefaultContext.NewPageAsync();
await page3.GoToAsync(TestConstants.EmptyPage);
}
}
public async Task ShouldBeAbleToSaveFile()
{
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();
string outputFile = Path.Combine(BaseDirectory, "output.pdf");
var fileInfo = new FileInfo(outputFile);
if (fileInfo.Exists)
{
fileInfo.Delete();
}
await page.GetPdfAsync(outputFile);
fileInfo = new FileInfo(outputFile);
Assert.True(new FileInfo(outputFile).Length > 0);
if (fileInfo.Exists)
{
fileInfo.Delete();
}
}
public async Task ShouldBeAbleToReconnectToADisconnectedBrowser()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
await using var browser = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await browser.CloseAsync();
await using var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
context = await remote.NewContextAsync();
page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await remote.CloseAsync();
await browserServer.CloseAsync();
}
public async Task ShouldExcludePatterns()
{
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}",
Bypass = "******",
};
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());
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 ShouldTakeElementScreenshotWhenDefaultViewportIsNullAndRestoreBack()
{
await using var browser = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
var page = await NewPageAsync(browser, new BrowserContextOptions { Viewport = null });
await page.SetContentAsync(@"
<div style=""height: 14px"">oooo</div>
<style>
div.to-screenshot {
border: 1px solid blue;
width: 600px;
height: 600px;
margin-left: 50px;
}
::-webkit-scrollbar{
display: none;
}
</style>
<div class=""to-screenshot""></div>
<div class=""to-screenshot""></div>
<div class=""to-screenshot""></div>
");
var sizeBefore = await page.EvaluateAsync <Viewport>("() => ({ width: document.body.offsetWidth, height: document.body.offsetHeight })");
var elementHandle = await page.QuerySelectorAsync("div.to-screenshot");
byte[] screenshot = await elementHandle.ScreenshotAsync();
Assert.NotEmpty(screenshot);
var sizeAfter = await page.EvaluateAsync <Viewport>("() => ({ width: document.body.offsetWidth, height: document.body.offsetHeight })");
Assert.Equal(sizeBefore, sizeAfter);
}
public async Task ShouldAuthenticate()
{
Server.SetRoute("/target.html", ctx =>
{
string auth = ctx.Request.Headers["proxy-authorization"];
if (string.IsNullOrEmpty(auth))
{
ctx.Response.StatusCode = 407;
ctx.Response.Headers["Proxy-Authenticate"] = "Basic realm=\"Access to internal site\"";
}
return(ctx.Response.WriteAsync($"<html><title>{auth}</title></html>"));
});
var defaultBrowserOptions = TestConstants.GetDefaultBrowserOptions();
defaultBrowserOptions.Proxy = new ProxySettings
{
Server = $"localhost:{TestConstants.Port}",
Username = "******",
Password = "******"
};
await using var browser = await BrowserType.LaunchAsync(defaultBrowserOptions);
var page = await browser.NewPageAsync();
await page.GoToAsync("http://non-existent.com/target.html");
Assert.Equal("Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes("user:secret")), await page.GetTitleAsync());
}
public async Task UserDataDirOptionShouldRestoreCookies()
{
using var userDataDir = new TempDirectory();
var options = TestConstants.GetDefaultBrowserOptions();
options.Args = options.Args.Concat(new[] { $"--user-data-dir=\"{userDataDir}\"" }).ToArray();
using (var browser = await Playwright.LaunchAsync(options))
{
var page = await browser.DefaultContext.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await page.EvaluateAsync(
"document.cookie = 'doSomethingOnlyOnce=true; expires=Fri, 31 Dec 9999 23:59:59 GMT'");
}
using (var browser2 = await Playwright.LaunchAsync(options))
{
var page2 = await browser2.DefaultContext.NewPageAsync();
await page2.GoToAsync(TestConstants.EmptyPage);
Assert.Equal("doSomethingOnlyOnce=true", await page2.EvaluateAsync <string>("document.cookie"));
}
}
public async Task ShouldRestoreDefaultViewportAfterFullPageScreenshot()
{
await using var browser = await Playwright.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"));
byte[] screenshot = await page.ScreenshotAsync(new ScreenshotOptions
{
FullPage = true
});
Assert.NotEmpty(screenshot);
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 ShouldBeAbleToReconnectToADisconnectedBrowser()
{
using var browserApp = await Playwright.LaunchBrowserAppAsync(TestConstants.GetDefaultBrowserOptions());
using var browser = await Playwright.ConnectAsync(browserApp.ConnectOptions);
string url = TestConstants.ServerUrl + "/frames/nested-frames.html";
var page = await browser.DefaultContext.NewPageAsync();
await page.GoToAsync(url);
await browser.DisconnectAsync();
using var remote = await Playwright.ConnectAsync(browserApp.ConnectOptions);
var pages = (await remote.DefaultContext.GetPagesAsync()).ToList();
var restoredPage = pages.FirstOrDefault(x => x.Url == url);
Assert.NotNull(restoredPage);
var frameDump = FrameUtils.DumpFrames(restoredPage.MainFrame);
Assert.Equal(TestConstants.NestedFramesDumpResult, frameDump);
int response = await restoredPage.EvaluateAsync <int>("7 * 8");
Assert.Equal(56, response);
await remote.DisconnectAsync();
}
public async Task ShouldBeCallableTwice()
{
await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
await Task.WhenAll(browser.CloseAsync(), browser.CloseAsync());
await browser.CloseAsync();
}
public async Task ShouldHaveDefaultUrlWhenLaunchingBrowser()
{
using var browser = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
var pages = (await browser.DefaultContext.GetPagesAsync()).Select(page => page.Url);
Assert.Equal(new[] { TestConstants.AboutBlank }, pages);
}
public async Task ShouldFireCloseEvent()
{
var tcs = new TaskCompletionSource <bool>();
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
browserServer.Closed += (sender, e) => tcs.TrySetResult(true);
await Task.WhenAll(tcs.Task, browserServer.CloseAsync());
}
/// <inheritdoc/>
public async Task InitializeAsync()
{
var options = TestConstants.GetDefaultBrowserOptions();
options.Args = new[] { "--site-per-process" };
_browser = await BrowserType.LaunchAsync(options);
_page = await _browser.NewPageAsync();
}
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);
}
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 ShouldHaveDefaultContext()
{
await using var browser = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
Assert.Single(browser.BrowserContexts);
var defaultContext = browser.BrowserContexts.First();
var exception = await Assert.ThrowsAsync <PlaywrightSharpException>(defaultContext.CloseAsync);
Assert.Same(defaultContext, browser.DefaultContext);
Assert.Contains("cannot be closed", exception.Message);
}
private async Task <(TempDirectory tmp, IBrowserContext context, IPage page)> LaunchAsync(BrowserContextOptions options = null)
{
var tmp = new TempDirectory();
var context = await BrowserType.LaunchPersistentContextAsync(
tmp.Path,
TestConstants.GetDefaultBrowserOptions().ToPersistentOptions() + (options ?? new BrowserContextOptions()));
var page = context.Pages.First();
return(tmp, context, page);
}
public async Task ShouldSetTheBrowserConnectedState()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
Assert.True(remote.IsConnected);
await remote.CloseAsync();
Assert.False(remote.IsConnected);
}
public async Task ShouldRejectAllPromisesWhenBrowserIsClosed()
{
await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
var page = await(await browser.NewContextAsync()).NewPageAsync();
var neverResolves = page.EvaluateHandleAsync("() => new Promise(r => {})");
await browser.CloseAsync();
var exception = await Assert.ThrowsAsync <TargetClosedException>(() => neverResolves);
Assert.Contains("Protocol error", exception.Message);
}
/// <inheritdoc/>
public HeadfulTests(ITestOutputHelper output) : base(output)
{
string extensionPath = TestUtils.GetWebServerFile("simple-extension");
_extensionOptions = TestConstants.GetDefaultBrowserOptions();
_extensionOptions.Headless = false;
_extensionOptions.Args = new[]
{
$"--disable-extensions-except={extensionPath}",
$"--load-extension={extensionPath}"
};
}
public async Task ShouldFireCloseEventForAllContexts()
{
await using var browser = await BrowserType.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
var context = await browser.NewContextAsync();
var closeTask = new TaskCompletionSource <bool>();
context.Closed += (sender, e) => closeTask.TrySetResult(true);
await Task.WhenAll(browser.CloseAsync(), closeTask.Task);
}
public async Task ShouldBeAbleToCloseRemoteBrowser()
{
using var browserApp = await Playwright.LaunchBrowserAppAsync(TestConstants.GetDefaultBrowserOptions());
using var remote = await Playwright.ConnectAsync(browserApp.ConnectOptions);
var closeTask = new TaskCompletionSource <bool>();
browserApp.Closed += (sender, e) => closeTask.TrySetResult(true);
await Task.WhenAll(remote.CloseAsync(), closeTask.Task);
}
/// <inheritdoc/>
public HeadfulTests(ITestOutputHelper output) : base(output)
{
string extensionPath = Path.Combine(Directory.GetCurrentDirectory(), "Assets", "simple-extension");
_extensionOptions = TestConstants.GetDefaultBrowserOptions();
_extensionOptions.Headless = false;
_extensionOptions.Args = new[]
{
$"--disable-extensions-except={extensionPath}",
$"--load-extension={extensionPath}"
};
}
/// <inheritdoc cref="IAsyncLifetime.InitializeAsync"/>
public override async Task InitializeAsync()
{
await base.InitializeAsync();
_controlledBrowser = await Playwright.LaunchBrowserAppAsync(TestConstants.GetDefaultBrowserOptions());
await Page.GoToAsync(TestConstants.ServerUrl + "/test/assets/playwrightweb.html");
await Page.EvaluateAsync(
"(product, connectOptions) => setup(product, connectOptions)",
TestConstants.Product.ToLower(),
_controlledBrowser.ConnectOptions);
}
public async Task ShouldCreateNewIncognitoContext()
{
await using var browser = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
Assert.Single(browser.BrowserContexts);
var context = await browser.NewContextAsync();
Assert.Equal(2, browser.BrowserContexts.Count());
Assert.Contains(context, browser.BrowserContexts);
await context.CloseAsync();
Assert.Single(browser.BrowserContexts);
}
public async Task ShouldIsolateLocalStorageAndCookies()
{
// Create two incognito contexts.
await using var browser = await Playwright.LaunchAsync(TestConstants.GetDefaultBrowserOptions());
var context1 = await browser.NewContextAsync();
var context2 = await browser.NewContextAsync();
Assert.Empty(await context1.GetPagesAsync());
Assert.Empty(await context2.GetPagesAsync());
// Create a page in first incognito context.
var page1 = await context1.NewPageAsync();
await page1.GoToAsync(TestConstants.EmptyPage);
await page1.EvaluateAsync(@"() => {
localStorage.setItem('name', 'page1');
document.cookie = 'name=page1';
}");
Assert.Single(await context1.GetPagesAsync());
Assert.Empty(await context2.GetPagesAsync());
// Create a page in second incognito context.
var page2 = await context2.NewPageAsync();
await page2.GoToAsync(TestConstants.EmptyPage);
await page2.EvaluateAsync(@"() => {
localStorage.setItem('name', 'page2');
document.cookie = 'name=page2';
}");
Assert.Single(await context1.GetPagesAsync());
Assert.Equal(page1, (await context1.GetPagesAsync())[0]);
Assert.Single(await context2.GetPagesAsync());
Assert.Equal(page2, (await context2.GetPagesAsync())[0]);
// Make sure pages don't share localstorage or cookies.
Assert.Equal("page1", await page1.EvaluateAsync <string>("() => localStorage.getItem('name')"));
Assert.Equal("name=page1", await page1.EvaluateAsync <string>("() => document.cookie"));
Assert.Equal("page2", await page2.EvaluateAsync <string>("() => localStorage.getItem('name')"));
Assert.Equal("name=page2", await page2.EvaluateAsync <string>("() => document.cookie"));
// Cleanup contexts.
await Task.WhenAll(context1.CloseAsync(), context2.CloseAsync());
Assert.Single(browser.BrowserContexts);
}
public async Task ShouldThrowIfUsedAfterDisconnect()
{
using var browserApp = await Playwright.LaunchBrowserAppAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await Playwright.ConnectAsync(browserApp.ConnectOptions);
var page = await remote.DefaultContext.NewPageAsync();
await remote.DisconnectAsync();
var exception = await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.EvaluateAsync("1 + 1"));
Assert.Contains("has been closed", exception.Message);
}
public async Task UserDataDirOption()
{
using var userDataDir = new TempDirectory();
var options = TestConstants.GetDefaultBrowserOptions();
options.UserDataDir = userDataDir.Path;
using var browser = await Playwright.LaunchAsync(options);
Assert.True(Directory.GetFiles(userDataDir.Path).Length > 0);
await browser.CloseAsync();
Assert.True(Directory.GetFiles(userDataDir.Path).Length > 0);
}
public async Task ShouldFireDisconnectedWhenClosingWithWebSocket()
{
var options = TestConstants.GetDefaultBrowserOptions();
using var browserApp = await Playwright.LaunchBrowserAppAsync(options);
using var browser = await Playwright.ConnectAsync(browserApp.ConnectOptions);
var disconnectedTask = new TaskCompletionSource <bool>();
browser.Disconnected += (sender, e) => disconnectedTask.TrySetResult(true);
browserApp.Kill();
await disconnectedTask.Task;
}
public async Task ShouldSupportTheWebSocketOption()
{
var options = TestConstants.GetDefaultBrowserOptions();
using var browserApp = await Playwright.LaunchBrowserAppAsync(options);
using var browser = await Playwright.ConnectAsync(browserApp.ConnectOptions);
Assert.Single(await browser.DefaultContext.GetPagesAsync());
Assert.NotNull(browserApp.WebSocketEndpoint);
var page = await browser.DefaultContext.NewPageAsync();
Assert.Equal(121, await page.EvaluateAsync <int>("11 * 11"));
}