How to use EvaluateFunctionHandleAsync method of PuppeteerSharp.Frame class

Best Puppeteer-sharp code snippet using PuppeteerSharp.Frame.EvaluateFunctionHandleAsync

Frame.cs

Source:Frame.cs Github

copy

Full Screen

...207 var context = await GetExecutionContextAsync().ConfigureAwait(false);208 return await context.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);209 }210 /// <summary>211 /// Passes a function to the <see cref="ExecutionContext.EvaluateFunctionAsync(string, object[])"/>, returns a <see cref="Task"/>, then <see cref="ExecutionContext.EvaluateFunctionHandleAsync(string, object[])"/> would wait for the <see cref="Task"/> to resolve and return its value.212 /// </summary>213 /// <example>214 /// <code>215 /// var frame = page.MainFrame;216 /// const handle = Page.MainFrame.EvaluateFunctionHandleAsync("() => Promise.resolve(self)");217 /// return handle; // Handle for the global object.218 /// </code>219 /// <see cref="JSHandle"/> instances can be passed as arguments to the <see cref="ExecutionContext.EvaluateFunctionAsync(string, object[])"/>:220 /// 221 /// const handle = await Page.MainFrame.EvaluateExpressionHandleAsync("document.body");222 /// const resultHandle = await Page.MainFrame.EvaluateFunctionHandleAsync("body => body.innerHTML", handle);223 /// return await resultHandle.JsonValueAsync(); // prints body's innerHTML224 /// </example>225 /// <returns>Resolves to the return value of <paramref name="function"/></returns>226 /// <param name="function">Function to be evaluated in the <see cref="ExecutionContext"/></param>227 /// <param name="args">Arguments to pass to <paramref name="function"/></param>228 public async Task<JSHandle> EvaluateFunctionHandleAsync(string function, params object[] args)229 {230 var context = await GetExecutionContextAsync().ConfigureAwait(false);231 return await context.EvaluateFunctionHandleAsync(function, args).ConfigureAwait(false);232 }233 /// <summary>234 /// Gets the <see cref="ExecutionContext"/> associated with the frame.235 /// </summary>236 /// <returns><see cref="ExecutionContext"/> associated with the frame.</returns>237 public Task<ExecutionContext> GetExecutionContextAsync() => _contextResolveTaskWrapper.Task;238 /// <summary>239 /// Waits for a selector to be added to the DOM240 /// </summary>241 /// <param name="selector">A selector of an element to wait for</param>242 /// <param name="options">Optional waiting parameters</param>243 /// <returns>A task that resolves when element specified by selector string is added to DOM</returns>244 /// <seealso cref="WaitForXPathAsync(string, WaitForSelectorOptions)"/>245 /// <seealso cref="Page.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>246 /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>247 public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)248 => WaitForSelectorOrXPathAsync(selector, false, options);249 /// <summary>250 /// Waits for a selector to be added to the DOM251 /// </summary>252 /// <param name="xpath">A xpath selector of an element to wait for</param>253 /// <param name="options">Optional waiting parameters</param>254 /// <returns>A task that resolves when element specified by selector string is added to DOM</returns>255 /// <example>256 /// <code>257 /// <![CDATA[258 /// var browser = await Puppeteer.LaunchAsync(new LaunchOptions());259 /// var page = await browser.NewPageAsync();260 /// string currentURL = null;261 /// page.MainFrame262 /// .WaitForXPathAsync("//img")263 /// .ContinueWith(_ => Console.WriteLine("First URL with image: " + currentURL));264 /// foreach (var current in new[] { "https://example.com", "https://google.com", "https://bbc.com" })265 /// {266 /// currentURL = current;267 /// await page.GoToAsync(currentURL);268 /// }269 /// await browser.CloseAsync();270 /// ]]>271 /// </code>272 /// </example>273 /// <seealso cref="WaitForSelectorAsync(string, WaitForSelectorOptions)"/>274 /// <seealso cref="Page.WaitForXPathAsync(string, WaitForSelectorOptions)"/>275 /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>276 public Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)277 => WaitForSelectorOrXPathAsync(xpath, true, options);278 /// <summary>279 /// Waits for a timeout280 /// </summary>281 /// <param name="milliseconds"></param>282 /// <returns>A task that resolves when after the timeout</returns>283 /// <seealso cref="Page.WaitForTimeoutAsync(int)"/>284 /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>285 public Task WaitForTimeoutAsync(int milliseconds) => Task.Delay(milliseconds);286 /// <summary>287 /// Waits for a function to be evaluated to a truthy value288 /// </summary>289 /// <param name="script">Function to be evaluated in browser context</param>290 /// <param name="options">Optional waiting parameters</param>291 /// <param name="args">Arguments to pass to <c>script</c></param>292 /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>293 /// <seealso cref="Page.WaitForFunctionAsync(string, WaitForFunctionOptions, object[])"/>294 /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>295 public Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options, params object[] args)296 => new WaitTask(this, script, false, "function", options.Polling, options.PollingInterval, options.Timeout, args).Task;297 /// <summary>298 /// Waits for an expression to be evaluated to a truthy value299 /// </summary>300 /// <param name="script">Expression to be evaluated in browser context</param>301 /// <param name="options">Optional waiting parameters</param>302 /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>303 /// <seealso cref="Page.WaitForExpressionAsync(string, WaitForFunctionOptions)"/>304 /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>305 public Task<JSHandle> WaitForExpressionAsync(string script, WaitForFunctionOptions options)306 => new WaitTask(this, script, true, "function", options.Polling, options.PollingInterval, options.Timeout).Task;307 /// <summary>308 /// Triggers a change and input event once all the provided options have been selected. 309 /// If there's no <![CDATA[<select>]]> element matching selector, the method throws an error.310 /// </summary>311 /// <exception cref="SelectorException">If there's no element matching <paramref name="selector"/></exception>312 /// <param name="selector">A selector to query page for</param>313 /// <param name="values">Values of options to select. If the <![CDATA[<select>]]> has the multiple attribute, 314 /// all values are considered, otherwise only the first one is taken into account.</param>315 /// <returns>Returns an array of option values that have been successfully selected.</returns>316 /// <seealso cref="Page.SelectAsync(string, string[])"/>317 public Task<string[]> SelectAsync(string selector, params string[] values)318 => QuerySelectorAsync(selector).EvaluateFunctionAsync<string[]>(@"(element, values) => {319 if (element.nodeName.toLowerCase() !== 'select')320 throw new Error('Element is not a <select> element.');321 const options = Array.from(element.options);322 element.value = undefined;323 for (const option of options) {324 option.selected = values.includes(option.value);325 if (option.selected && !element.multiple)326 break;327 }328 element.dispatchEvent(new Event('input', { 'bubbles': true }));329 element.dispatchEvent(new Event('change', { 'bubbles': true }));330 return options.filter(option => option.selected).map(option => option.value);331 }", new[] { values });332 /// <summary>333 /// Queries frame for the selector. If there's no such element within the frame, the method will resolve to <c>null</c>.334 /// </summary>335 /// <param name="selector">Selector to query frame for</param>336 /// <returns>Task which resolves to <see cref="ElementHandle"/> pointing to the frame element</returns>337 /// <seealso cref="Page.QuerySelectorAsync(string)"/>338 public async Task<ElementHandle> QuerySelectorAsync(string selector)339 {340 var document = await GetDocument().ConfigureAwait(false);341 var value = await document.QuerySelectorAsync(selector).ConfigureAwait(false);342 return value;343 }344 /// <summary>345 /// Queries frame for the selector. If no elements match the selector, the return value resolve to <see cref="Array.Empty{T}"/>.346 /// </summary>347 /// <param name="selector">A selector to query frame for</param>348 /// <returns>Task which resolves to ElementHandles pointing to the frame elements</returns>349 /// <seealso cref="Page.QuerySelectorAllAsync(string)"/>350 public async Task<ElementHandle[]> QuerySelectorAllAsync(string selector)351 {352 var document = await GetDocument().ConfigureAwait(false);353 var value = await document.QuerySelectorAllAsync(selector).ConfigureAwait(false);354 return value;355 }356 /// <summary>357 /// Evaluates the XPath expression358 /// </summary>359 /// <param name="expression">Expression to evaluate <see href="https://developer.mozilla.org/en-US/docs/Web/API/Document/evaluate"/></param>360 /// <returns>Task which resolves to an array of <see cref="ElementHandle"/></returns>361 /// <seealso cref="Page.XPathAsync(string)"/>362 public async Task<ElementHandle[]> XPathAsync(string expression)363 {364 var document = await GetDocument().ConfigureAwait(false);365 var value = await document.XPathAsync(expression).ConfigureAwait(false);366 return value;367 }368 /// <summary>369 /// Adds a <c><![CDATA[<link rel="stylesheet">]]></c> tag into the page with the desired url or a <c><![CDATA[<link rel="stylesheet">]]></c> tag with the content370 /// </summary>371 /// <param name="options">add style tag options</param>372 /// <returns>Task which resolves to the added tag when the stylesheet's onload fires or when the CSS content was injected into frame</returns>373 /// <seealso cref="Page.AddStyleTagAsync(AddTagOptions)"/>374 /// <seealso cref="Page.AddStyleTagAsync(string)"/>375 public async Task<ElementHandle> AddStyleTag(AddTagOptions options)376 {377 const string addStyleUrl = @"async function addStyleUrl(url) {378 const link = document.createElement('link');379 link.rel = 'stylesheet';380 link.href = url;381 const promise = new Promise((res, rej) => {382 link.onload = res;383 link.onerror = rej;384 });385 document.head.appendChild(link);386 await promise;387 return link;388 }";389 const string addStyleContent = @"async function addStyleContent(content) {390 const style = document.createElement('style');391 style.type = 'text/css';392 style.appendChild(document.createTextNode(content));393 const promise = new Promise((res, rej) => {394 style.onload = res;395 style.onerror = rej;396 });397 document.head.appendChild(style);398 await promise;399 return style;400 }";401 if (!string.IsNullOrEmpty(options.Url))402 {403 var url = options.Url;404 try405 {406 var context = await GetExecutionContextAsync().ConfigureAwait(false);407 return (await context.EvaluateFunctionHandleAsync(addStyleUrl, url).ConfigureAwait(false)) as ElementHandle;408 }409 catch (PuppeteerException)410 {411 throw new PuppeteerException($"Loading style from {url} failed");412 }413 }414 if (!string.IsNullOrEmpty(options.Path))415 {416 var contents = await AsyncFileHelper.ReadAllText(options.Path).ConfigureAwait(false);417 contents += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);418 var context = await GetExecutionContextAsync().ConfigureAwait(false);419 return (await context.EvaluateFunctionHandleAsync(addStyleContent, contents).ConfigureAwait(false)) as ElementHandle;420 }421 if (!string.IsNullOrEmpty(options.Content))422 {423 var context = await GetExecutionContextAsync().ConfigureAwait(false);424 return (await context.EvaluateFunctionHandleAsync(addStyleContent, options.Content).ConfigureAwait(false)) as ElementHandle;425 }426 throw new ArgumentException("Provide options with a `Url`, `Path` or `Content` property");427 }428 /// <summary>429 /// Adds a <c><![CDATA[<script>]]></c> tag into the page with the desired url or content430 /// </summary>431 /// <param name="options">add script tag options</param>432 /// <returns>Task which resolves to the added tag when the script's onload fires or when the script content was injected into frame</returns>433 /// <seealso cref="Page.AddScriptTagAsync(AddTagOptions)"/>434 /// <seealso cref="Page.AddScriptTagAsync(string)"/>435 public async Task<ElementHandle> AddScriptTag(AddTagOptions options)436 {437 const string addScriptUrl = @"async function addScriptUrl(url, type) {438 const script = document.createElement('script');439 script.src = url;440 if(type)441 script.type = type;442 const promise = new Promise((res, rej) => {443 script.onload = res;444 script.onerror = rej;445 });446 document.head.appendChild(script);447 await promise;448 return script;449 }";450 const string addScriptContent = @"function addScriptContent(content, type = 'text/javascript') {451 const script = document.createElement('script');452 script.type = type;453 script.text = content;454 let error = null;455 script.onerror = e => error = e;456 document.head.appendChild(script);457 if (error)458 throw error;459 return script;460 }";461 async Task<ElementHandle> AddScriptTagPrivate(string script, string urlOrContent, string type)462 {463 var context = await GetExecutionContextAsync().ConfigureAwait(false);464 return (string.IsNullOrEmpty(type)465 ? await context.EvaluateFunctionHandleAsync(script, urlOrContent).ConfigureAwait(false)466 : await context.EvaluateFunctionHandleAsync(script, urlOrContent, type).ConfigureAwait(false)) as ElementHandle;467 }468 if (!string.IsNullOrEmpty(options.Url))469 {470 var url = options.Url;471 try472 {473 return await AddScriptTagPrivate(addScriptUrl, url, options.Type).ConfigureAwait(false);474 }475 catch (PuppeteerException)476 {477 throw new PuppeteerException($"Loading script from {url} failed");478 }479 }480 if (!string.IsNullOrEmpty(options.Path))...

