public async Task ShouldRetryWhenElementIsAnimatingFromOutsideTheViewportWithForce()
{
await Page.SetContentAsync($@"
<style>
@keyframes move {{
from {{ left: -300px; }}
to {{ left: 0; }}
}}
button {{
position: absolute;
left: -300px;
top: 0;
bottom: 0;
width: 200px;
}}
button.animated {{
animation: 1s linear 1s move forwards;
}}
</style>
<div style=""position: relative; width: 300px; height: 300px;"">
<button onclick =""window.clicked=true""></button>
</div>");
var handle = await Page.QuerySelectorAsync("button");
var clickTask = handle.ClickAsync(new() { Force = true });
await handle.EvaluateAsync("button => button.className = 'animated'");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => clickTask);
Assert.Null(await Page.EvaluateAsync <bool?>("window.clicked"));
StringAssert.Contains("Element is outside of the viewport", exception.Message);
}
public async Task ShouldRespectTimeout()
{
var task = Page.WaitForURLAsync("**/frame.html", new() { Timeout = 2500 });
await Page.GotoAsync(Server.EmptyPage);
var exception = await PlaywrightAssert.ThrowsAsync<TimeoutException>(() => task);
StringAssert.Contains("Timeout 2500ms exceeded.", exception.Message);
}
public async Task ShouldBeAbortableWithCustomErrorCodes()
{
await Page.RouteAsync("**/*", (route) =>
{
route.AbortAsync(RequestAbortErrorCode.InternetDisconnected);
});
IRequest failedRequest = null;
Page.RequestFailed += (_, e) => failedRequest = e;
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.GotoAsync(Server.EmptyPage));
Assert.NotNull(failedRequest);
StringAssert.StartsWith(failedRequest.Failure, exception.Message);
if (TestConstants.IsWebKit)
{
Assert.AreEqual("Request intercepted", failedRequest.Failure);
}
else if (TestConstants.IsFirefox)
{
Assert.AreEqual("NS_ERROR_OFFLINE", failedRequest.Failure);
}
else
{
Assert.AreEqual("net::ERR_INTERNET_DISCONNECTED", failedRequest.Failure);
}
}
public async Task ShouldTakeTimeoutIntoAccount()
{
await Page.GotoAsync(Server.Prefix + "/frames/one-frame.html");
Page.SetDefaultNavigationTimeout(1_000);
await PlaywrightAssert.ThrowsAsync <TimeoutException>(async() => await Page.RunAndWaitForNavigationAsync(() => Task.CompletedTask));
}
public async Task ShouldFailWhenNavigatingAndShowTheUrlAtTheErrorMessage()
{
string url = HttpsServer.Prefix + "/redirect/1.html";
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.GotoAsync(url));
StringAssert.Contains(url, exception.Message);
}
public async Task ShouldThrowErrorIfNoElementIsFound()
{
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(()
=> Page.EvalOnSelectorAsync("section", "e => e.id"));
StringAssert.Contains("failed to find element matching selector \"section\"", exception.Message);
}
public async Task ShouldSaveAsVideosFromRemoteBrowser()
{
using var tempDirectory = new TempDirectory();
var videoPath = tempDirectory.Path;
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync(new()
{
RecordVideoDir = videoPath,
RecordVideoSize = new() { Height = 320, Width = 240 }
});
var page = await context.NewPageAsync();
await page.EvaluateAsync("() => document.body.style.backgroundColor = 'red'");
await Task.Delay(1000);
await context.CloseAsync();
var videoSavePath = tempDirectory.Path + "my-video.webm";
await page.Video.SaveAsAsync(videoSavePath);
Assert.That(videoSavePath, Does.Exist);
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await page.Video.PathAsync());
StringAssert.Contains("Path is not available when connecting remotely. Use SaveAsAsync() to save a local copy", exception.Message);
}
public async Task ShouldNotAllowChangingProtocolWhenOverridingUrl()
{
var tcs = new TaskCompletionSource <Exception>();
await Page.RouteAsync("**/empty.html", async (route) =>
{
try
{
await route.ContinueAsync(new RouteContinueOptions {
Url = "file:///tmp/foo"
});
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetResult(ex);
}
});
var gotoTask = Page.GotoAsync(Server.EmptyPage, new PageGotoOptions {
Timeout = 5000
});
var exception = await tcs.Task;
Assert.IsInstanceOf <PlaywrightException>(exception);
Assert.AreEqual("New URL must have same protocol as overridden URL", exception.Message);
await PlaywrightAssert.ThrowsAsync <TimeoutException>(() => gotoTask);
}
public async Task ShouldSaveDownload()
{
Server.SetRoute("/download", context =>
{
context.Response.Headers["Content-Type"] = "application/octet-stream";
context.Response.Headers["Content-Disposition"] = "attachment";
return(context.Response.WriteAsync("Hello world"));
});
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync(new() { AcceptDownloads = true });
await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>");
var downloadTask = page.WaitForDownloadAsync();
await TaskUtils.WhenAll(
downloadTask,
page.ClickAsync("a"));
using var tmpDir = new TempDirectory();
string userPath = Path.Combine(tmpDir.Path, "these", "are", "directories", "download.txt");
var download = downloadTask.Result;
await download.SaveAsAsync(userPath);
Assert.True(new FileInfo(userPath).Exists);
Assert.AreEqual("Hello world", File.ReadAllText(userPath));
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => download.PathAsync());
Assert.AreEqual("Path is not available when connecting remotely. Use SaveAsAsync() to save a local copy.", exception.Message);
await browser.CloseAsync();
}
public async Task ShouldFailWhenReplacedByAnotherNavigation()
{
Task anotherTask = null;
// Hang for request to the empty.html
Server.SetRoute("/empty.html", _ =>
{
anotherTask = Page.GotoAsync(Server.Prefix + "/one-style.html");
return(Task.Delay(-1));
});
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.GotoAsync(Server.EmptyPage));
await anotherTask;
if (TestConstants.IsChromium)
{
StringAssert.Contains("net::ERR_ABORTED", exception.Message);
}
else if (TestConstants.IsWebKit)
{
StringAssert.Contains("Navigation interrupted by another one", exception.Message);
}
else
{
StringAssert.Contains("NS_BINDING_ABORTED", exception.Message);
}
}
public async Task ShouldReportLogsWhileWaitingForHidden()
{
await Page.GotoAsync(Server.EmptyPage);
var frame = Page.MainFrame;
await frame.EvaluateAsync(@"() => {
const div = document.createElement('div');
div.className = 'foo bar';
div.id = 'mydiv';
div.textContent = 'hello';
document.body.appendChild(div);
}");
var watchdog = frame.WaitForSelectorAsync("div", new() { State = WaitForSelectorState.Hidden, Timeout = 5000 });
await GiveItTimeToLogAsync(frame);
await frame.EvaluateAsync(@"() => {
document.querySelector('div').remove();
const div = document.createElement('div');
div.className = 'another';
div.textContent = 'hello';
document.body.appendChild(div);
}");
await GiveItTimeToLogAsync(frame);
var exception = await PlaywrightAssert.ThrowsAsync <TimeoutException>(() => watchdog);
StringAssert.Contains("Timeout 5000ms", exception.Message);
StringAssert.Contains("waiting for selector \"div\" to be hidden", exception.Message);
StringAssert.Contains("selector resolved to visible <div id=\"mydiv\" class=\"foo bar\">hello</div>", exception.Message);
StringAssert.Contains("selector resolved to visible <div class=\"another\">hello</div>", exception.Message);
}
public async Task ShouldKeepDownloadsPathFolder()
{
var page = await _browser.NewPageAsync(new() { AcceptDownloads = false });
await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>");
var downloadTask = page.WaitForDownloadAsync();
await TaskUtils.WhenAll(
downloadTask,
page.ClickAsync("a"));
var download = downloadTask.Result;
Assert.AreEqual($"{Server.Prefix}/download", download.Url);
Assert.AreEqual("file.txt", download.SuggestedFilename);
await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => download.PathAsync());
await page.CloseAsync();
await _browser.CloseAsync();
Assert.True(new DirectoryInfo(_tmp.Path).Exists);
}
public async Task ShouldWork()
{
const string createTagSelector = @"({
create(root, target) {
return target.nodeName;
},
query(root, selector) {
return root.querySelector(selector);
},
queryAll(root, selector) {
return Array.from(root.querySelectorAll(selector));
}
})";
await TestUtils.RegisterEngineAsync(Playwright, "tag", createTagSelector);
var context = await Browser.NewContextAsync();
await TestUtils.RegisterEngineAsync(Playwright, "tag2", createTagSelector);
var page = await context.NewPageAsync();
await page.SetContentAsync("<div><span></span></div><div></div>");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => page.QuerySelectorAsync("tAG=DIV"));
StringAssert.Contains("Unknown engine \"tAG\" while parsing selector tAG=DIV", exception.Message);
}
public async Task ShouldHandleErrors()
{
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.QuerySelectorAsync("neverregister=ignored"));
StringAssert.Contains("Unknown engine \"neverregister\" while parsing selector neverregister=ignored", exception.Message);
const string createDummySelector = @"({
create(root, target) {
return target.nodeName;
},
query(root, selector) {
return root.querySelector('dummy');
},
queryAll(root, selector) {
return Array.from(root.querySelectorAll('dummy'));
}
})";
exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Playwright.Selectors.RegisterAsync("$", new() { Script = createDummySelector }));
StringAssert.Contains("Selector engine name may only contain [a-zA-Z0-9_] characters", exception.Message);
await TestUtils.RegisterEngineAsync(Playwright, "dummy", createDummySelector);
await TestUtils.RegisterEngineAsync(Playwright, "duMMy", createDummySelector);
exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Playwright.Selectors.RegisterAsync("dummy", new() { Script = createDummySelector }));
StringAssert.Contains("\"dummy\" selector engine has been already registered", exception.Message);
exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Playwright.Selectors.RegisterAsync("css", new() { Script = createDummySelector }));
StringAssert.Contains("\"css\" is a predefined selector engine", exception.Message);
}
public async Task ShouldErrorWhenSavingDownloadAfterDeletion()
{
Server.SetRoute("/download", context =>
{
context.Response.Headers["Content-Type"] = "application/octet-stream";
context.Response.Headers["Content-Disposition"] = "attachment";
return(context.Response.WriteAsync("Hello world"));
});
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync(new() { AcceptDownloads = true });
await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>");
var downloadTask = page.WaitForDownloadAsync();
await TaskUtils.WhenAll(
downloadTask,
page.ClickAsync("a"));
using var tmpDir = new TempDirectory();
string userPath = Path.Combine(tmpDir.Path, "download.txt");
var download = downloadTask.Result;
await download.DeleteAsync();
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => download.SaveAsAsync(userPath));
StringAssert.Contains("Target page, context or browser has been closed", exception.Message);
await browser.CloseAsync();
}
public async Task ShouldNotCrashWhenNavigatingToBadSSLAfterACrossOriginNavigation()
{
await Page.GotoAsync(Server.CrossProcessPrefix + "/empty.html");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.GotoAsync(HttpsServer.Prefix + "/empty.html"));
TestUtils.AssertSSLError(exception.Message);
}
public async Task ShouldFailWhenNavigatingToBadSSLAfterRedirects()
{
Server.SetRedirect("/redirect/1.html", "/redirect/2.html");
Server.SetRedirect("/redirect/2.html", "/empty.html");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.GotoAsync(HttpsServer.Prefix + "/redirect/1.html"));
TestUtils.AssertSSLError(exception.Message);
}
public async Task ShouldThrowForCircularObjects()
{
var windowHandle = await Page.EvaluateHandleAsync("window");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => windowHandle.JsonValueAsync <object>());
StringAssert.Contains("Argument is a circular structure", exception.Message);
}
public async Task ShouldNotBeAbleToFillTextIntoTheInputTypeNumber()
{
await Page.SetContentAsync("<input id=\"input\" type=\"number\"></input>");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.FillAsync("input", "abc"));
StringAssert.Contains("Cannot type text into input[type=number]", exception.Message);
}
public async Task ShouldTimeoutInConnectWhileConnecting()
{
var exception = await PlaywrightAssert.ThrowsAsync <TimeoutException>(async() => await BrowserType.ConnectAsync($"ws://localhost:{Server.Port}/ws", new BrowserTypeConnectOptions {
Timeout = 100
}));
StringAssert.Contains("BrowserType.ConnectAsync: Timeout 100ms exceeded", exception.Message);
}
public async Task ShouldThrowErrorWithDetailedInformationOnExceptionInsidePromise()
{
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.EvaluateAsync <object>(@"() => new Promise(() => {
throw new Error('Error in promise');
})"));
StringAssert.Contains("Error in promise", exception.Message);
}
public async Task ShouldRespectDefaultTimeout()
{
Page.SetDefaultTimeout(1);
var exception = await PlaywrightAssert.ThrowsAsync <TimeoutException>(()
=> Page.WaitForFunctionAsync("false"));
StringAssert.Contains("Timeout 1ms exceeded", exception.Message);
}
public async Task ShouldThrowForDuplicateRegistrations()
{
await Page.ExposeFunctionAsync("foo", () => { });
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.ExposeFunctionAsync("foo", () => { }));
Assert.AreEqual("Function \"foo\" has been already registered", exception.Message);
}
public async Task ShouldRespectDefaultTimeout()
{
Page.SetDefaultTimeout(1);
var exception = await PlaywrightAssert.ThrowsAsync <TimeoutException>(
() => Page.WaitForRequestAsync(_ => false));
StringAssert.Contains(exception.Message, "Timeout 1ms exceeded while waiting for event \"Request\"");
}
public async Task ShouldThrowWhenElementIsNotASelect()
{
await Page.GotoAsync(Server.Prefix + "/input/select.html");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.SelectOptionAsync("body", string.Empty));
StringAssert.Contains("Element is not a <select> element", exception.Message);
}
public async Task ShouldThrowWhenElementIsNotAnInputOrTextareaOrContenteditable()
{
await Page.GotoAsync(Server.Prefix + "/input/textarea.html");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.FillAsync("body", string.Empty));
StringAssert.Contains("Element is not an <input>", exception.Message);
}
public async Task ShouldFailWithErrorUponDisconnect()
{
var task = Page.WaitForDownloadAsync();
await Page.CloseAsync();
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => task);
StringAssert.Contains("Page closed", exception.Message);
}
public async Task ShouldThrowWhenEvaluationTriggersReload()
{
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => Page.EvaluateAsync <object>(@"() => {
location.reload();
return new Promise(() => { });
}"));
StringAssert.Contains("navigation", exception.Message);
}
public async Task ShouldFailWhenExceedingBrowserContextTimeout()
{
Server.SetRoute("/empty.html", _ => Task.Delay(-1));
Page.Context.SetDefaultTimeout(2);
var exception = await PlaywrightAssert.ThrowsAsync <TimeoutException>(() => Page.GotoAsync(Server.EmptyPage));
StringAssert.Contains("Timeout 2ms exceeded", exception.Message);
StringAssert.Contains(Server.EmptyPage, exception.Message);
}
public async Task ShouldThrowForDetachedFrames()
{
var frame1 = await FrameUtils.AttachFrameAsync(Page, "frame1", Server.EmptyPage);
await FrameUtils.DetachFrameAsync(Page, "frame1");
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => frame1.EvaluateAsync("() => 7 * 8"));
StringAssert.Contains("Frame was detached", exception.Message);
}
