public async Task ShouldThrowANiceErrorAfterANavigation() { var exceptionTask = Assert.ThrowsAsync <PlaywrightSharpException>(() => Page.EvaluateAsync("() => new Promise(f => window.__resolve = f)")); await TaskUtils.WhenAll( Page.WaitForNavigationAsync(), Page.EvaluateAsync(@"() => { window.location.reload(); setTimeout(() => window.__resolve(42), 1000); }") ); var exception = await exceptionTask; Assert.Contains("navigation", exception.Message); }
public async Task ShouldWorkWithClickingOnAnchorLinks() { await Page.GoToAsync(TestConstants.EmptyPage); await Page.SetContentAsync("<a href='#foobar'>foobar</a>"); var navigationTask = Page.WaitForNavigationAsync(); await TaskUtils.WhenAll( navigationTask, Page.ClickAsync("a") ); Assert.Null(await navigationTask); Assert.Equal(TestConstants.EmptyPage + "#foobar", Page.Url); }
public async Task ShouldWork() { await Page.GoToAsync(TestConstants.EmptyPage); var waitForNavigationResult = Page.WaitForNavigationAsync(); await TaskUtils.WhenAll( waitForNavigationResult, Page.EvaluateAsync("url => window.location.href = url", TestConstants.ServerUrl + "/grid.html") ); var response = await waitForNavigationResult; Assert.Equal(HttpStatusCode.OK, response.Status); Assert.Contains("grid.html", response.Url); }
public async Task ShouldClickWithDisabledJavascript() { await using var context = await Browser.NewContextAsync(new BrowserContextOptions { JavaScriptEnabled = false }); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.ServerUrl + "/wrappedlink.html"); await TaskUtils.WhenAll( page.ClickAsync("a"), page.WaitForNavigationAsync() ); Assert.Equal(TestConstants.ServerUrl + "/wrappedlink.html#clicked", page.Url); }
public async Task ShouldFocusPopupsByDefault() { await Page.GoToAsync(TestConstants.EmptyPage); var popupTask = Page.WaitForEventAsync(PageEvent.Popup); await TaskUtils.WhenAll( popupTask, Page.EvaluateAsync("url => window.open(url)", TestConstants.EmptyPage)); var popup = popupTask.Result.Page; Assert.True(await Page.EvaluateAsync <bool>("document.hasFocus()")); Assert.True(await popup.EvaluateAsync <bool>("document.hasFocus()")); }
public async Task ShouldSendReferer() { await Page.SetExtraHTTPHeadersAsync(new Dictionary <string, string> { ["referer"] = "http://google.com/" }); await Page.RouteAsync("**/*", (route, request) => route.ContinueAsync()); var requestTask = Server.WaitForRequest("/grid.html", request => request.Headers["referer"]); await TaskUtils.WhenAll( requestTask, Page.GoToAsync(TestConstants.ServerUrl + "/grid.html") ); Assert.Equal("http://google.com/", requestTask.Result); }
public async Task ShouldWorkWithExtraHeadersFromBrowserContext() { await using var context = await Browser.NewContextAsync(); await context.SetExtraHTTPHeadersAsync(new Dictionary <string, string> { ["Foo"] = "Bar" }); var page = await context.NewPageAsync(); var headerTask = Server.WaitForRequest("/empty.html", request => request.Headers["Foo"]); await TaskUtils.WhenAll(page.GoToAsync(TestConstants.EmptyPage), headerTask); Assert.Equal("Bar", headerTask.Result); }
public async Task ShouldWorkOnFrame() { await Page.GoToAsync(TestConstants.ServerUrl + "/frames/one-frame.html"); var frame = Page.Frames[1]; var(response, _) = await TaskUtils.WhenAll( frame.WaitForNavigationAsync(), frame.EvaluateAsync("url => window.location.href = url", TestConstants.ServerUrl + "/grid.html") ); Assert.Equal(HttpStatusCode.OK, response.Status); Assert.Contains("grid.html", response.Url); Assert.Same(frame, response.Frame); Assert.Contains("/frames/one-frame.html", Page.Url); }
public async Task ShouldWorkWithNoopenerAndNoUrl() { await Page.GoToAsync(TestConstants.EmptyPage); var popupTask = Page.WaitForEventAsync(PageEvent.Popup); await TaskUtils.WhenAll( popupTask, Page.EvaluateAsync("() => window.open(undefined, null, 'noopener')") ); var popup = popupTask.Result.Page; Assert.Equal("about:blank", popup.Url.Split('#')[0]); Assert.False(await Page.EvaluateAsync <bool>("() => !!window.opener")); Assert.False(await popup.EvaluateAsync <bool>("() => !!window.opener")); }
public async Task ShouldWorkForMultiplePagesSharingSameProcess() { await using var context = await Browser.NewContextAsync(new BrowserContextOptions { TimezoneId = "Europe/Moscow" }); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); await TaskUtils.WhenAll( page.WaitForEventAsync(PageEvent.Popup), page.EvaluateAsync("url => window.open(url)", TestConstants.EmptyPage)); await TaskUtils.WhenAll( page.WaitForEventAsync(PageEvent.Popup), page.EvaluateAsync("url => window.open(url)", TestConstants.EmptyPage)); }
public async Task ShouldSendReferer() { string referer1 = null; string referer2 = null; await TaskUtils.WhenAll( Server.WaitForRequest("/grid.html", r => referer1 = r.Headers["Referer"]), Server.WaitForRequest("/digits/1.png", r => referer2 = r.Headers["Referer"]), Page.GoToAsync(TestConstants.ServerUrl + "/grid.html", referer: "http://google.com/") ); Assert.Equal("http://google.com/", referer1); // Make sure subresources do not inherit referer. Assert.Equal(TestConstants.ServerUrl + "/grid.html", referer2); Assert.Equal(TestConstants.ServerUrl + "/grid.html", Page.Url); }
public async Task PageWorkers() { await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.Worker), Page.GoToAsync(TestConstants.ServerUrl + "/worker/worker.html")); var worker = Page.Workers.First(); Assert.Contains("worker.js", worker.Url); Assert.Equal("worker function result", await worker.EvaluateAsync <string>("() => self['workerFunction']()")); await Page.GoToAsync(TestConstants.EmptyPage); Assert.Empty(Page.Workers); }
public async Task ShouldAcceptSingleFile() { await Page.SetContentAsync("<input type=file oninput='javascript:console.timeStamp()'>"); var fileChooser = await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.FileChooser), Page.ClickAsync("input") ); Assert.Same(Page, fileChooser.Page); Assert.NotNull(fileChooser.Element); await fileChooser.SetFilesAsync(TestConstants.FileToUpload); Assert.Equal(1, await Page.EvalOnSelectorAsync <int>("input", "input => input.files.length")); Assert.Equal("file-to-upload.txt", await Page.EvalOnSelectorAsync <string>("input", "input => input.files[0].name")); }
public async Task WatchPositionShouldBeNotified() { await Context.GrantPermissionsAsync(ContextPermission.Geolocation); await Page.GoToAsync(TestConstants.EmptyPage); var messages = new List <string>(); Page.Console += (sender, e) => messages.Add(e.Message.Text); await Context.SetGeolocationAsync(new Geolocation { Longitude = 0, Latitude = 0 }); var geolocation = await Page.EvaluateAsync <Geolocation>(@"() => { navigator.geolocation.watchPosition(pos => { const coords = pos.coords; console.log(`lat=${coords.latitude} lng=${coords.longitude}`); }, err => {}); }"); await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.Console, e => e.Message.Text.Contains("lat=0 lng=10")), Context.SetGeolocationAsync(new Geolocation { Latitude = 0, Longitude = 10 })); await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.Console, e => e.Message.Text.Contains("lat=20 lng=30")), Context.SetGeolocationAsync(new Geolocation { Latitude = 20, Longitude = 30 })); await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.Console, e => e.Message.Text.Contains("lat=40 lng=50")), Context.SetGeolocationAsync(new Geolocation { Latitude = 40, Longitude = 50 })); string allMessages = string.Join("|", messages); Assert.Contains("lat=0 lng=10", allMessages); Assert.Contains("lat=20 lng=30", allMessages); Assert.Contains("lat=40 lng=50", allMessages); }
public async Task ShouldWorkWhenPostIsRedirectedWith302() { Server.SetRedirect("/rredirect", "/empty.html"); await Page.GoToAsync(TestConstants.EmptyPage); await Page.RouteAsync("**/*", (route, _) => route.ContinueAsync()); await Page.SetContentAsync(@" <form action='/rredirect' method='post'> <input type=""hidden"" id=""foo"" name=""foo"" value=""FOOBAR""> </form>"); await TaskUtils.WhenAll( Page.EvalOnSelectorAsync("form", "form => form.submit()"), Page.WaitForNavigationAsync() ); }
public async Task ShouldWorkWithNoTimeout() { await Page.GoToAsync(TestConstants.EmptyPage); var task = Page.WaitForRequestAsync(TestConstants.ServerUrl + "/digits/2.png", 0); var(request, _) = await TaskUtils.WhenAll( task, Page.EvaluateAsync(@"() => setTimeout(() => { fetch('/digits/1.png'); fetch('/digits/2.png'); fetch('/digits/3.png'); }, 50)") ); Assert.Equal(TestConstants.ServerUrl + "/digits/2.png", request.Url); }
public async Task ShouldAwaitNavigationWhenAssigningLocation() { var messages = new List <string>(); Server.SetRoute("/empty.html", context => { messages.Add("route"); context.Response.ContentType = "text/html"; return(context.Response.WriteAsync("<link rel='stylesheet' href='./one-style.css'>")); }); await TaskUtils.WhenAll( Page.EvaluateAsync($"window.location.href = '{TestConstants.EmptyPage}'").ContinueWith(t => messages.Add("evaluate")), Page.WaitForEventAsync(PageEvent.FrameNavigated).ContinueWith(t => messages.Add("navigated"))); Assert.Equal("route|navigated|evaluate", string.Join("|", messages)); }
public async Task ShouldReportRequestsAndResponsesHandledByServiceWorker() { await Page.GoToAsync(TestConstants.ServerUrl + "/serviceworkers/fetchdummy/sw.html"); await Page.EvaluateAsync("() => window.activationPromise"); var(request, swResponse) = await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.Request), Page.EvaluateAsync <string>("() => fetchDummy('foo')")); Assert.Equal("responseFromServiceWorker:foo", swResponse); Assert.Equal(TestConstants.ServerUrl + "/serviceworkers/fetchdummy/foo", request.Request.Url); var response = await request.Request.GetResponseAsync(); Assert.Equal(TestConstants.ServerUrl + "/serviceworkers/fetchdummy/foo", response.Url); Assert.Equal("responseFromServiceWorker:foo", await response.GetTextAsync()); }
public async Task ShouldWork() { await Page.GoToAsync(TestConstants.EmptyPage); var task = Page.WaitForResponseAsync(TestConstants.ServerUrl + "/digits/2.png"); var(response, _) = await TaskUtils.WhenAll( task, Page.EvaluateAsync <string>(@"() => { fetch('/digits/1.png'); fetch('/digits/2.png'); fetch('/digits/3.png'); }") ); Assert.Equal(TestConstants.ServerUrl + "/digits/2.png", response.Url); }
public async Task ShouldWorkWithPredicate() { await Page.GoToAsync(TestConstants.EmptyPage); var task = Page.WaitForEventAsync(PageEvent.Request, e => e.Request.Url == TestConstants.ServerUrl + "/digits/2.png"); var(requestEvent, _) = await TaskUtils.WhenAll( task, Page.EvaluateAsync <string>(@"() => { fetch('/digits/1.png'); fetch('/digits/2.png'); fetch('/digits/3.png'); }") ); Assert.Equal(TestConstants.ServerUrl + "/digits/2.png", requestEvent.Request.Url); }
public async Task ShouldWorkWhenSubframeIssuesWindowStop() { //This test is slightly different from the one in PW because of .NET Threads (or thanks to .NET Threads) var framesNavigated = new List <IFrame>(); IFrame frame = null; var frameAttachedTaskSource = new TaskCompletionSource <IFrame>(); Page.FrameAttached += (sender, e) => { frameAttachedTaskSource.SetResult(e.Frame); }; var frameNavigatedTaskSource = new TaskCompletionSource <bool>(); Page.FrameNavigated += (sender, e) => { if (frame != null) { if (e.Frame == frame) { frameNavigatedTaskSource.TrySetResult(true); } } else { framesNavigated.Add(frame); } }; Server.SetRoute("/frames/style.css", (context) => Task.CompletedTask); var navigationTask = Page.GoToAsync(TestConstants.ServerUrl + "/frames/one-frame.html"); frame = await frameAttachedTaskSource.Task; if (framesNavigated.Contains(frame)) { frameNavigatedTaskSource.TrySetResult(true); } await frameNavigatedTaskSource.Task; await TaskUtils.WhenAll( frame.EvaluateAsync("() => window.stop()"), navigationTask ); }
public async Task ShouldSupportUserAgentOption() { var(tmp, context, page) = await LaunchAsync(new BrowserContextOptions { UserAgent = "foobar" }); string userAgent = string.Empty; await TaskUtils.WhenAll( Server.WaitForRequest("/empty.html", r => userAgent = r.Headers["user-agent"]), page.GoToAsync(TestConstants.EmptyPage)); Assert.Equal("foobar", userAgent); tmp.Dispose(); await context.DisposeAsync(); }
public async Task ShouldWorkWithShiftClicking() { // WebKit: Shift+Click does not open a new window. await using var context = await Browser.NewContextAsync(); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); await page.SetContentAsync("<a href=\"/one-style.html\">yo</a>"); var popupEventTask = context.WaitForEventAsync(ContextEvent.Page); await TaskUtils.WhenAll( popupEventTask, page.ClickAsync("a", modifiers: new[] { Modifier.Shift })); Assert.Null(await popupEventTask.Result.Page.GetOpenerAsync()); }
public async Task ShouldHaveAnOpener() { await using var context = await Browser.NewContextAsync(); var page = await context.NewPageAsync(); await page.GoToAsync(TestConstants.EmptyPage); var(popupEvent, _) = await TaskUtils.WhenAll( context.WaitForEventAsync(ContextEvent.Page), page.GoToAsync(TestConstants.ServerUrl + "/popup/window-open.html")); var popup = popupEvent.Page; Assert.Equal(TestConstants.ServerUrl + "/popup/popup.html", popup.Url); Assert.Same(page, await popup.GetOpenerAsync()); Assert.Null(await page.GetOpenerAsync()); }
public async Task ExposeBindingHandleShouldNotThrowDuringNavigation() { IJSHandle target = null; await Page.ExposeBindingAsync( "logme", (BindingSource source, IJSHandle t) => { target = t; return(17); }); await TaskUtils.WhenAll( Page.WaitForNavigationAsync(LifecycleEvent.Load), Page.EvaluateAsync(@"async url => { window['logme']({ foo: 42 }); window.location.href = url; }", TestConstants.ServerUrl + "/one-style.html")); }
public async Task ShouldReportDownloadsWithAcceptDownloadsTrue() { var page = await Browser.NewPageAsync(acceptDownloads : true); await page.SetContentAsync($"<a href=\"{TestConstants.ServerUrl}/download\">download</a>"); var downloadTask = page.WaitForEventAsync(PageEvent.Download); await TaskUtils.WhenAll( downloadTask, page.ClickAsync("a")); var download = downloadTask.Result.Download; string path = await download.GetPathAsync(); Assert.True(new FileInfo(path).Exists); Assert.Equal("Hello world", File.ReadAllText(path)); }
public async Task ShouldFire() { var(error, _) = await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.PageError), Page.GoToAsync(TestConstants.ServerUrl + "/error.html") ); Assert.Equal("Error", error.Name); Assert.Equal("Fancy error!", error.Message); string stack = await Page.EvaluateAsync <string>("() => window.e.stack"); if (TestConstants.IsWebKit) { stack = stack.Replace("14:25", "15:19"); } Assert.Equal(stack, error.Stack); }
public async Task ShouldNotFailForWindowObject() { ConsoleMessage message = null; void EventHandler(object sender, ConsoleEventArgs e) { message = e.Message; Page.Console -= EventHandler; } Page.Console += EventHandler; await TaskUtils.WhenAll( Page.EvaluateAsync("() => console.error(window)"), Page.WaitForEventAsync(PageEvent.Console) ); Assert.Equal("JSHandle@object", message.Text); }
public async Task ShouldWork() { var(request, _) = await TaskUtils.WhenAll( Page.WaitForEventAsync(PageEvent.RequestFinished), Page.GoToAsync(TestConstants.EmptyPage)); var timing = request.Request.Timing; Assert.True(timing.DomainLookupStart >= 0); Assert.True(timing.DomainLookupEnd >= timing.DomainLookupStart); Assert.True(timing.ConnectStart >= timing.DomainLookupEnd); Assert.Equal(-1, timing.SecureConnectionStart); Assert.True(timing.ConnectEnd > timing.SecureConnectionStart); Assert.True(timing.RequestStart >= timing.ConnectEnd); Assert.True(timing.ResponseStart > timing.RequestStart); Assert.True(timing.ResponseEnd >= timing.ResponseStart); Assert.True(timing.ResponseEnd < 10000); }
public async Task ShouldReportDownloadsInDownloadsPathFolder() { var page = await _browser.NewPageAsync(new BrowserContextOptions { AcceptDownloads = true }); await page.SetContentAsync($"<a href=\"{TestConstants.ServerUrl}/download\">download</a>"); var downloadTask = page.WaitForEventAsync(PageEvent.Download); await TaskUtils.WhenAll( downloadTask, page.ClickAsync("a")); var download = downloadTask.Result.Download; string path = await download.GetPathAsync(); Assert.StartsWith(_tmp.Path, path); await page.CloseAsync(); }