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