playwright/docs/verification.md

Scraping and verification

Playwright allows verifiying state of the page and catching abnormal behavior by:

• evaluating JavaScript code snippets in the page
• capturing screenshots (png or jpeg)
• listening console messages
• observing uncaghut exceptions in the page
• observing page crashes
• etc

Contents

• Evaluating JavaScript
• Capturing screenshot
• Listening console messages
• Uncaghut exceptions
• Page crashes

Evaluating JavaScript

Execute JavaScript function in the page:

  const href = await page.evaluate(() => document.location.href);

If the result is a Promise or if the function is asynchronouse eveluate will automatically wait until it's resolved:

  const status = await page.evaluate(async () => {
    const response = await fetch(location.href);
    return response.status;
  });

Get object handle and use it in multiple evaluations:

  // Create a new array in the page, wriate a reference to it in
  // window.myArray and get a handle to it.
  const myArrayHandle = await page.evaluateHandle(() => {
    window.myArray = [1];
    return myArray;
  });

  // Get current length of the array using the handle.
  const length = await page.evaluate(
    (arg) => arg.myArray.length,
    { myArray: myArrayHandle }
  );

  // Add one more element to the array using the handle
  await page.evaluate((arg) => arg.myArray.push(arg.newElement), {
    myArray:myArrayHandle,
    newElement: 2
  });

  // Get current length of the array using window.myArray reference.
  const newLength = await page.evaluate(() => window.myArray.length);

  // Release the object when it's no longer needed.
  await myArrayHandle.dispose();

API reference

• page.$(selector)
• page.$$(selector)
• page.$eval(selector, pageFunction[, arg])
• page.$$eval(selector, pageFunction[, arg])
• page.evaluate(pageFunction[, arg])
• page.evaluateHandle(pageFunction[, arg])

Capturing screenshot

Take screenshot of the page's viewport and save it in a png file:

  await page.screenshot({path: 'screenshot.png'});

Capture entire scrollable area of the page:

  await page.screenshot({path: 'screenshot.png', fullPage: true});

Save screenshot in an in-memory buffer (the content is base64-encoded image bytes):

  const buffer = await page.screenshot();
  // Log the length.
  console.log(buffer.length);

API reference

• page.screenshot([options])
• Node.js Buffer

Listening console messages

Listen all console messages in a page and dump errors in to the terminal:

  // Get all console messages from the page.
  page.on('console', msg => {
    // Handle only errors.
    if (msg.type() !== 'error')
      return;
    console.log(`text: "${msg.text()}"`);
  });

  await page.evaluate(() => console.error('Page error message'));

Get access to the console message arguments:

  page.on('console', msg => {
    for (let i = 0; i < msg.args().length; ++i)
      console.log(`${i}: ${msg.args()[i]}`);
  });

API reference

• class: ConsoleMessage
• class JSHandle
• event: 'console'

Uncaghut exceptions

Listen uncaghut exceptions in the page:

  // Log all uncaught errors to the terminal
  page.on('pageerror', exception => {
    console.log(`Uncaught exception: "${exception}"`);
  });

  // Navigate to a page with an exception.
  await page.goto('data:text/html,<script>throw new Error("Test")</script>');

API reference

• event: 'pageerror'

Page crashes

Listen to page crashes:

  page.on('crash', exception => {
    console.log(`Page crashed`);
  });

It's very unusual for page to crash but might happen if a page allocates too much memory or due to a bug in a browser.

API reference

• event: 'crash'