Full Screen

Full Screen

ElementHandle.cs

Source:ElementHandle.cs Github

copy

Full Screen

...239 /// <param name="selector">A selector to query element for</param>240 /// <returns>Task which resolves to <see cref="ElementHandle"/> pointing to the frame element</returns>241 public async Task<ElementHandle> QuerySelectorAsync(string selector)242 {243 var handle = await ExecutionContext.EvaluateFunctionHandleAsync(244 "(element, selector) => element.querySelector(selector)",245 this, selector).ConfigureAwait(false);246 if (handle is ElementHandle element)247 {248 return element;249 }250 await handle.DisposeAsync().ConfigureAwait(false);251 return null;252 }253 /// <summary>254 /// Runs <c>element.querySelectorAll</c> within the page. If no elements match the selector, the return value resolve to <see cref="Array.Empty{T}"/>.255 /// </summary>256 /// <param name="selector">A selector to query element for</param>257 /// <returns>Task which resolves to ElementHandles pointing to the frame elements</returns>258 public async Task<ElementHandle[]> QuerySelectorAllAsync(string selector)259 {260 var arrayHandle = await ExecutionContext.EvaluateFunctionHandleAsync(261 "(element, selector) => element.querySelectorAll(selector)",262 this, selector).ConfigureAwait(false);263 var properties = await arrayHandle.GetPropertiesAsync().ConfigureAwait(false);264 await arrayHandle.DisposeAsync().ConfigureAwait(false);265 return properties.Values.OfType<ElementHandle>().ToArray();266 }267 /// <summary>268 /// A utility function to be used with <see cref="Extensions.EvaluateFunctionAsync{T}(Task{JSHandle}, string, object[])"/>269 /// </summary>270 /// <param name="selector">A selector to query element for</param>271 /// <returns>Task which resolves to a <see cref="JSHandle"/> of <c>document.querySelectorAll</c> result</returns>272 public Task<JSHandle> QuerySelectorAllHandleAsync(string selector)273 => ExecutionContext.EvaluateFunctionHandleAsync(274 "(element, selector) => Array.from(element.querySelectorAll(selector))", this, selector);275 /// <summary>276 /// Evaluates the XPath expression relative to the elementHandle. If there's no such element, the method will resolve to <c>null</c>.277 /// </summary>278 /// <param name="expression">Expression to evaluate <see href="https://developer.mozilla.org/en-US/docs/Web/API/Document/evaluate"/></param>279 /// <returns>Task which resolves to an array of <see cref="ElementHandle"/></returns>280 public async Task<ElementHandle[]> XPathAsync(string expression)281 {282 var arrayHandle = await ExecutionContext.EvaluateFunctionHandleAsync(283 @"(element, expression) => {284 const document = element.ownerDocument || element;285 const iterator = document.evaluate(expression, element, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE);286 const array = [];287 let item;288 while ((item = iterator.iterateNext()))289 array.push(item);290 return array;291 }",292 this, expression293 ).ConfigureAwait(false);294 var properties = await arrayHandle.GetPropertiesAsync().ConfigureAwait(false);295 await arrayHandle.DisposeAsync().ConfigureAwait(false);296 return properties.Values.OfType<ElementHandle>().ToArray();...

