NodeJS Screenshot Testing

What is Puppeteer? Puppeteer is Node library that you can use in order to control Headless Chrome with the DevTools Protocol.

The Chrome DevTools Protocol allows for tools to instrument, inspect, debug and profile for Chromium and Chrome browsers.

Puppeteer – Headless Chrome Node API works only with Chrome and uses the latest versions of Chromium.

Chromium is an open-source browser project that forms the basis for the Chrome web browser. One of the biggest differences between the two browsers is that, while Chrome is based on Chromium, Google adds some of proprietary features to Chrome, features like automatic updates and support for additional video formats. Other features like usage-tracking or “user metrics” feature can be found only in Chrome browser.

Note: Puppeteer requires at least Node v6.4.0but the examples below use async/await which is only supported in Node v7.6.0 or greater.

Node.js has a simple module loading system. In Node.js, files and modules are in one-to-one correspondence (each file is treated as a separate module).

You can use Visual Regression Testing to take website screenshots and compare the generated images and identify differences pixel by pixel, a comparison image will be shown next to the result’s screenshot that highlights the differences in red.

visual regression testing tool


Install Puppeteer

Here is how to install puppeteer from NPM Modules Registry (npm is the package manager for JavaScript):

npm i puppeteer

Below are code snippets on how to use Puppeteer – Headless Chrome Node API in order to take screenshots of your website.

Example – navigating to and saving a screenshot as a PNG file named example.png:

Generate screenshots with Puppetteer

const puppeteer = require('puppeteer'); (async () = { const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto(''); await page.screenshot({path: 'example.png'}); await browser.close(); })();

