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