Full Screen

Full Screen

EvaluateTests.cs

Source:EvaluateTests.cs Github

copy

Full Screen

...177 }178 [Fact]179 public async Task ShouldBeAbleToThrowATrickyError()180 {181 var windowHandle = await Page.EvaluateFunctionHandleAsync("() => window");182 PuppeteerException exception = await Assert.ThrowsAsync<MessageException>(() => windowHandle.JsonValueAsync());183 var errorText = exception.Message;184 exception = await Assert.ThrowsAsync<EvaluationFailedException>(() => Page.EvaluateFunctionAsync(@"errorText =>185 {186 throw new Error(errorText);187 }", errorText));188 Assert.Contains(errorText, exception.Message);189 }190 [Theory]191 [InlineData("1 + 5;", 6)] //ShouldAcceptSemiColons192 [InlineData("2 + 5\n// do some math!'", 7)] //ShouldAceptStringComments193 public async Task BasicIntExressionEvaluationTest(string script, object expected)194 {195 var result = await Page.EvaluateExpressionAsync<int>(script);196 Assert.Equal(expected, result);197 }198 [Fact]199 public async Task ShouldAcceptElementHandleAsAnArgument()200 {201 await Page.SetContentAsync("<section>42</section>");202 var element = await Page.QuerySelectorAsync("section");203 var text = await Page.EvaluateFunctionAsync<string>("e => e.textContent", element);204 Assert.Equal("42", text);205 }206 [Fact]207 public async Task ShouldThrowIfUnderlyingElementWasDisposed()208 {209 await Page.SetContentAsync("<section>39</section>");210 var element = await Page.QuerySelectorAsync("section");211 Assert.NotNull(element);212 await element.DisposeAsync();213 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()214 => Page.EvaluateFunctionAsync<string>("e => e.textContent", element));215 Assert.Contains("JSHandle is disposed", exception.Message);216 }217 [Fact]218 public async Task ShouldThrowIfElementHandlesAreFromOtherFrames()219 {220 await FrameUtils.AttachFrameAsync(Page, "frame1", TestConstants.EmptyPage);221 var bodyHandle = await Page.FirstChildFrame().QuerySelectorAsync("body");222 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()223 => Page.EvaluateFunctionAsync<string>("body => body.innerHTML", bodyHandle));224 Assert.Contains("JSHandles can be evaluated only in the context they were created", exception.Message);225 }226 [Fact]227 public async Task ShouldSimulateAUserGesture()228 => Assert.True(await Page.EvaluateFunctionAsync<bool>(@"() => {229 document.body.appendChild(document.createTextNode('test'));230 document.execCommand('selectAll');231 return document.execCommand('copy'); 232 }"));233 [Fact]234 public async Task ShouldThrowANiceErrorAfterANavigation()235 {236 var executionContext = await Page.MainFrame.GetExecutionContextAsync();237 await Task.WhenAll(238 Page.WaitForNavigationAsync(),239 executionContext.EvaluateFunctionAsync("() => window.location.reload()")240 );241 var ex = await Assert.ThrowsAsync<EvaluationFailedException>(() =>242 {243 return executionContext.EvaluateFunctionAsync("() => null");244 });245 Assert.Contains("navigation", ex.Message);246 }247 [Fact]248 public async Task ShouldNotThrowAnErrorWhenEvaluationDoesANavigation()249 {250 await Page.GoToAsync(TestConstants.ServerUrl + "/one-style.html");251 var result = await Page.EvaluateFunctionAsync<int[]>(@"() =>252 {253 window.location = '/empty.html';254 return [42];255 }");256 Assert.Equal(new[] { 42 }, result);257 }258 /// <summary>259 /// Original Name "should transfer 100Mb of data from page to node.js"260 /// </summary>261 [Fact]262 public async Task ShouldTransfer100MbOfDataFromPage()263 {264 var a = await Page.EvaluateFunctionAsync<string>("() => Array(100 * 1024 * 1024 + 1).join('a')");265 Assert.Equal(100 * 1024 * 1024, a.Length);266 }267 [Fact]268 public async Task ShouldThrowErrorWithDetailedInformationOnExceptionInsidePromise()269 {270 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>271 Page.EvaluateFunctionAsync(272 @"() => new Promise(() => {273 throw new Error('Error in promise');274 })"));275 Assert.Contains("Error in promise", exception.Message);276 }277 [Fact]278 public async Task ShouldWorkWithDifferentSerializerSettings()279 {280 var result = await Page.EvaluateFunctionAsync<ComplexObjectTestClass>("() => { return { foo: 'bar' }}");281 Assert.Equal("bar", result.Foo);282 result = (await Page.EvaluateFunctionAsync<JToken>("() => { return { Foo: 'bar' }}"))283 .ToObject<ComplexObjectTestClass>(new JsonSerializerSettings());284 Assert.Equal("bar", result.Foo);285 result = await Page.EvaluateExpressionAsync<ComplexObjectTestClass>("var obj = { foo: 'bar' }; obj;");286 Assert.Equal("bar", result.Foo);287 result = (await Page.EvaluateExpressionAsync<JToken>("var obj = { Foo: 'bar' }; obj;"))288 .ToObject<ComplexObjectTestClass>(new JsonSerializerSettings());289 Assert.Equal("bar", result.Foo);290 }291 [Fact]292 public async Task ShouldProperlyIgnoreUndefinedFields()293 {294 var result = await Page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: undefined})");295 Assert.Empty(result);296 }297 [Fact]298 public async Task ShouldProperlySerializeNullFields()299 {300 var result = await Page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: null})");301 Assert.True(result.ContainsKey("a"));302 Assert.Null(result["a"]);303 }304 [Fact]305 public async Task ShouldAcceptObjectHandleAsAnArgument()306 {307 var navigatorHandle = await Page.EvaluateExpressionHandleAsync("navigator");308 var text = await Page.EvaluateFunctionAsync<string>("e => e.userAgent", navigatorHandle);309 Assert.Contains("Mozilla", text);310 }311 [Fact]312 public async Task ShouldAcceptObjectHandleToPrimitiveTypes()313 {314 var aHandle = await Page.EvaluateExpressionHandleAsync("5");315 var isFive = await Page.EvaluateFunctionAsync<bool>("e => Object.is(e, 5)", aHandle);316 Assert.True(isFive);317 }318 [Fact]319 public async Task ShouldWarnOnNestedObjectHandles()320 {321 var handle = await Page.EvaluateFunctionHandleAsync("() => document.body");322 var elementHandle = handle as ElementHandle;323 var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()324 => Page.EvaluateFunctionHandleAsync(325 "opts => opts.elem.querySelector('p')",326 new { elem = handle }));327 Assert.Contains("Are you passing a nested JSHandle?", exception.Message);328 //Check with ElementHandle329 exception = await Assert.ThrowsAsync<EvaluationFailedException>(()330 => Page.EvaluateFunctionHandleAsync(331 "opts => opts.elem.querySelector('p')",332 new { elem = elementHandle }));333 Assert.Contains("Are you passing a nested JSHandle?", exception.Message);334 }335 [Fact]336 public async Task ShouldWorkWithoutGenerics()337 {338 Assert.NotNull(await Page.EvaluateExpressionAsync("var obj = {}; obj;"));339 Assert.NotNull(await Page.EvaluateExpressionAsync("[]"));340 Assert.NotNull(await Page.EvaluateExpressionAsync("''"));341 var objectPopulated = await Page.EvaluateExpressionAsync("var obj = {a:1}; obj;");342 Assert.NotNull(objectPopulated);343 Assert.Equal(1, objectPopulated["a"]);344 var arrayPopulated = await Page.EvaluateExpressionAsync("[1]");...