await page.goto(''), {
timeout: 120000,
slowMo: 2000,
waitUntil: ['load', 'networkidle'],
networkIdleTimeout: 5000,

By default, Puppeteer take screenshots of the viewport (the area which is visible by default when you open a website).

In order to take a screenshot of the full web page, you need to add the fullPage parameter to the screenshot method:

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

Here is an example on how to take a screenshot of a webpage with Puppeteer using a customer web page size.
You just need to pass the width and height of the viewport in order for the browser to resize the web page to the desired size.

export async function takeScreenshot(page, filename, width, height) {
await page.setViewport({ width, height });

await page.screenshot({ path: `${filename}-${width}-${height}.png`, fullPage: true });

Here is how to call the above custom screenshot method:

await takeScreenshot(page, 'example.png', 320, 480);

Puppeteer, also provides a list of Mobile Devices as a list of objects called DeviceDescriptors.
In order to emulate a web page in a mobile emulator, with specific characteristics, you can import the
pre-defined list of mobile emulators from puppeteer/DeviceDescriptors

const devices from 'puppeteer/DeviceDescriptors'; 

Puppeteer’s API is very similar to Selenium WebDriver, but works only with Google Chrome, while WebDriver work with most popular browsers.

More details on how to locate elements to use in order to interact with Puppeteer or Selenium WebDriver.

Debugging and Troubleshooting Puppeteer

1. Non Headless Mode – for debugging purposes, sometimes it’s useful to see what the browser is displaying. Instead of launching in headless mode, launch a full version of Chrome using headless: false when you launch the browser using Puppeteer:

const browser = await puppeteer.launch({headless: false});

2. Slow down screenshot generation – the slowMo option slows down Puppeteer operations by the specified amount of milliseconds. It’s another way to understand better what’s happening with the code you’ve written and debug easier.

const browser = await puppeteer.launch({
headless: false,
slowMo: 250 // slow down by 250ms

3. Capture browser’s console output

page.on('console', msg => console.log('PAGE LOG:', ...msg.args));

await page.evaluate(() => console.log(`url is ${location.href}`));

4. Enable verbose logging – All public API calls and internal protocol traffic will be logged via the debug module under the puppeteer namespace.

# Basic verbose logging

env DEBUG="puppeteer:*" node script.js

You can use Visual Regression Testing to take website screenshots and compare the generated images and identify differences pixel by pixel, a comparison image will be shown next to the result’s screenshot that highlights the differences in red.

LoadFocus is a cloud testing platform for:


Here are the steps you need to follow in order to debug ES6 code in the WebStorm IDE. After this, you’ll be able to take advantage of all debugging advantages, like setting breakpoints, moving away from console logs and faster understanding of the code of your application.

Prerequisites for Debugging ES6 in WebStorm IDE


1.Add the following NPM modules:


3. Add the following devDependencies:

"devDependencies": {
"gulp": "^3.9.1",
"gulp-babel": "^6.1.2",
"gulp-sourcemaps": "^2.4.1"

2. Create a new gulp file, you can call it: gulp.babel.js, and paste the below code to this file:

import gulp from 'gulp';
import sourceMaps from 'gulp-sourcemaps';
import babel from 'gulp-babel';
import path from 'path';

const paths = {
es6: ['./src/**/*.js', './test/**/*.js'],
es5: './dist',

sourceRoot: path.join(__dirname, 'src'),

gulp.task('babel', () => gulp.src(paths.es6)
presets: ['es2015'],
.pipe(sourceMaps.write('.', { sourceRoot: paths.sourceRoot }))

gulp.task('watch', ['babel'], () => {, ['babel']);

gulp.task('default', ['watch']);


4. Install NPM modules
It is a good idea to install gulp globally:

npm install gulp -g

Install the npm modules, by running npm install in the root of your application.

5. Run gulp from the root folder of your application, which will create the dist folder with the transpiled scripts + sourcemaps used for debugging ES6 code

Debug Mocha Unit Tests with WebStorm

  • in order to debug/add breakpoint to the Mocha tests, you need to do the following:
  • add `–compilers js:babel-core/register` the `WebStorm Mocha Configuration -> Extra Mocha options` field
  • start debugging the tests by adding breakpoints to the unit tests and while running in the Debug mode


We are going to show how to use the DataProvider in your test cases created with the TestNG unit testing framework.
DataProvider are used in order to create data-driven tests. Basically, it will help you to run the same test case, but with different data sets.

Examples of DataProviders

We are going to use the two dimensional object array Object[][] in order to return data and make use of it in the test case.

In order to create a DataProvider, you need to:
– create a new method with the two dimensional object array Object[][] as a return type
– add the DataProvider annotation to the method
– give a name for the DataProvider
– return a new two dimensional object array Object[][] with the desired values for the test

Here are some examples of values that can be provided for the DataProvider in TestNG:

@DataProvider(name = "provideDaysInterval")
public Object[][] provideData() {
return new Object[][]{{1}, {2}, {28}, {110}, {365}, {400}, {800}};

@DataProvider(name = "invalidIds")
public Object[][] provideInvalidIds() {
return new Object[][]{{"a"}, {"asdasdasf"}, {"£!@$%^&*^(&*&^%£$@£!"}, {"1"}, {"2332423"}, {"123456786543sadfgh"}, {"1234567890"}};

@DataProvider(name = "minMaxDates")
public Object[][] provideMinMaxDateRanges() {
return new Object[][]{
{"2013-01-04", "2014-01-04", "2014-04-04", "2015-07-04"},
{"2013-01-04", "2013-04-04", "2014-04-04", "2014-07-04"}

Now, you can make use of these DataProviders in your test cases by following the below steps:

– add the dataProvider attribute to the @Test annotation, and specify which is the dataProvider that you want to use. Make sure the data types defined in the two dimensional object array Object[][] are reflected in your test method attributes, see more details about the implementation of the DataProvider in TestNG:

@Test(groups = {"smoke"}, dataProvider = "provideDaysInterval")
public void test_Days_Are_Valid(int numberOfDaysInterval){


@Test(groups = {"smoke"}, dataProvider = "minMaxDates")
public void test_Data_Ranges_Validate_Min_Max(String startDateFirst, String endDateFirst, String startDateLast, String endDateLast){


This is the way to created automated data-driven test cases with TestNG and DataProviders in Java.


We found the use of DataProviders very useful, especially for API Testing and UI Testing with Selenium WebDriver. More details on how to find web elements in Selenium WebDriver can be found here.


Click here for Online Tutorial for using Java and TestNG for testing with Selenium WebDriver.

Native Device Testing

Using the Overview, Home and Back native buttons is pretty straight forward using WebDriver and Appium. Below there are the code examples for all the 3 buttons:


How to click the Back Button on Android with Selenium WebDriver and Appium

public void clickBackButton(){

How to click the Overview Button on Android with Selenium WebDriver and Appium

See more details

public void clickOverviewButton(){

How to click the Home Button on Android with Selenium WebDriver and Appium

public void clickHomeButton(){
} is a cloud testing platform:

Apache JMeter Tutorials

In order to define your own variables and reuse them in your tests, it’s easier to use the User Defined Variables from JMeter.

Here is how to create a variable and use it in an HTTP Request from your JMeter Test Plan.


1. Open JMeter (here is a more detailed post on how to install JMeter) and Add a Thread Group to your Test Plan

2. Add a HTTP Request Sampler to your Thread Group

3. Right-Click the Thread Group and add User Defined Variables Config Element in your JMeter test

4. Create a new variable: var1 with value

5. Go to the HTTP Request and add the variable name where you want to be replaced with its value, use ${var1}

6. Add a View Results Tree Listener in order to easily see the results of your request.

7. Make the request and you can see that the ${var1} was replaced with in the HTTP Request

8. Add the ${var1} also in the name of the HTTP Request sampler and you can see the request has the value of the user defined variable var1


  • suggestion: for simplicity use User Defined Variables only at the beginning of a Thread Group
  • all User Defined Variables from a test plan are processed at the beginning no matter where they are added or placed in the JMeter Test Plan
  • JMeter User Defined Variables should not be used with functions that generate different results each time they are called
  • use User Parameters for defining variables during a test run instead of User Defined Variables
  • User Defined Variables are processed in the order they are added in the test plan, from TOP to BOTTOM
  • If, in your Test Plan,you have more than one Thread Group, use different names for different values, as UDVs are shared between Thread Groups.
  • You can reference variables defined in earlier UDVs or on the Test Plan.


If you want to scroll the page UP or DOWN with Selenium WebDriver in order to find web elements or make assertions, here are a few way you can do that.

How to scroll Page Down using Selenium WebDriver:

JavaScript scrollBy() method scrolls the document by the specified number of pixels. Update the second parameter of the scrollBy() method with the number of pixels in order scroll more or less.

The definition of the JavaScript method scrollBy() is:



  • xpixels is a Number and Required parameter:
    • How many pixels to scroll by, along the x-axis (horizontal).
    • Positive values will scroll to the left, while negative values will scroll to the right
  • ypixels is a Number and Required parameter:
    • How many pixels to scroll by, along the y-axis (vertical).
    • Positive values will scroll down, while negative values scroll up

In the examples we are using 250 pixels for vertical scrolling in order to show how scroll method works.

@Test(groups = {"smoke"})
public void test_Scroll_Page_Down() throws Exception {


JavascriptExecutor jse = (JavascriptExecutor) driver;
jse.executeScript("window.scrollBy(0,250)", "");

How to scroll Page UP using Selenium WebDriver:

Similar to scrolling Down the web page, but we set a negative number of pixels as the second parameter of the JS scrollBy() method to a negative number: -250

@Test(groups = {"smoke"})
public void test_Scroll_Page_UP() throws Exception {


JavascriptExecutor jse = (JavascriptExecutor) driver;
jse.executeScript("window.scrollBy(0,-250)", "");

How to scroll to the Bottom of the Web Page using Selenium WebDriver:

Basically, we get the height of the Body element from the DOM (Document Object Model) and we use the JavaScript method scrollTo() to scroll to the maximum height of the page:

@Test(groups = {"smoke"})
public void test_Scroll_Page_To_Bottom() throws Exception {


JavascriptExecutor jse = (JavascriptExecutor) driver;
jse.executeScript("window.scrollTo(0, document.body.scrollHeight)");

How to scroll Page to a Web Element Selenium WebDriver:

Just identify the Web Element fro the webpage and use the JS method scrollIntoView() to scroll the page to that web element until it becomes visible

@Test(groups = {"smoke"})
public void test_Scroll_Page_To_Element() throws Exception {


JavascriptExecutor jse = (JavascriptExecutor) driver;

WebElement element = driver.findElement(By.linkText(""));
jse.executeScript("arguments[0].scrollIntoView();", element);

How to scroll Page Down or UP using Keys Selenium WebDriver:

If you want to use the keys form the keyboard to scroll UP or DOWN you can use the WebDriver sendKeys() method and pass the PAGE_UP or PAGE_DOWN as an argument:

@Test(groups = {"smoke"})
public void test_Scroll_Page_Using_Keys() throws Exception {


Actions action = new Actions(driver);

Hope you’ll find this useful. Check also how to find web elements using Selenium WebDriver.

LoadFocus is a cloud load testing platform. Try it for free.


Enroll Now for the new Online Course: How to Find XPath for Web Elements in Chrome and Firefox Browsers.

A lot of times while developing a test or when debugging a test you want to check to what element the XPath used in your test refers to. You will find this useful since you don’t need to install any other plugin or widget, you can use just built-in browser functionality.

For example, let’s imagine we have the following code in our UI Selenium test:

@FindBy(xpath = "//div[contains(@class,'item--lowest')]//a[contains(@class,'summary__date')]")
public WebElement summaryDateElement;

To identify to which element this refers to just do the following:

    1. Open the URL / web page in the Chrome browser
    2. Open the Web developer tools by pressing:
      •  Cmd + Alt + I (on Mac)
      • or by clicking View -> Developer -> Developer tools
      • or by Right-Click and Inspect Element

See more details

  1. Click on the Console tab in the Web developer tools
  2. Paste in the console the XPath from your test in the following format:
  3. $x(“//div[contains(@class,’item–lowest’)]//a[contains(@class,’summary__date’)]”)
  4. Hovering with the mouse over the returned result will highlight the page element that the XPATH refers to.
  5. Details about locating elements with Selenium WebDriver can be found in our previous blog post.

That is it. You will see in the console what the XPath returns.

Find best screenshot comparison tools