public async Task ShouldWorkForSubframes()
{
Assert.Contains("Mozilla", await Page.EvaluateExpressionAsync <string>("navigator.userAgent"));
await Page.SetUserAgentAsync("foobar");
var waitForRequestTask = Server.WaitForRequest <string>("/empty.html", (request) => request.Headers["user-agent"]);
await Task.WhenAll(
waitForRequestTask,
FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage));
}
public async Task ShouldWorkForCrossFrameEvaluations()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.Frames[1];
var elementHandle = (IElementHandle)await frame.EvaluateHandleAsync("() => window.top.document.querySelector('#frame1')");
Assert.Equal(frame, await elementHandle.GetContentFrameAsync());
}
public async Task ShouldReturnNullForDocumentDocumentElement()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.Frames[1];
var elementHandle = (IElementHandle)await frame.EvaluateHandleAsync("() => document.documentElement");
Assert.Null(await elementHandle.GetContentFrameAsync());
}
public async Task ShouldThrowIfElementHandlesAreFromOtherFrames()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var bodyHandle = await Page.FirstChildFrame().QuerySelectorAsync("body");
var exception = await Assert.ThrowsAsync <EvaluationFailedException>(()
=> Page.EvaluateFunctionAsync <string>("body => body.innerHTML", bodyHandle));
Assert.Contains("JSHandles can be evaluated only in the context they were created", exception.Message);
}
public async Task ShouldThrowForDetachedFrames()
{
var frame1 = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.DetachFrameAsync(Page, "frame1");
var exception = await Assert.ThrowsAsync <PuppeteerException>(
() => frame1.EvaluateExpressionAsync("7 * 8"));
Assert.Contains("Execution Context is not available in detached frame", exception.Message);
}
public async Task ShouldWorkForIframeElements()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.MainFrame;
var elementHandle = (IElementHandle)await frame.EvaluateHandleAsync("() => document.querySelector('#frame1')");
Assert.Equal(frame, await elementHandle.GetOwnerFrameAsync());
}
public async Task ShouldWorkForCrossFrameEvaluations()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.MainFrame;
var elementHandle = (IElementHandle)await frame.EvaluateHandleAsync("() => document.querySelector('#frame1').contentWindow.document.body");
Assert.Equal(frame.ChildFrames[0], await elementHandle.GetOwnerFrameAsync());
}
public async Task ShouldWorkForCrossProcessIframes()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.CrossProcessUrl + "/empty.html");
var frame = Page.Frames[1];
var elementHandle = (IElementHandle)await frame.EvaluateHandleAsync("() => document.body");
Assert.Equal(frame, await elementHandle.GetOwnerFrameAsync());
}
public async Task ShouldFireForIframes()
{
var requests = new List <IRequest>();
Page.Request += (sender, e) => requests.Add(e.Request);
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, requests.Count);
}
public async Task ShouldWorkForCrossProcessIframes()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.CrossProcessUrl + "/empty.html");
var elementHandle = await Page.QuerySelectorAsync("#frame1");
var frame = await elementHandle.GetContentFrameAsync();
Assert.Equal(Page.Frames[1], frame);
}
public async Task ShouldReturnMatchingResponses()
{
// Disable cache: otherwise, chromium will cache similar requests.
await Page.SetCacheEnabledAsync(false);
await Page.GoToAsync(TestConstants.EmptyPage);
// Attach three frames.
var matchingData = new MatchingResponseData[]
{
new MatchingResponseData {
FrameTask = FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage)
},
new MatchingResponseData {
FrameTask = FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage)
},
new MatchingResponseData {
FrameTask = FrameUtils.AttachFrameAsync(Page, "frame3", TestConstants.EmptyPage)
}
};
await Task.WhenAll(matchingData.Select(m => m.FrameTask));
// Navigate all frames to the same URL.
var requestHandler = new RequestDelegate(async(context) =>
{
if (int.TryParse(context.Request.Query["index"], out var index))
{
await context.Response.WriteAsync(await matchingData[index].ServerResponseTcs.Task);
}
});
Server.SetRoute("/one-style.html?index=0", requestHandler);
Server.SetRoute("/one-style.html?index=1", requestHandler);
Server.SetRoute("/one-style.html?index=2", requestHandler);
for (var i = 0; i < 3; ++i)
{
var waitRequestTask = Server.WaitForRequest("/one-style.html");
matchingData[i].NavigationTask = matchingData[i].FrameTask.Result.GoToAsync($"{TestConstants.ServerUrl}/one-style.html?index={i}");
await waitRequestTask;
}
// Respond from server out-of-order.
var serverResponseTexts = new string[] { "AAA", "BBB", "CCC" };
for (var i = 0; i < 3; ++i)
{
matchingData[i].ServerResponseTcs.TrySetResult(serverResponseTexts[i]);
var response = await matchingData[i].NavigationTask;
Assert.Same(matchingData[i].FrameTask.Result, response.Frame);
Assert.Equal(serverResponseTexts[i], await response.TextAsync());
}
}
public async Task ShouldThrowWhenDetached()
{
await Page.GoToAsync(TestConstants.EmptyPage);
var frame1 = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await Page.EvalOnSelectorAsync("#frame1", "e => e.remove()");
var exception = await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => frame1.GetFrameElementAsync());
Assert.Equal("Frame has been detached.", exception.Message);
}
public async Task ShouldWorkWithContentFrame()
{
await Page.GoToAsync(TestConstants.EmptyPage);
var frame = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var handle = await frame.GetFrameElementAsync();
var contentFrame = await handle.GetContentFrameAsync();
Assert.Same(contentFrame, frame);
}
public async Task ShouldThrowWhenFrameIsDetached()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.FirstChildFrame();
var waitPromise = frame.WaitForXPathAsync("//*[@class=\"box\"]");
await FrameUtils.DetachFrameAsync(Page, "frame1");
var exception = await Assert.ThrowsAnyAsync <Exception>(() => waitPromise);
Assert.Contains("waitForFunction failed: frame got detached.", exception.Message);
}
public async Task ShouldRunInSpecifiedFrame()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame2", TestConstants.EmptyPage);
var frame1 = Page.Frames.First(f => f.Name == "frame1");
var frame2 = Page.Frames.First(f => f.Name == "frame2");
var waitForXPathPromise = frame2.WaitForXPathAsync("//div");
await frame1.EvaluateFunctionAsync(addElement, "div");
await frame2.EvaluateFunctionAsync(addElement, "div");
var eHandle = await waitForXPathPromise;
Assert.Equal(frame2, eHandle.ExecutionContext.Frame);
}
public async Task ShouldWork()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var elementHandle = await Page.QuerySelectorAsync("#frame1");
var frame = await elementHandle.ContentFrameAsync();
Assert.Equal(Page.FirstChildFrame(), frame);
}
public async Task ShouldNotAllowCrossFrameElementHandlesWhenFramesDoNotScriptEachOther()
{
await Page.GoToAsync(TestConstants.EmptyPage);
var frame = await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.CrossProcessUrl + "/empty.html");
var bodyHandle = await frame.QuerySelectorAsync("body");
var exception = await Assert.ThrowsAsync <PlaywrightSharpException>(() => Page.EvaluateAsync("body => body.innerHTML", bodyHandle));
Assert.Contains("Unable to adopt element handle from a different document", exception.Message);
}
public async Task ShouldHaveDifferentExecutionContexts()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, Page.Frames.Length);
await Page.Frames[0].EvaluateAsync("() => window.FOO = 'foo'");
await Page.Frames[1].EvaluateAsync("() => window.FOO = 'bar'");
Assert.Equal("foo", await Page.Frames[0].EvaluateAsync <string>("() => window.FOO"));
Assert.Equal("bar", await Page.Frames[1].EvaluateAsync <string>("() => window.FOO"));
}
public async Task ShouldTypeEmojiIntoAnIframe()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "emoji-test", TestConstants.ServerUrl + "/input/textarea.html");
var frame = Page.Frames[1];
var textarea = await frame.QuerySelectorAsync("textarea");
await textarea.TypeAsync("👹 Tokyo street Japan 🇯🇵");
Assert.Equal("👹 Tokyo street Japan 🇯🇵", await frame.EvalOnSelectorAsync <string>("textarea", "textarea => textarea.value"));
}
public async Task ShouldWorkForSubframeNavigationRequest()
{
var requests = new List <IRequest>();
Page.Request += (sender, e) => requests.Add(e.Request);
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
Assert.Equal(2, requests.Count);
Assert.Equal(Page.FirstChildFrame(), requests[1].Frame);
}
public async Task ShouldWorkForSubframes()
{
var page = await NewPageAsync();
Assert.Contains("Mozilla", await page.EvaluateAsync <string>("navigator.userAgent"));
page = await NewPageAsync(new BrowserContextOptions { UserAgent = "foobar" });
var(userAgent, _) = await TaskUtils.WhenAll(
Server.WaitForRequest <string>("/empty.html", (request) => request.Headers["user-agent"]),
FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.EmptyPage));
Assert.Equal("foobar", userAgent);
}
public async Task ShouldThrowWhenFrameIsDetached()
{
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.Frames.ElementAt(1);
var waitTask = frame.WaitForSelectorAsync(".box").ContinueWith(task => task?.Exception?.InnerException);
await FrameUtils.DetachFrameAsync(Page, "frame1");
var waitException = await waitTask;
Assert.NotNull(waitException);
Assert.Contains("waitForSelector failed: frame got detached", waitException.Message);
}
public async Task ShouldClickTheButtonInsideAnIframe()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
var frame = Page.FirstChildFrame();
var button = await frame.QuerySelectorAsync("button");
await button.ClickAsync();
Assert.Equal("Clicked", await frame.EvaluateExpressionAsync <string>("window.result"));
}
public async Task ShouldWorkForSubframes()
{
var page = await NewPageAsync();
Assert.Contains("Mozilla", await page.EvaluateAsync <string>("navigator.userAgent"));
await page.SetUserAgentAsync("foobar");
var userAgentTask = Server.WaitForRequest <string>("/empty.html", (request) => request.Headers["user-agent"]);
await Task.WhenAll(
userAgentTask,
FrameUtils.AttachFrameAsync(page, "frame1", TestConstants.EmptyPage));
Assert.Equal("foobar", userAgentTask.Result);
}
public async Task ShouldTypeEmojiIntoAniframe()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "emoji-test", TestConstants.ServerUrl + "/input/textarea.html");
var frame = Page.FirstChildFrame();
var textarea = await frame.QuerySelectorAsync("textarea");
await textarea.TypeAsync("👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5");
Assert.Equal(
"👹 Tokyo street Japan \uD83C\uDDEF\uD83C\uDDF5",
await frame.QuerySelectorAsync("textarea").EvaluateFunctionAsync <string>("t => t.value"));
}
public async Task ShouldReturnNonEmptyNodeConstructorNameInUtilityContext()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var frame = Page.Frames[1];
// TODO We might want cast frame to a FrameBase when implementing this instead of exposing an internal class as an interface.
var context = await((PlaywrightSharp.Frame)frame).GetUtilityContextAsync();
var elementHandle = await context.EvaluateHandleAsync("() => window.top.document.querySelector('#frame1')");
string constructorName = await context.EvaluateAsync <string>("node => node.constructor.name", elementHandle);
Assert.Equal("HTMLIFrameElement", constructorName);
}
public async Task ShouldReportFrameName()
{
await FrameUtils.AttachFrameAsync(Page, "theFrameId", TestConstants.EmptyPage);
await Page.EvaluateAsync(@"url => {
const frame = document.createElement('iframe');
frame.name = 'theFrameName';
frame.src = url;
document.body.appendChild(frame);
return new Promise(x => frame.onload = x);
}", TestConstants.EmptyPage);
Assert.Empty(Page.Frames[0].Name);
Assert.Equal("theFrameId", Page.Frames[1].Name);
Assert.Equal("theFrameName", Page.Frames[2].Name);
}
public async Task ShouldClickTheButtonWithDeviceScaleFactorSet()
{
await Page.SetViewportAsync(new ViewPortOptions { Width = 400, Height = 400, DeviceScaleFactor = 5 });
Assert.Equal(5, await Page.EvaluateExpressionAsync <int>("window.devicePixelRatio"));
await Page.SetContentAsync("<div style=\"width:100px;height:100px\">spacer</div>");
await FrameUtils.AttachFrameAsync(Page, "button-test", TestConstants.ServerUrl + "/input/button.html");
var frame = Page.FirstChildFrame();
var button = await frame.QuerySelectorAsync("button");
await button.ClickAsync();
Assert.Equal("Clicked", await frame.EvaluateExpressionAsync <string>("window.result"));
}
public async Task PageWaitForSelectorAsyncIsShortcutForMainFrame()
{
await Page.GoToAsync(TestConstants.EmptyPage);
await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);
var otherFrame = Page.FirstChildFrame();
var watchdog = Page.WaitForSelectorAsync("div");
await otherFrame.EvaluateFunctionAsync(AddElement, "div");
await Page.EvaluateFunctionAsync(AddElement, "div");
var eHandle = await watchdog;
Assert.Equal(Page.MainFrame, eHandle.ExecutionContext.Frame);
}
public async Task ShouldReportFrameName()
{
await FrameUtils.AttachFrameAsync(Page, "theFrameId", TestConstants.EmptyPage);
await Page.EvaluateFunctionAsync(@"url => {
const frame = document.createElement('iframe');
frame.name = 'theFrameName';
frame.src = url;
document.body.appendChild(frame);
return new Promise(x => frame.onload = x);
}", TestConstants.EmptyPage);
Assert.Single(Page.Frames, frame => frame.Name == string.Empty);
Assert.Single(Page.Frames, frame => frame.Name == "theFrameId");
Assert.Single(Page.Frames, frame => frame.Name == "theFrameName");
}