Full Screen

Full Screen

DOMWorld.cs

Source:DOMWorld.cs Github

copy

Full Screen

...60 {61 var context = await GetExecutionContextAsync().ConfigureAwait(false);62 return await context.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);63 }64 internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params object[] args)65 {66 var context = await GetExecutionContextAsync().ConfigureAwait(false);67 return await context.EvaluateFunctionHandleAsync(script, args).ConfigureAwait(false);68 }69 internal async Task<T> EvaluateExpressionAsync<T>(string script)70 {71 var context = await GetExecutionContextAsync().ConfigureAwait(false);72 return await context.EvaluateExpressionAsync<T>(script).ConfigureAwait(false);73 }74 internal async Task<JToken> EvaluateExpressionAsync(string script)75 {76 var context = await GetExecutionContextAsync().ConfigureAwait(false);77 return await context.EvaluateExpressionAsync(script).ConfigureAwait(false);78 }79 internal async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)80 {81 var context = await GetExecutionContextAsync().ConfigureAwait(false);82 return await context.EvaluateFunctionAsync<T>(script, args).ConfigureAwait(false);83 }84 internal async Task<JToken> EvaluateFunctionAsync(string script, params object[] args)85 {86 var context = await GetExecutionContextAsync().ConfigureAwait(false);87 return await context.EvaluateFunctionAsync(script, args).ConfigureAwait(false);88 }89 internal Task<string> GetContentAsync() => EvaluateFunctionAsync<string>(@"() => {90 let retVal = '';91 if (document.doctype)92 retVal = new XMLSerializer().serializeToString(document.doctype);93 if (document.documentElement)94 retVal += document.documentElement.outerHTML;95 return retVal;96 }");97 internal async Task SetContentAsync(string html, NavigationOptions options = null)98 {99 var waitUntil = options?.WaitUntil ?? new[] { WaitUntilNavigation.Load };100 var timeout = options?.Timeout ?? _timeoutSettings.NavigationTimeout;101 // We rely upon the fact that document.open() will reset frame lifecycle with "init"102 // lifecycle event. @see https://crrev.com/608658103 await EvaluateFunctionAsync(@"html => {104 document.open();105 document.write(html);106 document.close();107 }", html).ConfigureAwait(false);108 using (var watcher = new LifecycleWatcher(_frameManager, Frame, waitUntil, timeout))109 {110 var watcherTask = await Task.WhenAny(111 watcher.TimeoutOrTerminationTask,112 watcher.LifecycleTask).ConfigureAwait(false);113 await watcherTask.ConfigureAwait(false);114 }115 }116 internal async Task<ElementHandle> AddScriptTagAsync(AddTagOptions options)117 {118 const string addScriptUrl = @"async function addScriptUrl(url, type) {119 const script = document.createElement('script');120 script.src = url;121 if(type)122 script.type = type;123 const promise = new Promise((res, rej) => {124 script.onload = res;125 script.onerror = rej;126 });127 document.head.appendChild(script);128 await promise;129 return script;130 }";131 const string addScriptContent = @"function addScriptContent(content, type = 'text/javascript') {132 const script = document.createElement('script');133 script.type = type;134 script.text = content;135 let error = null;136 script.onerror = e => error = e;137 document.head.appendChild(script);138 if (error)139 throw error;140 return script;141 }";142 async Task<ElementHandle> AddScriptTagPrivate(string script, string urlOrContent, string type)143 {144 var context = await GetExecutionContextAsync().ConfigureAwait(false);145 return (string.IsNullOrEmpty(type)146 ? await context.EvaluateFunctionHandleAsync(script, urlOrContent).ConfigureAwait(false)147 : await context.EvaluateFunctionHandleAsync(script, urlOrContent, type).ConfigureAwait(false)) as ElementHandle;148 }149 if (!string.IsNullOrEmpty(options.Url))150 {151 var url = options.Url;152 try153 {154 return await AddScriptTagPrivate(addScriptUrl, url, options.Type).ConfigureAwait(false);155 }156 catch (PuppeteerException)157 {158 throw new PuppeteerException($"Loading script from {url} failed");159 }160 }161 if (!string.IsNullOrEmpty(options.Path))162 {163 var contents = await AsyncFileHelper.ReadAllText(options.Path).ConfigureAwait(false);164 contents += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);165 return await AddScriptTagPrivate(addScriptContent, contents, options.Type).ConfigureAwait(false);166 }167 if (!string.IsNullOrEmpty(options.Content))168 {169 return await AddScriptTagPrivate(addScriptContent, options.Content, options.Type).ConfigureAwait(false);170 }171 throw new ArgumentException("Provide options with a `Url`, `Path` or `Content` property");172 }173 internal async Task<ElementHandle> AddStyleTagAsync(AddTagOptions options)174 {175 const string addStyleUrl = @"async function addStyleUrl(url) {176 const link = document.createElement('link');177 link.rel = 'stylesheet';178 link.href = url;179 const promise = new Promise((res, rej) => {180 link.onload = res;181 link.onerror = rej;182 });183 document.head.appendChild(link);184 await promise;185 return link;186 }";187 const string addStyleContent = @"async function addStyleContent(content) {188 const style = document.createElement('style');189 style.type = 'text/css';190 style.appendChild(document.createTextNode(content));191 const promise = new Promise((res, rej) => {192 style.onload = res;193 style.onerror = rej;194 });195 document.head.appendChild(style);196 await promise;197 return style;198 }";199 if (!string.IsNullOrEmpty(options.Url))200 {201 var url = options.Url;202 try203 {204 var context = await GetExecutionContextAsync().ConfigureAwait(false);205 return (await context.EvaluateFunctionHandleAsync(addStyleUrl, url).ConfigureAwait(false)) as ElementHandle;206 }207 catch (PuppeteerException)208 {209 throw new PuppeteerException($"Loading style from {url} failed");210 }211 }212 if (!string.IsNullOrEmpty(options.Path))213 {214 var contents = await AsyncFileHelper.ReadAllText(options.Path).ConfigureAwait(false);215 contents += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);216 var context = await GetExecutionContextAsync().ConfigureAwait(false);217 return (await context.EvaluateFunctionHandleAsync(addStyleContent, contents).ConfigureAwait(false)) as ElementHandle;218 }219 if (!string.IsNullOrEmpty(options.Content))220 {221 var context = await GetExecutionContextAsync().ConfigureAwait(false);222 return (await context.EvaluateFunctionHandleAsync(addStyleContent, options.Content).ConfigureAwait(false)) as ElementHandle;223 }224 throw new ArgumentException("Provide options with a `Url`, `Path` or `Content` property");225 }226 internal Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)227 => WaitForSelectorOrXPathAsync(selector, false, options);228 internal Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)229 => WaitForSelectorOrXPathAsync(xpath, true, options);230 internal Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options, params object[] args)231 => new WaitTask(232 this,233 script,234 false,235 "function",236 options.Polling,...

Full Screen

Full Screen

ExecutionContext.cs

Source:ExecutionContext.cs Github

copy

Full Screen

...69 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.70 /// <see cref="JSHandle"/> instances can be passed as arguments71 /// </remarks>72 /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>73 /// <seealso cref="EvaluateFunctionHandleAsync(string, object[])"/>74 /// <returns>Task which resolves to script return value</returns>75 public Task<JToken> EvaluateFunctionAsync(string script, params object[] args)76 => EvaluateAsync<JToken>(EvaluateFunctionHandleAsync(script, args));77 /// <summary>78 /// Executes a function in browser context79 /// </summary>80 /// <typeparam name="T">The type to deserialize the result to</typeparam>81 /// <param name="script">Script to be evaluated in browser context</param>82 /// <param name="args">Arguments to pass to script</param>83 /// <remarks>84 /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.85 /// <see cref="JSHandle"/> instances can be passed as arguments86 /// </remarks>87 /// <seealso cref="EvaluateExpressionAsync{T}(string)"/>88 /// <seealso cref="EvaluateFunctionHandleAsync(string, object[])"/>89 /// <returns>Task which resolves to script return value</returns>90 public Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)91 => EvaluateAsync<T>(EvaluateFunctionHandleAsync(script, args));92 /// <summary>93 /// The method iterates JavaScript heap and finds all the objects with the given prototype.94 /// </summary>95 /// <returns>A task which resolves to a handle to an array of objects with this prototype.</returns>96 /// <param name="prototypeHandle">A handle to the object prototype.</param>97 public async Task<JSHandle> QueryObjectsAsync(JSHandle prototypeHandle)98 {99 if (prototypeHandle.Disposed)100 {101 throw new PuppeteerException("Prototype JSHandle is disposed!");102 }103 if (!((JObject)prototypeHandle.RemoteObject).TryGetValue(MessageKeys.ObjectId, out var objectId))104 {105 throw new PuppeteerException("Prototype JSHandle must not be referencing primitive value");106 }107 var response = await _client.SendAsync("Runtime.queryObjects", new Dictionary<string, object>108 {109 {"prototypeObjectId", objectId.ToString()}110 }).ConfigureAwait(false);111 return CreateJSHandle(response[MessageKeys.Objects]);112 }113 internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)114 {115 if (string.IsNullOrEmpty(script))116 {117 return null;118 }119 try120 {121 return await EvaluateHandleAsync("Runtime.evaluate", new Dictionary<string, object>122 {123 ["expression"] = _sourceUrlRegex.IsMatch(script) ? script : $"{script}\n{EvaluationScriptSuffix}",124 ["contextId"] = _contextId,125 ["returnByValue"] = false,126 ["awaitPromise"] = true,127 ["userGesture"] = true128 }).ConfigureAwait(false);129 }130 catch (Exception ex)131 {132 throw new EvaluationFailedException(ex.Message, ex);133 }134 }135 internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params object[] args)136 {137 if (string.IsNullOrEmpty(script))138 {139 return null;140 }141 try142 {143 return await EvaluateHandleAsync("Runtime.callFunctionOn", new Dictionary<string, object>144 {145 ["functionDeclaration"] = $"{script}\n{EvaluationScriptSuffix}\n",146 [MessageKeys.ExecutionContextId] = _contextId,147 ["arguments"] = args.Select(FormatArgument),148 ["returnByValue"] = false,149 ["awaitPromise"] = true,...

Full Screen

Full Screen

PageExtensions.cs

Source:PageExtensions.cs Github

copy

Full Screen

...17 /// <returns>Task which resolves to <see cref="ElementHandle"/> pointing to the frame element</returns>18 /// <seealso href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp"/>19 public static async Task<ElementHandle> QuerySelectorWithContentAsync(this Page page, string selector, string regex, string flags = "")20 {21 return await page.GuardFromNull().EvaluateFunctionHandleAsync(22 @"(selector, regex, flags) => {23 var elements = document.querySelectorAll(selector);24 return Array.prototype.find.call(elements, function(element) {25 return RegExp(regex, flags).test(element.textContent);26 });27 }", selector, regex, flags).ConfigureAwait(false) as ElementHandle;28 }29 /// <summary>30 /// The method runs <c>document.querySelectorAll</c> within the page and then tests a <c>RegExp</c> against the elements <c>textContent</c>. All element matches are returned. If no element matches the selector and regular expression, the return value resolve to <see cref="System.Array.Empty{T}"/>.31 /// </summary>32 /// <param name="page">A <see cref="Page"/> to query</param>33 /// <param name="selector">A selector to query page for</param>34 /// <param name="regex">A regular expression to test against <c>element.textContent</c></param>35 /// <param name="flags">A set of flags for the regular expression</param>36 /// <returns>Task which resolves to ElementHandles pointing to the frame elements</returns>37 /// <seealso href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp"/>38 public static async Task<ElementHandle[]> QuerySelectorAllWithContentAsync(this Page page, string selector, string regex, string flags = "")39 {40 var arrayHandle = await page.GuardFromNull().EvaluateFunctionHandleAsync(41 @"(selector, regex, flags) => {42 var elements = document.querySelectorAll(selector);43 return Array.prototype.filter.call(elements, function(element) {44 return RegExp(regex, flags).test(element.textContent);45 });46 }", selector, regex, flags).ConfigureAwait(false);47 var properties = await arrayHandle.GetPropertiesAsync().ConfigureAwait(false);48 await arrayHandle.DisposeAsync().ConfigureAwait(false);49 return properties.Values.OfType<ElementHandle>().ToArray();50 }51 /// <summary>52 /// Indicates whether the page has the specified content or not.53 /// </summary>54 /// <param name="page">A <see cref="Page"/></param>...

Full Screen

Full Screen

BoxModelTests.cs

Source:BoxModelTests.cs Github

copy

Full Screen

...27 top: 2px;28 `;");29 // Step 2: Add div and position it absolutely inside frame.30 var frame = Page.FirstChildFrame();31 var divHandle = (ElementHandle)await frame.EvaluateFunctionHandleAsync(@"() => {32 const div = document.createElement('div');33 document.body.appendChild(div);34 div.style = `35 box-sizing: border-box;36 position: absolute;37 border-left: 1px solid black;38 padding-left: 2px;39 margin-left: 3px;40 left: 4px;41 top: 5px;42 width: 6px;43 height: 7px;44 `;45 return div;...

Full Screen

Full Screen

FrameUtils.cs

Source:FrameUtils.cs Github

copy

Full Screen

...6 public static class FrameUtils7 {8 public static async Task<Frame> AttachFrameAsync(Page page, string frameId, string url)9 {10 var handle = await page.EvaluateFunctionHandleAsync(@" async (frameId, url) => {11 const frame = document.createElement('iframe');12 frame.src = url;13 frame.id = frameId;14 document.body.appendChild(frame);15 await new Promise(x => frame.onload = x);16 return frame17 }", frameId, url) as ElementHandle;18 return await handle.ContentFrameAsync();19 }20 public static async Task DetachFrameAsync(Page page, string frameId)21 {22 await page.EvaluateFunctionAsync(@"function detachFrame(frameId) {23 const frame = document.getElementById(frameId);24 frame.remove();...

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 var browser = await Puppeteer.LaunchAsync(new LaunchOptions9 {10 });11 var page = await browser.NewPageAsync();12 var result = await page.EvaluateFunctionHandleAsync("function() { return 1; }");13 Console.WriteLine(result);14 await browser.CloseAsync();15 }16 }17}18Your name to display (optional):19Your name to display (optional):20using System;21using System.Threading.Tasks;22using PuppeteerSharp;23{24 {25 static async Task Main(string[] args)26 {27 var browser = await Puppeteer.LaunchAsync(new LaunchOptions28 {29 });30 var page = await browser.NewPageAsync();31 var result = await page.EvaluateFunctionHandleAsync("function() { return 1; }");32 Console.WriteLine(result);33 await browser.CloseAsync();34 }35 }36}37Your name to display (optional):

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);9 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false }))10 {11 var page = await browser.NewPageAsync();12 await page.EvaluateFunctionHandleAsync("() => document.querySelector('input').value = 'PuppeteerSharp'");13 Console.ReadLine();14 }15 }16 }17}18using System;19using System.Threading.Tasks;20using PuppeteerSharp;21{22 {23 static async Task Main(string[] args)24 {25 await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);26 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false }))27 {28 var page = await browser.NewPageAsync();29 await page.EvaluateFunctionHandleAsync("() => document.querySelector('input').value = 'PuppeteerSharp'");30 Console.ReadLine();31 }32 }33 }34}35using System;36using System.Threading.Tasks;37using PuppeteerSharp;38{39 {40 static async Task Main(string[] args)41 {42 await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);43 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false }))44 {45 var page = await browser.NewPageAsync();46 var frame = page.MainFrame;47 await frame.EvaluateFunctionHandleAsync("() => document.querySelector('input').value = 'PuppeteerSharp'");48 Console.ReadLine();49 }50 }51 }52}53using System;54using System.Threading.Tasks;55using PuppeteerSharp;56{

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.IO;3using System.Threading.Tasks;4using PuppeteerSharp;5{6 {7 static async Task Main(string[] args)8 {9 var option = new LaunchOptions { Headless = true };10 var browser = await Puppeteer.LaunchAsync(option);11 var page = await browser.NewPageAsync();12 await page.EvaluateFunctionHandleAsync("() => document.body.style.backgroundColor = 'red'");13 await page.ScreenshotAsync("1.png");14 Console.WriteLine("Screenshot saved to 1.png");15 await browser.CloseAsync();16 }17 }18}

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1var puppeteer = require("puppeteer");2var fs = require("fs");3var path = require("path");4var pathToExtension = path.join(__dirname, "extension");5var extensionFiles = fs.readdirSync(pathToExtension);6var extension = {};7extensionFiles.forEach(function (file) {8 var filePath = path.join(pathToExtension, file);9 var stat = fs.statSync(filePath);10 if (stat.isFile()) {11 extension[file] = fs.readFileSync(filePath, "utf8");12 }13});14var browser = await puppeteer.launch({15});16var page = await browser.newPage();17await page.goto(url);18await page.waitFor(5000);19await page.evaluate(() => {20 var element = document.querySelector("#hplogo");21 element.style.border = "10px solid red";22});23var frame = page.mainFrame();24var handle = await frame.evaluateHandle(() => {25 var element = document.querySelector("#hplogo");26 return element;27});28var result = await frame.evaluateHandle(29 (element) => {30 return element.style.border;31 },32);33var border = await result.jsonValue();34console.log(border);35await browser.close();

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static void Main(string[] args)7 {8 MainAsync().GetAwaiter().GetResult();9 }10 static async Task MainAsync()11 {12 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false }))13 {14 var page = await browser.NewPageAsync();15 var title = await page.EvaluateFunctionHandleAsync(@"() => {16 return document.title;17 }");18 Console.WriteLine(title);19 }20 }21 }22}23using System;24using System.Threading.Tasks;25using PuppeteerSharp;26{27 {28 static void Main(string[] args)29 {30 MainAsync().GetAwaiter().GetResult();31 }32 static async Task MainAsync()33 {34 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = false }))35 {36 var page = await browser.NewPageAsync();37 var title = await page.EvaluateFunctionHandleAsync(@"() => {38 return document.title;39 }");40 var value = await title.JsonValueAsync();41 Console.WriteLine(value);42 }43 }44 }45}46using System;47using System.Threading.Tasks;48using PuppeteerSharp;49{50 {51 static void Main(string[] args)52 {53 MainAsync().GetAwaiter().GetResult();54 }55 static async Task MainAsync()56 {57 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static void Main(string[] args)7 {8 MainAsync().Wait();9 }10 static async Task MainAsync()11 {12 var browser = await Puppeteer.LaunchAsync(new LaunchOptions13 {14 });15 var page = await browser.NewPageAsync();16 var elementHandle = await page.QuerySelectorAsync("input[name=search]");17 var searchValue = await page.EvaluateFunctionHandleAsync<string>(@"(element) => {18 element.value = 'Puppeteer';19 return element.value;20 }", elementHandle);21 Console.WriteLine(searchValue);22 await browser.CloseAsync();23 }24 }25}

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using PuppeteerSharp;2{3 {4 static void Main(string[] args)5 {6 EvaluateFunctionHandleAsync().Wait();7 }8 private static async Task EvaluateFunctionHandleAsync()9 {10 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions11 {12 Args = new string[] { "--no-sandbox" }13 }))14 {15 var page = await browser.NewPageAsync();16 await page.SetViewportAsync(new ViewPortOptions { Width = 1366, Height = 768 });17 var functionHandle = await page.EvaluateFunctionHandleAsync("() => { return document.body; }");18 var value = await functionHandle.JsonValueAsync();19 Console.WriteLine(value);20 }21 }22 }23}

Full Screen

Full Screen

EvaluateFunctionHandleAsync

Using AI Code Generation

copy

Full Screen

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5 {6 static async Task Main(string[] args)7 {8 await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);9 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true }))10 using (var page = await browser.NewPageAsync())11 {12 var title = await page.EvaluateFunctionHandleAsync("() => document.title");13 Console.WriteLine(await page.EvaluateFunctionAsync<string>("x => x", title));14 }15 }16 }17}18using System;19using System.Threading.Tasks;20using PuppeteerSharp;21{22 {23 static async Task Main(string[] args)24 {25 await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);26 using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true }))27 using (var page = await browser.NewPageAsync())28 {29 var title = await page.EvaluateFunctionHandleAsync("() => document.title");30 var element = await page.EvaluateFunctionHandleAsync("() => document.body");31 Console.WriteLine(await page.EvaluateFunctionAsync<string>("(x, y) => x === y, title, element"));32 }33 }34 }35}

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful