Forem: Abeer Mishra

How To Take Screenshots In Selenium WebDriver Using JavaScript

Abeer Mishra — Tue, 17 Aug 2021 07:41:01 +0000

While performing automation testing, even the most reliable of test cases might face roadblocks as the action progresses. A failed test case, for instance, is a sure sign that something has gone wrong. Test failure can either be due to some issue in the script or due to some issue in the AUT (Application Under Test). What’s even more challenging is debugging such deviation scenarios for the development as well as the testing teams. Capturing screenshots of the failed scenarios can be of great help to figure out where things went wrong. Screenshots in Selenium should be the way forward to make the most out of Selenium automation testing. In this blog, we deep dive into how to take screenshots in Selenium WebDriver using JavaScript.

Selenium WebDriver has built-in functionality to capture screenshots of the page, and it’s quite easy to use. It uses the TakesScreenshot interface for capturing the respective screenshot. This Selenium JavaScript tutorial shows the usage of TakesScreenshot method to take screenshots of a page and particular element. It is demonstrated with a step-by-step process that is executed over cloud-based Selenium Grid using Selenium automation testing.

_ Bonus Tip : If you are on Selenium 4, you can capture a screenshot of the page & WebElements with minimal instructions._

Why take screenshots when running a Selenium test

Before we go in-depth about how to take screenshots in Selenium WebDriver, let’s have a look as the ‘why’ part of capturing screenshots:

Screenshots can be very useful in understanding the test execution flow of the application and its behavior.
Capturing screenshots can be helpful in debugging any test scenario with ease.
In case of a test failure, screenshots can help to identify if the problem is with the test script or the application under test.
While executing a test script, screenshots at certain steps can be compared with the baseline image to verify if there is any deviation from the actual image.
When we execute any Selenium test, sometimes we need to see the execution at later stages. So such screenshots can help us avoid re-execution of tests.

So taking or capturing screenshots during a Selenium test is essential and can be of great help. These screenshots can be in different forms, such as:

Full page screenshot of the application under test.
Screenshot of a particular element in the application.
Screenshot of only the viewable part of the page.

How to take screenshots in Selenium WebDriver using JavaScript?

Now that we have understood the need to capture screenshots, it’s time for some action! Some classes (or interfaces) in the Selenium WebDriver can help us take screenshots of the AUT such as TakeScreenshot, AShot, etc. Let us deep dive into these classes one by one and see how to take screenshots in Selenium WebDriver using JavaScript.

Taking screenshots in Selenium JavaScript using the TakeScreenshot interface

Before getting to know about taking screenshots, let us first look at the TakeScreenshot interface of Selenium WebDriver in detail.

TakesScreenshot Interface in Selenium

The TakeScreenshot interface in the Selenium WebDriver package is made with the sole purpose of capturing screenshots of applications during Selenium test automation. The TakeScreenshot interface has a subinterface – WebElement, which indicates a WebDriver instance or an HTML element to capture a screenshot and store it as per the specified instructions.

Browsers that support TakeScreenshot Interface

Here is a list of browsers that support the TakeScreenshot interface:

Syntax:

Here is the basic syntax for how the TakeScreenshot interface can be used to take screenshots in Selenium using JavaScript.

driver.takeScreenshot().then(
    function(image) {
        require('fs').writeFileSync(file, image, encoding_system);
    }
);

Let me break the sequence of execution of the above code syntax:

First, the TakeScreenshot interface of Selenium WebDriver is called using the driver.takeScreenshot() method.
A promise is called using then.
In the promise, a custom function is made with the parameter as the image. It is the captured image which is further returned by the driver.takeScreenshot() method.
In the next step, the captured image is saved into a file with the specified name as ‘file’ and a desired ‘encoding system.’

Example 1:

Let us try to automate a test scenario where:

The LambdaTest sample todo app is called using the URL https://lambdatest.github.io/sample-todo-app/.
The 1st item in the list is clicked.
The 2nd item in the list is clicked.
A new item is added to the list with the name “New item.”
The screenshot is captured of the application under test in the current state.

Below is the complete implementation of the test scenario automation:

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")
// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;
let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

driver.get('https://lambdatest.github.io/sample-todo-app/');

driver.findElement(By.name('li1')).click();
driver.findElement(By.name('li2')).click();
driver.findElement(By.id("sampletodotext")).sendKeys("New item");
driver.findElement(By.id("addbutton")).click();

driver.takeScreenshot().then(
    function(image) {
        require('fs').writeFileSync('captured_image_3.png', image, 'base64');
    }
);

driver.quit();

Code Walkthrough:

First, the required instances of Selenium WebDriver and ChromeDriver are called.

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")
// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;

The WebDriver is instantiated and a local instance of the Google Chrome browser is opened.

let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

Then, the LambdaTest sample ToDo app is navigated to by the Selenium WebDriver.

driver.get('https://lambdatest.github.io/sample-todo-app/');

The first item in the list is searched using the Name Selenium locator and then clicked.

driver.findElement(By.name('li1')).click();

Similarly, the second item in the list is searched using the name Selenium locator and then clicked.

driver.findElement(By.name('li2')).click();

Then the text box to input a new item is searched using Selenium locator ID, and then the text “New item” is passed.

driver.findElement(By.id("sampletodotext")).sendKeys("New item");

Once the text is input, now the add button is located and clicked. This inserts a new item to the list with the name “New item.”

driver.findElement(By.id("addbutton")).click();

In the next step, the screenshot of the application under test is taken and captured into a file, using the TakeScreenshot interface of Selenium WebDriver.

driver.takeScreenshot().then(
    function(image) {
        require('fs').writeFileSync('captured_image_3.png', image, 'base64');
    }
);

Once done, the test scenario is executed. Then, the Selenium WebDriver instance gets closed using the quit() method.

driver.quit();

Output:

Execute the test using the below-given command:

node take_screenshot_implementation.js

Once the test execution is complete, you can see the required image getting saved:

If you open the saved image, you can see the screenshot of the viewable area in the application, representing the test scenario executed:

Example 2:

Let us try to automate a different test scenario this time, where:

The LambdaTest Dynamic Data Loading Selenium playground is called using the URL Dynamic Data Loading Demo.
The “Get New User” button is clicked.
The dynamic content of the page is loaded.
The screenshot is captured of the application under test in the current state with the dynamic elements.

Below is the implementation to automate the required test scenario:

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")

// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;
let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

(async function () {

    // Navigate to the required URL
    driver.get('');

    // Press the Get New User button
    driver.findElement(By.id('save')).click();

    // Wait for 5 secs to let the dynamic content to load
    await driver.sleep(5000);

    // Take screenshot of the application with the dynamic content
    driver.takeScreenshot().then(
        function (image) {
            require('fs').writeFileSync('screenshot_with_wait.png', image, 'base64')
        });

    // Exit the driver
    driver.quit();

}());

Code Walkthrough:

First, the required instances of Selenium WebDriver and ChromeDriver are called.

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")
// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;

The WebDriver instance is then built, and a local instance of the Google Chrome browser is opened.

let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

Now we will do the required actions in an async state as we will be using Selenium explicit wait in this code.

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")

// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;
let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

(async function () {

    // Navigate to the required URL
    driver.get('');

    // Press the Get New User button
    driver.findElement(By.id('save')).click();

    // Wait for 5 secs to let the dynamic content to load
    await driver.sleep(5000);

    // Take screenshot of the application with the dynamic content
    driver.takeScreenshot().then(
        function (image) {
            require('fs').writeFileSync('screenshot_with_wait.png', image, 'base64')
        });

    // Exit the driver
    driver.quit();

}());

Then, the LambdaTest Dynamic Data Loading Selenium Playground is navigated to by the Selenium WebDriver.

// Navigate to the required URL
    driver.get('');

As per the test scenario, the “Get New User” button is searched and clicked using the ID Selenium locator to start loading the web page’s dynamic content.

// Press the Get New User button
driver.findElement(By.id('save')).click();

Now the major issue with dynamic content on a web page is that it takes time to load. Hence we cannot just go ahead and perform our next step. As a result, we need to use waits in Selenium to wait for the dynamic content to load successfully. That is why an explicit wait of 5 seconds is used.

// Wait for 5 secs to let the dynamic content to load
await driver.sleep(5000);

In the next step, the screenshot of the AUT is taken and captured into a file, using the TakeScreenshot interface of Selenium WebDriver.

// Take screenshot of the application with the dynamic content
driver.takeScreenshot().then(
        function (image) {
            require('fs').writeFileSync('screenshot_with_wait.png', image, 'base64')
        });

Once done, the test scenario is executed. Close the existing instance of Selenium WebDriver using the quit() method.

driver.quit();

Output:

Execute the test using the below-given command:

node take_screenshot_implementation2.js

Once the test execution is complete, you can see the required image getting saved:

If you open the saved image, you can see the screenshot of the viewable area in application, representing the test scenario executed. The expected screenshot must have an image, a first name, and a last name in it, loaded with the help of dynamic page loading content.

As you can see, the dynamic data has been loaded successfully, and the screenshot has also been captured.

For a quick overview on getting started with JavaScript, check out the video below from LambdaTest YouTube Channel.

Taking screenshots of a particular element in Selenium JavaScript

Till now, we looked at how to take a screenshot of the viewable area of the AUT in Selenium using JavaScript. What if we need to take screenshots of a specific region or a particular element on the page. The TakeScreenshot interface of Selenium WebDriver can be used to do this as well. But, since the TakeScreenshot interface always takes the screenshot of the complete viewable area, the question is how?

Steps to take screenshots of a particular WebElement

To take the screenshot of a particular WebElement, you need to follow the below steps:

Take a screenshot of the complete viewable area using the TakeScreenshot interface.
Get the Position and dimensions of the element around which you want to take the screenshot.
Crop the original image to the fetched dimensions of the element.
Save the modified image.

Prerequisites:

Steps 1, 2, and 4 can be performed with the help of Selenium JavaScript. To perform step 3, (i.e. crop the image), external libraries such as Sharp, EasyImage, etc. can be used. For our demonstration, we have used the Sharp library. To install Sharp, run the following command on the terminal:

npm install sharp

Example:

Let us try to automate a test scenario where:

The LambdaTest sample todo app is called using the URL https://lambdatest.github.io/sample-todo-app/.
A new item is added to the list with the name “New item.”
The screenshot is captured of only this newly added item.

Below is the complete implementation of the above test scenario:

const sharp = require('sharp')

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")
// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;
let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

driver.get('https://lambdatest.github.io/sample-todo-app/');

driver.findElement(By.id("sampletodotext")).sendKeys("New item");
driver.findElement(By.id("addbutton")).click();

driver.takeScreenshot().then(
    function (image) {
        require('fs').writeFileSync('image_viewable_full.png', image, 'base64')
    });

try {

    var _height = 0, _width = 0, _left = 0, _top = 0;

    driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'))
        .getLocation().then(location => {
            _left = location.x;
            _top = location.y;
        });
    driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'))
        .getSize().then(size => {
            _width = size.width;
            _height = size.height;
        });


    (async function () {

        await driver.sleep(5000);

        sharp('image_li6.png')
            .extract({ left: parseInt(_left), top: parseInt(_top), width: parseInt(_width), height: parseInt(_height) })
            .toFile('image_li6_crop.png')
            .then(function (new_file_info) {
                console.log("Image cropped and saved");
            })
            .catch(function (err) {
                if (err) console.log(err);
            });

    }());
}
catch (err) {
    console.log("Error: " + err);
};
driver.quit();

Code Walkthrough:

First, the required instances of Selenium WebDriver and ChromeDriver are called.

// Include the chrome driver
require("chromedriver");
require("selenium-webdriver")
// Include selenium webdriver
let webdriver = require("selenium-webdriver");
var By = require("selenium-webdriver").By;

The WebDriver instance is then built, and a local instance of the Google Chrome browser is opened.

let browser = new webdriver.Builder();
let driver = browser.forBrowser("chrome").build();

Then, the LambdaTest sample todo app is navigated to by the Selenium WebDriver.

driver.get('https://lambdatest.github.io/sample-todo-app/');

The text box to input a new item is searched using Selenium locator ID, and then the text “New item” is passed.

driver.findElement(By.id("sampletodotext")).sendKeys("New item");

Once the text is input, now the add button is found and clicked. This inserts a new item to the list with the name “New item.”

driver.findElement(By.id("addbutton")).click();

In the next step, the screenshot of the application under test is taken and captured into a file, using the TakeScreenshot interface of Selenium WebDriver.

driver.takeScreenshot().then(
    function (image) {
        require('fs').writeFileSync('image_viewable_full.png', image, 'base64')
    });

We have the original image of the current state of the application captured. Now we need the dimensions of the newly added item so that image can be cropped. To store that, we will create four variables to keep the value of the corresponding dimension.

var _height = 0, _width = 0, _left = 0, _top = 0;

Among the required four dimensions, first, the left and top positions are fetched using the getLocation() method and stored as per the requirement.

driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'))
        .getLocation().then(location => {
            _left = location.x;
            _top = location.y;
        });

Then the width and the height of the newly added li6 element are fetched using the getSize() method and stored.

driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'))
        .getSize().then(size => {
            _width = size.width;
            _height = size.height;
        });

Since we have the required dimensions of the li6 item now, we can crop the captured screenshot using the Sharp package. As you can see, the Sharp object takes one parameter which is the image file. With the help of the extract() method, the image is then cropped. Once cropped, we can save the modified file to the same file or a new one, using the toFile() method.

sharp('image_element_li6.png')
            .extract({ left: parseInt(_left), top: parseInt(_top), width: parseInt(_width), height: parseInt(_height) })
            .toFile('image_li6_crop.png')
            .then(function (new_file_info) {
                console.log("Image cropped and saved");
            })
            .catch(function (err) {
                if (err) console.log(err);
            });

Once done, the test scenario is executed. Then, the Selenium WebDriver instance gets closed using the quit() method.

driver.quit();

Output:

To trigger the test, run the below command on the terminal:

node screenshot_of_element.js

On successful execution, the captured image file is stored in the desired location (or directory).

If you open the saved image, you can see the screenshot of only the newly added 6th item in the list with the name “New item” and not the complete viewable area, representing the test scenario executed:

How to take screenshot of a particular WebElement using Selenium 4 and JavaScript

In Selenium 3, the approach to capture the screenshot of the entire web page was pretty simple and straightforward. However, capturing the screenshot of a WebElement in the page required a fair bit of calculations! You would have witnessed this tedious calculation exercise in the earlier section where we demonstrated how to capture a screenshot of a WebElement in Selenium 3.

Things are set to change with Selenium 4, considering the fact that it is relatively easy to update from Selenium 3 to Selenium 4.

One of the welcome changes in Selenium 4 is the ability to capture the screenshot of a particular WebElement with ultra ease. You no longer need to use third-party libraries to capture the screenshot of a WebElement.

Here are the steps you need to perform for capturing WebElement screenshot with Selenium 4:

Locate the desired WebElement using the appropriate web locators (e.g. XPath, ID, CSS, etc.).
Once the WebElement (e.g. ele) is located, use <element_name>.takeScreenshot(true) method for capturing the element screenshot (in the desired image format – base64)

Now that we have covered the steps to capture element screenshot with Selenium 4 & JavaScript, let’s get our hands dirty with the implementation:

const {By,Key,Builder} = require("selenium-webdriver");
require("chromedriver");

let fs = require('fs');

async function WebElementCapture(){
       //To wait for browser to build and launch properly
       let driver = await new Builder().forBrowser("chrome").build();

        //To fetch https://lambdatest.github.io/sample-todo-app/ from the browser with our code.
        await driver.get("https://lambdatest.github.io/sample-todo-app/");

        //Add a new item in the list
        await driver.findElement(By.id("sampletodotext")).sendKeys("Add a new item in the list");
        await driver.findElement(By.id("addbutton")).click();

        let ele = await driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'));

        //Capture the element screenshot
        let encodedString = await ele.takeScreenshot(true);
        await fs.writeFileSync('./image_li6_crop.png', encodedString, 'base64');
        await driver.quit();
}
WebElementCapture()

Code Walkthrough:

Implementation has only changed in the area where the TakeElementScreenshot method is used to capture a screenshot of the WebElement.

To get started, we add a new item (i.e. Add a new item in the list) in the LambdaTest ToDo app.

await driver.findElement(By.id("sampletodotext")).sendKeys("Add a new item in the list");
await driver.findElement(By.id("addbutton")).click();

Now that the item is added to the list, it is located using the XPath locator.

let ele = await driver.findElement(By.xpath('/html/body/div/div/div/ul/li[6]'));

The takeScreenshot method is used on the required WebElement (i.e. ele in this case) and the captured image is written to the file system in the base64 encoded format.

let encodedString = await ele.takeScreenshot(true);
await fs.writeFileSync('./image_li6_crop.png', encodedString, 'base64');

That’s all. This is all that is required to capture screenshot of a desired WebElement in Selenium using JavaScript.

Execution:

Run the following command on the terminal to trigger the test

node ImageCapture.js

A new item is added to the ToDo list. A screenshot of the new item is taken and stored in the given location in the file system. As mentioned earlier, the screenshot is stored in the base64 encoded format. As seen below, an image by the name image_li6_crop.png is created in the designated folder.

Here is the screenshot of the newly added element.

If you are intrigued to learn more about Selenium 4, do check out Selenium 4 Learning Hub on LambdaTest. It’s your go-to place to deep dive into the various facets of Selenium 4!

We have seen how to take screenshots in Selenium WebDriver using JavaScript. Using a local setup has severe shortcomings, especially when the test cases are extremely long or when screenshots have to be captured at multiple test steps. Here are some of the major drawbacks of using a local Selenium setup for capturing screenshots:

For larger test scenarios, taking screenshots becomes difficult to implement.
Using Local setup can become tedious when screenshots have to be captured at multiple steps.
Full page screenshots can take up a huge chunk of system memory.

To overcome these shortcomings, it is recommended to use LambdaTest, an online Selenium grid that helps you run your tests on 2000+ browsers, browser versions, and operating systems. That’s not all, the platform captures screenshots automatically at every test step.

How to capture screenshots step-by-step on LambdaTest

To capture the screenshot on the LambdaTest platform at every test step, you need to pass the “visual” capability in the desired capabilities. This capability is available in the advanced configuration of the capabilities generator. When “visual” is set to “true”, LambdaTest will record a step by step screenshot of your test.

Syntax:

Below is an example of the desired capabilities with the “visual” capability passed as “true”. This is instrumental in capturing screenshots at every test step.

capabilities = {
  'build': ’Capture Screenshots’, //Build name
  'name': 'Your Test Name', // Test name
  'platform':'MacOS Big sur', // OS name
  'browserName': 'Firefox', // Browser name
  'version': '89.0', // Browser version
  "resolution" : "1280x960",

  'visual': true,  // To take step by step screenshot

  'network':false,  // To capture network Logs
  'console':false, // To capture console logs.
  'tunnel': false // If you want to run the localhost then change it to true
  };

Example:

Consider the below example that solves the below test scenario:

The LambdaTest sample todo app is called using the URL https://lambdatest.github.io/sample-todo-app/.
The 1st item in the list is clicked.
The 2nd item in the list is clicked.
A new item is added to the list with the name “New item.”
The screenshot is captured of the application under test in the current state.

The test is run on the LambdaTest platform. As the prerequisites, we first need to get the username, access key, and the desired capabilities.

Get the username and access key from the LambdaTest Profile section, and update the below code snippet for the Grid URL. Grid URL is your specific Remote WebDriver route on which the tests will be executed.

String gridURL = "http://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub";

Next, get the desired capabilities from the LambdaTest Capabilities Generator:

var capabilities = {
        "build" : "your build name",
        "name" : "your test name",
        "platform" : "'MacOS Big sur",
        "browserName" : "Firefox",
        "version" : "89.0",
        "visual" : true
    }

We need to create the Remote WebDriver instance and initialize it with the above capabilities and Grid URL.

LT_USERNAME = "username";
LT_ACCESS_KEY = "access key";

caps = {
  'build': 'Capture Screenshots', //Build name
  'name': 'Your Test Name', // Test name
  'platform':'MacOS Big sur', // OS name
  'browserName': 'Firefox', // Browser name
  'version': '89.0', // Browser version
  "resolution" : "1280x960",
  'visual': true,  // To take step by step screenshot
  'network':false,  // To capture network Logs
  'console':false, // To capture console logs.
  'tunnel': false // If you want to run the localhost then change it to true
  };

var buildDriver = function () {
    return new webdriver.Builder()
        .usingServer(
            "http://" +
            LT_USERNAME +
            ":" +
            LT_ACCESS_KEY +
            "@hub.lambdatest.com/wd/hub"
        )
        .withCapabilities(caps)
        .build();
};

That’s it. Now we can use this Remote WebDriver instance to write and execute our test to show how to take screenshots in Selenium WebDriver. Below is the complete JavaScript code for the same:

LT_USERNAME = "username";
LT_ACCESS_KEY = "access key";

exports.capabilities = {
  'build': 'Capture Screenshots', //Build name
  'name': 'Your Test Name', // Test name
  'platform':'MacOS Big sur', // OS name
  'browserName': 'Firefox', // Browser name
  'version': '89.0', // Browser version
  "resolution" : "1280x960",
  'visual': false,  // To take step by step screenshot
  'network':false,  // To capture network Logs
  'console':false, // To capture console logs.
  'tunnel': false // If you want to run the localhost then change it to true
  };

var By = require("selenium-webdriver").By;

var assert = require("assert"),
    webdriver = require("selenium-webdriver"),
    conf_file = process.argv[3] || "conf/single.conf.js";

var caps = require("../" + conf_file).capabilities;

var buildDriver = function (caps) {
    return new webdriver.Builder()
        .usingServer(
            "http://" +
            LT_USERNAME +
            ":" +
            LT_ACCESS_KEY +
            "@hub.lambdatest.com/wd/hub"
        )
        .withCapabilities(caps)
        .build();
};

describe("Capture Screenshot " + caps.browserName, function () {
    var driver;
    this.timeout(0);

    beforeEach(function (done) {
        caps.name = this.currentTest.title;
        driver = buildDriver(caps);
        done();
    });

    it("Take Screenshot JavaScript", function (done) {

        driver.get('https://lambdatest.github.io/sample-todo-app/');

        driver.findElement(By.name('li1')).click();
        driver.findElement(By.name('li2')).click();
        driver.findElement(By.id("sampletodotext")).sendKeys("New item");
        driver.findElement(By.id("addbutton")).click();
    });

    afterEach(function (done) {
        if (this.currentTest.isPassed) {
            driver.executeScript("lambda-status=passed");
        } else {
            driver.executeScript("lambda-status=failed");
        }
        driver.quit().then(function () {
            done();
        });
    });
});

Upon execution, you can see the test getting run on the desired environment configuration on the LambdaTest platform.

How to view screenshots step-by-step on LambdaTest?

You can view the screenshots step-by-step on the LambdaTest platform. Just go to the Commands tab of the test, and you will see the screenshots along with all the steps. You can view or download any of the screenshots as and when required.

Below is one of the screenshots, where we send keys to enter the name of the 6th item in the list as New item, captured by LambdaTest.

Conclusion

The UI of a webpage is often very complex, and to test the complete UI, Selenium automation testing is the most effective way. Capabilities offered by Selenium automation testing can be enhanced by capturing page (or WebElement) screenshots for the failed test scenarios.

Taking screenshots in Selenium WebDriver using JavaScript can be super helpful in checking problematic areas on the page. Taking such screenshots can help you witness the execution as the desired point and debug your tests in a much easier and faster way. Online tools like LambdaTest can help you capture step by step screenshots of your test with a minimal addition in the test capabilities.

We hope you learned how to take screenshots in Selenium WebDriver using JavaScript.

Happy Testing!

How To Set Jenkins Pipeline Environment Variables?

Abeer Mishra — Thu, 24 Jun 2021 09:13:02 +0000

Jenkins is an open-source and extensible continuous integration and continuous deployment server. It is used to automate the process of continuous integration and continuous deployment(CI/CD). The importance of monitoring remote jobs and interacting with team members for stable code is immense; Jenkins takes care of all these requirements and allows a smooth integration via plugins, pipelines, and Jenkins environment variables.

If you are amongst the typical Jenkins users who want to add to their knowledge about CI and CD, some fundamental concepts must be learned. In this article, we will learn about the critical concept of Jenkins pipeline environment variables. We will also view and install the Lambatest Jenkins plugin and use the in-build variables from the Jenkins environment variables list.

So, let’s get started!

What are Jenkins Pipeline Environment Variables?

While writing the script for a Jenkins pipeline, some dynamic values are to be injected and used. These are especially useful to avoid hardcoding every value into the pipeline. For this dynamic integration, Jenkins set environment variables.

Jenkins environment variable is a global variable, exposed via env variable and used in Jenkins pipelines and anywhere into Jenkinsfile. Any value stored as the environment variable in the env variable is of string type.

The Jenkins pipeline environment variables facilitate the benefits like :

Injection of sensitive data at runtime to avoid the hardcoding into the pipeline.
Addition of job parameters available only at runtime, but not at design time.
Boolean values set in environment variables help certain toggle stages in a pipeline via a parameter that describes a specific subset of tests you want to run.
Providing IDs of credentials defined in Jenkins.

In the Jenkins pipeline, there are a lot of helpful environment variables that can be accessed and maintained during build execution; some of the most useful ones are :

env: env is used to access the Jenkins pipeline environment variables in groovy code as env.VARNAME or simply as VARNAME. The env prefix also accesses the environment variables provided in the Jenkins pipeline.
currentBuild: As the name suggests, it addresses the currently running build of the Jenkins pipeline.
params: All the parameters provided for a successful build from a read-only map with various typed variables. These can be accessed via params.
docker: This is to provide convenient access to Docker – related functions in a Groovy script of Jenkins pipeline.

To ease building the pipeline, Jenkins has provided us with a Jenkins environment variables list. This list contains some of the most used variables. Let’s start by browsing through the list of environment variables.

Viewing Jenkins Environment Variables List

Jenkins exposes the crucial characteristics of components using environment variables. Thus, a set of these variables are already defined by Jenkins. This includes information about the job and the specific build that is running. Some of the most commonly used variables are :

Variable Name	Description	Example
JOB_NAME	Provides the name of the job in Jenkins	envvars
JOB_URL	Gives the URL to the job in the Jenkins UI	`http://localhost:8082/job/envvars/`
BUILD_NUMBER	Prints the build number in Jenkins console output	5,6, etc.
BUILD_TAG	Gives a unique tag for a specific job name and build number	envvars-build-8

The Jenkins environment variables list can be viewed using two different ways.

1. Via env-vars.html :

The environment variables can be viewed on an HTML page. You have to open the page on your Jenkins controller server. The steps to view the jenkins environment variables list are :

At the address bar of chrome, type ${YOUR_JENKINS_HOST}/env-vars.html.
The ${YOUR_JENKINS_HOST} itself is an environment variable defining the Jenkins host address/Jenkins URL(that would be http://localhost:8080/).
And env-vars.html is the HTML file consisting of the list of all Jenkins environment variables.
The page looks like this :

2. Via Windows batch script/shell command :

You can also list all the environment variables by writing the shell command in the groovy script of the Jenkins pipeline. The steps to do the same are :

Create a new pipeline in Jenkins, named ‘ envvars ’.
In the Pipeline Script , type the following groovy script.

pipeline{
    agent any

    stages{
        stage("Env Variables"){
            steps{
                bat ‘set’                                                     
            }
        }
    }
}

The windows batch command used here is “ set ”. This command lists all the Jenkins pipeline environment variables in logs.
For Linux/Unix, you can use the shell command “ printenv ”, as : sh ‘printenv’.
This can be viewed as :

Reading Jenkins Environment Variables

In this section, we will see how you can read your Jenkins environment variables list. Let’s take it one step at a time-

To access the Jenkins environment variables in a pipeline, you can use the env object, eg. env.BUILD_NUMBER will give the current build number of a pipeline. The reference to Jenkins pipeline environment variables is made by surrounding it by ${} in the following way: ${env.BUILD_NUMBER}
You can also use the short version, which is BUILD_NUMBER. But this variant is quite confusing for some users. The script to read the build number via environment variables is :

pipeline{
    agent any

    stages{
        stage("Env Build Number"){
            steps{
                echo "The build number is ${env.BUILD_NUMBER}"
                echo "You can also use \${BUILD_NUMBER} -> ${BUILD_NUMBER}"                                                
            }
        }
    }
}

The console output of the build processed via the above script is :

Setting Jenkins Environment Variables

Jenkins environment variables are set both globally as well as locally. Global environment variables can be set via the UI of Jenkins, and local environment variables are set according to the pipeline, being declarative or scripted. The Jenkins pipeline environment variables can also be read from a properties file. For this, we use the Pipeline Utility Steps plugin. You can also inject the variables during the build startup via the EnvInject plugin.

Thus, different ways to set Jenkins environment variables are :

1. Creating Global Environment Variables

Global environment variables are the variables that can be used in any and every Pipeline or Job built on Jenkins. The global variables are set via the Jenkins console and via the groovy script of a pipeline. The ways to set these global environment variables are:

On the upper left side, you will find a dropdown menu on the right of Jenkins; Select the dropdown menu.
In the dropdown menu, you will find an option for Manage Jenkins. Please click on it.
In the Manage Jenkins window, click on the Configure System. Here, you can configure global properties, commands, and a lot more.

Find the Global properties section.
In the Global properties section, tick the box of environment variables.
As you will tick the box, the button to add the Jenkins environment variables list appears.

Click on Add. Two fields appear- Name and Value.
You can provide multiple environment variables by clicking on the add button.
This can be viewed as :

Using Java Code in Groovy Script :

You can create Jenkins environment variables by using Java code in the Groovy script. This code is to be written in the pipeline script section when a new pipeline is created.
The required code is :

import hudson.EnvVars;
import hudson.slaves.EnvironmentVariablesNodeProperty;
import hudson.slaves.NodeProperty;
import hudson.slaves.NodePropertyDescriptor;
import hudson.util.DescribableList;
import jenkins.model.Jenkins;
public createGlobalEnvironmentVariables(String key, String value){

       Jenkins instance = Jenkins.getInstance();

       DescribableList<NodeProperty<?>, NodePropertyDescriptor> globalNodeProperties = instance.getGlobalNodeProperties();
       List<EnvironmentVariablesNodeProperty> envVarsNodePropertyList = globalNodeProperties.getAll(EnvironmentVariablesNodeProperty.class);

       EnvironmentVariablesNodeProperty newEnvVarsNodeProperty = null;
       EnvVars envVars = null;

       if ( envVarsNodePropertyList == null || envVarsNodePropertyList.size() == 0 ) {
           newEnvVarsNodeProperty = new hudson.slaves.EnvironmentVariablesNodeProperty();
           globalNodeProperties.add(newEnvVarsNodeProperty);
           envVars = newEnvVarsNodeProperty.getEnvVars();
       } else {
           envVars = envVarsNodePropertyList.get(0).getEnvVars();
       }
       envVars.put(key, value)
       instance.save()
}
createGlobalEnvironmentVariables('Var1','Dummy')

In java, createGlobalEnvironmentVariables() method is used to create new global environment variables. Here, the environment variable named, “Var1” is created having the value “Dummy”.

You can populate the environment variable using a Jenkins file.
There might be a file in your code repository where some configuration properties for your app are saved, Or the file would be available on fileshare somewhere.
There is a plugin in Jenkins that can be used to read these properties from a file. This is the Pipeline Utility Steps plugin.

So, firstly install the Pipeline Utility Steps plugin. This provides the readProperties step, which makes it easy to read properties from a file.
Click on Manage Jenkins on the left column.
Select Manage Plugins and go to the Available Tab.

In the filter box, type pipeline utility steps.
You will find the plugin listed, select the checkbox in front of Pipeline Utility Steps and click on the install button.
After successful installation, you will find the required plugin under the Installed tab.

Also, define Java .properties file with some key and value pairs. The properties file is used to store the username, password, access tokens etc., which cannot be hardcoded due to privacy. As shown below :

Username = root
Access_Token = ***************

Then, you can read these values from the properties file using the .readProperties step, provided by Pipeline Utility Steps plugin.

To read and use the key-value pairs, you have to write the following stage in your groovy script.

stage(“reading properties from properties file”) {
    steps {
        // Use a script block to do custom scripting
        script {
            def props = readProperties file: 'extravars.properties' 
            env.Username = props.Username
        }
        echo "The username  is $Username"
    }
}

This way, you can read the properties from the file and save them as environment variables. Remember, Jenkins will search the properties file in the local workspace. If your file is not present in the local workspace, do provide the path to the properties file.
The output to the above groovy script for reading properties file will be :

2. Creating Local Environment Variables

The local environment variables are the variables explicitly defined for a particular job in Jenkins. These are defined according to the pipeline and its type. There are declarative pipelines as well as scripted pipelines. Declarative pipelines break down the stages into individual stages that can contain multiple steps; Scripted pipelines, on the other hand, use groovy code and references within the stages without any extra efforts. Because of this difference, the code for creating local environment variables is different for the two types of pipelines.

Using Declarative Pipeline:

The Jenkins declarative pipeline uses an environment directive to define local environment variables. The environment directive looks like:

environment {
       DISABLE_AUTH = 'true'
   }

The environment directive can be placed at the beginning of the pipeline. Then, the variable declared in the directive can be used in all steps. The groovy code for the same is:

pipeline {
   agent any
   environment {
       DISABLE_AUTH = 'true'                               //can be used in whole pipeline
   }
   stages {
       stage(“Build”) {
           steps {
               echo env.DISABLE_AUTH
           }
       }
   }
}

The directive can also be placed in the stages. Thus, that variable can be used only in steps of that particular stage

pipeline {
   agent any
   environment {
       DISABLE_AUTH = 'true'
   }
   stages {
       stage(“Build”) {
           environment {
                   ENABLE_AUTH = ‘false’                                 //can be used in this stage only
              }
           steps {
               echo env.DISABLE_AUTH
               echo env.ENABLE_AUTH
           }
       }
   }
}

The output to the above groovy script is :

Create nodes for the scripted pipeline.
In the scripted pipelines, use withEnv to define local Jenkins environment variables. The withEnv([“env=value]) {} block can also be used to override any environment variable.
The simple code to declare local environment variables is :

node{
   stage('Build') {
       withEnv(["DISABLE_AUTH=true"]) {
         echo env.DISABLE_AUTH   }
   }
 }

The output to the above groovy script will give the value of environment variable ‘DISABLE_AUTH’ :

3. Injecting Environment Variables in Freestyle Projects

Injecting Jenkins environment variables can be done with the help of a plugin. This plugin is the EnvInject plugin. You can install the EnvInject plugin and inject the environment variables during the build startup. This makes it possible to set up a custom environment for all Jenkins jobs. This plugin is used massively in the freestyle projects of Jenkins. The steps that demonstrate the usage of the EnvInject plugin are:

On the leftmost side, you will find the New Item option. Click on that, and a new window appears.

Enter the Item name and select the Item type from the types available like freestyle project , pipeline, multibranch pipeline, folder etc.
You can provide the name of an existing job if you want this job to be its replica, or you can leave it blank and then click on OK.

Your freestyle project is created.
Click on configure to alter the project and to inject Jenkins environment variables.

In the Source Code Management section, select the None option as we are not fetching code from any code repository. You can choose Git if you want to fetch the code from a Git repository.

You can also select checkboxes in the Build Triggers and Build Environment section to do the necessary settings required.
In the Build section, click on the drop-down Add Build Steps. (This provides the steps taken before a successful build happens.)

Select Inject environment variables from the drop-down. A dialog box will be added to the build section.

In this box, specify the Properties File Path if you have the environment variables defined in a properties file separately.
You can also add environment variables in the Properties Content directly without specifying the file path. Here, ‘Username’ is the environment variable with ‘root’ as its value.

You can also select an option from the drop-down, Post-build Actions to be performed after the successful build.
Click Save and Apply. Your freestyle project is configured successfully.
The output shows that the given environment variable is injected successfully.

Capturing bat Command Output in the Environment Variable

You can capture the output of a shell command or batch command as a Jenkins environment variable and use it in later stages of the pipeline. For that you need to use the exact given syntax – bat(script: ‘cmd’, returnStdout:true). This is to force the bat command to return the output to be captured and stored in an environment variable. The steps to store the output into a Jenkins environment variable are:

Here, we have taken the dir command, and we will capture its output in an environment variable named LS.
We have used a script block to save the output in LS, and then we have accessed the same variable and displayed the saved content.
The groovy script that works for the same is :

pipeline {
    agent any

    stages {
        stage("capturing output in Environment Variables") {
            steps {
                script {
                    env.LS = bat(script:'dir', returnStdout: true).trim()
                   // if you access environment variable in the batch command
                    echo $LS
                }
            }
        }
    }

The trim() method is used to avoid the new line character present in the batch output. It also removes the whitespaces from the beginning and the end of the captured output.
The console output of a successful build for the pipeline which captures bat output in an environment variable is :

In Linux/Unix, you can capture the output from the shell command to the Jenkins environment variable. As the shell commands are different, the syntax will be changed. This will be sh(script:’ls -lah’, returnStdout: true).trim().

As the installation of a plugin is facilitated, new environment variables are added to the jenkins environment variables list. Here, we will install the LambdaTest Jenkins plugin and view the environment variables added by this plugin.

LambdaTest Jenkins plugin helps in pacing up your automated cross browser testing cycles. This easily automates your Selenium test scripts by connecting the Jenkins instance to the LambdaTest Selenium Grid. LambdaTest offers you an expansive library of 2000+ browser and browser versions so as to achieve higher test coverage while performing automation testing using the Selenium suite. You can view the steps to install the LambdaTest Jenkins plugin by clicking here. Some new environment variables added due to the LambdaTest Jenkins plugin are:

When set in the Jenkins pipeline, these environment variables provide the required information for the LambdaTest integration with Jenkins. The groovy script to set these environment variables in a pipeline is :

pipeline{
    agent any
    environment{
          LT_USERNAME='racha10r@gmail.com'
          LT_ACCESS_KEY='iHnnmi0atXDjDKIqckdBH0gU72Uf8zJb76EyNlXjzvGPzvr54'
          LT_TUNNEL=true
        }
    stages{
        stage('printing the environment variables'){
            steps{
                echo env.LT_USERNAME
                echo env.LT_ACCESS_KEY
                echo env.LT_TUNNEL
            }
        }
    }
}

This is a simple groovy script to just set and print the environment variables in the build's console output. The Console Output looks like this:

Using Jenkins Pipeline Environment Variables with LambdaTest Jenkins Plugin

Before we jump off to learn about the practical usage of Jenkins environment variables, let us understand the pre-requisites for the plugin.

Pre-requisites:

A Git repository containing Selenium Test: This is a sample project with some Nightwatch tests scripts; We will run these tests script from Jenkins on the LambdaTest Selenium Grid Cloud. The URL to the repository is: https://github.com/LambdaTest/nightwatch-selenium-sample.git
A Jenkins pipeline: A new pipeline will be created on Jenkins to run the Nightwatch tests on the LambdaTest Selenium Grid. To achieve this, this project is integrated into LambdaTest.
Credentials of LambdaTest Account: The credentials to your LambdaTest profile will be needed. You can easily find the Username and Access Key on the profile section of your LambdaTest Account. (After logging in, click on the rightmost avatar, a dropdown menu will appear and then click on the profile section. You will find the username and Access token there.)

Steps to achieve Integration through Environment Variables

Start the Jenkins Server by traversing to the location of Jenkins folder in CMD(Command Line Prompt) and typing the command “java -jar jenkins.war”. (You can also change the port on which Jenkins is running by adding --httpPort = <port number> attribute to the previous command.)

As the Jenkins server is up and running, go to http://localhost:8082/ and Login to the Jenkins Server.

The Jenkins Dashboard appears; On the Topmost left side, select the New Item Icon. You will be directed to a new configuration page.

Enter the Name of the pipeline (in this case, it’s “Lambdatest Integration Pipeline”), and select Pipeline from the given options. Click on OK. A new Jenkins pipeline is created.

You will be directed to the configuration page for the Jenkins pipeline, Select Tab Pipeline and add the below Groovy Script in order to create three pipeline stages:
- Providing the Environment by LambdaTest Environment Variables: By the withEnv construct you will set the environment with variables, LT_USERNAME, LT_ACCESS_KEY, LT_TUNNEL. These variables will then be used in our whole pipeline.
- Setup Stage: In the setup stage, you will clone the git repository and download the binary file(LT_Windows.zip) required to create an ssh connection through a Tunnel. You will then unzip the zip file and Activate the tunnel by command “LT --user ${LT_USERNAME} --key ${LT_ACCESS_KEY}”.
- Build Stage: After the activation of Tunnel, you will install the required dependencies by commands, npm install and npm install nightwatch.
- Test Stage: In the test stage, we will run the tests with the help of Nightwatch. Here the command used is a batch command : bat 'node_modules/.bin/nightwatch -e chrome tests'. Through this command we are also providing the environment in which the Tests should be run(the environments can be chrome, ie, edge, firefox etc.. LambdaTest eases the process of testing in various environments by providing us to choose the environment as per the need.)

The Groovy Script for the Pipeline to create stages is :

#!/usr/bin/env groovy

node {
    // Sets the environment variables from LambdaTest for testing
    withEnv(["LT_USERNAME=rachna10r@gmail.com",
    "LT_ACCESS_KEY=z71l7Q9ohS9HhKiCqd690mH0sDu5AYrz8VSB0whO3mZ2JEkNAN",
    "LT_TUNNEL=true"]){

    // Just printing the above set environment variables
    echo env.LT_USERNAME
    echo env.LT_ACCESS_KEY 

   stage('setup') { 

      // Get some code from a GitHub repository
    try{
      git 'https://github.com/LambdaTest/nightwatch-selenium-sample.git'

      //Download Tunnel Binary
     bat 'wget "https://downloads.lambdatest.com/tunnel/v3/windows/64bit/LT_Windows.zip"'

     //Required if unzip is not installed
      bat 'unzip -o LT_Windows.zip'

      //Starting Tunnel Process 
     'LT --user ${LT_USERNAME} --key ${LT_ACCESS_KEY}'
         }
    catch (err){
      echo err
        }
   }
   stage('build') {
      // Installing Dependencies
      bat 'npm install'
      bat 'npm install nightwatch'
    }

   stage('test') {
          try{
        // Running the nightwatch tests with environment set as Chrome
          bat 'node_modules/.bin/nightwatch -e chrome tests'
          }
          catch (err){
          echo err
          }  
   }
   stage('end') {  
    // Printing the success message
     echo "Success" 
     }
 }
}

Click on Apply and Save. This will save the pipeline script. And the pipeline is ready to build now.

To run the Jenkins Pipeline, On the Left side menu click on Build Now option. You can also use the Configure option to make changes in the Pipeline Configuration, if required.

As soon as you click on Build Now , You can view the four stages forming in the Stage View (shown in the above screenshot).
On the left side of the Stage view, to check whether the Build was successful or not, click on the Build Number and then go to Console Output. (The Blue ball represents that the build was successful, you can view the whole logs by scrolling down in your log pane.)

Checking the Test Cases on the LambdaTest Automation Dashboard

You will be directed to the LambdaTest Dashboard; On the Left Menu, click on the Automation option.

The LambdaTest Automation Dashboard appears. Select Automation Logs Tab on it.

You will find the Test run from Jenkins with proper configurations. LambdaTest eases the process of testing by providing a video log, screenshot etc. You can view the video log and see how the test is passed and weigh the intricacies of the Nightwatch test run through LambdaTest - Jenkins Integration.

Thus, this way, you can use the LambdaTest Integration with Jenkins for easeful testing. You can also create a freestyle project where after installation of the LambdaTest plugin, the environment variables, LambdaTest credentials etc., can be set manually through a user-friendly UI.

Wrapping Up!

Jenkins has a lot of potential in it. With the integration of various plugins and configuration of different platforms like LambdaTest integration with Jenkins; It provides different environments to create a build and facilitates various applications of continuous integration and continuous deployment.

However, setting up the environment variables is a crucial step in every use case provided by Jenkins. These variables maintain a lot of information required for a successful setup. These are accessed and injected in freestyle projects and pipelines to fulfil essential requirements of the build process and the test process. With Jenkins, we aim to create a robust product or software with excellent test resistance and performance. Thus, ensure that the required Jenkins environment variables are set and can be accessed wherever and whenever necessary.

Also, don't forget to leave your comments, and if you have any query or question, shoot up to the LambdaTest community and get it resolved.

Till then, Happy Testing!

Comprehensive Guide To Jenkins Declarative Pipeline [With Examples]

Abeer Mishra — Thu, 10 Jun 2021 08:56:27 +0000

Jenkins Pipeline is an automation solution that lets you create simple or complex (template) pipelines via the DSL used in each pipeline. Jenkins provides two ways of developing a pipeline- Scripted and Declarative. Traditionally, Jenkins jobs were created using Jenkins UI called FreeStyle jobs. In Jenkins 2.0, Jenkins introduced a new way to create jobs using the technique called pipeline as code. In pipeline as code technique, jobs are created using a script file that contains the steps to be executed by the job. In Jenkins, that scripted file is called Jenkinsfile. In this blog, we will deep dive into Jenkins Declarative Pipeline with the help of Jenkins declarative pipeline examples.

Let’s get started with the basics.

What is Jenkinsfile?

Jenkinsfile is just a text file, usually checked in along with the project’s source code in Git repo. Ideally, every application will have its own Jenkinsfile.

Jenkinsfile can be written in two aspects – Scripted pipeline syntax & Declarative pipeline syntax

What is Jenkins Scripted Pipeline?

Jenkins pipelines are traditionally written as scripted pipelines. Ideally, the scripted pipeline is stored in Jenkins webUI as a Jenkins file. The end-to-end scripted pipeline script is written in Groovy.

It requires knowledge of Groovy programming as a prerequisite.
Jenkinsfile starts with the word node.
Can contain standard programming constructs like if-else block, try-catch block, etc.

Sample Scripted Pipeline

node {
    stage('Stage 1') {
        echo 'hello'
    }
}

What is Jenkins Declarative Pipeline?

The Declarative Pipeline subsystem in Jenkins Pipeline is relatively new, and provides a simplified, opinionated syntax on top of the Pipeline subsystems.

The latest addition in Jenkins pipeline job creation technique.
Jenkins declarative pipeline needs to use the predefined constructs to create pipelines. Hence, it is not flexible as a scripted pipeline.
Jenkinsfile starts with the word pipeline.

Jenkins declarative pipeline should be the preferred way to create a Jenkins job as they offer a rich set of features, come with less learning curve & no prerequisite to learn a programming language like Groovy just for the sake of writing pipeline code.

We can also validate the syntax of the Declarative pipeline code before running the job. It helps to avoid a lot of runtime issues with the build script.

Our First Declarative Pipeline

pipeline {
    agent any
    stages {
        stage('Welcome Step') {
            steps { 
                echo 'Welcome to LambdaTest'
            }
        }
    }
}

We recommend VS Code IDE for writing Jenkins pipeline scripts, especially when creating Jenkins Declarative pipeline examples.

Running Your First Declarative Pipeline

Now that you are well-acquainted with the Jenkins pipeline’s basics, it’s time to dive deeper. In this section, we will learn how to run a Jenkins declarative pipeline. You can refer to our Jenkins Pipeline Tutorial for more.

Let us run our Jenkins declarative pipeline step by step.

Step 1: Open Jenkins home page (http://localhost:8080 in local) & click on New Item from the left side menu.

Step 2: Enter Jenkins job name & choose the style as Pipeline & click OK.

Step 3: Scroll down to the Pipeline section & copy-paste your first Declarative style Pipeline code from below to the script textbox.

Step 4: Click on the Save button & Click on Build Now from the left side menu.

We can see the build running stage by stage in Stage View.

Step 5: To check logs from Build Job, click on any stage & click on the check logs button. Or you can use the Console Output from the left side menu to see the logs for the build.

Console Output

Jenkins Declarative Pipeline Syntax

In this section, we will look at the most commonly used Jenkins declarative pipeline examples or syntax. Typically, declarative pipelines contain one or more declarative steps or directives, as explained below.

pipeline

Entire Declarative pipeline script should be written inside the pipeline block. It’s a mandatory block.

pipeline {
}

agent

Specify where the Jenkins build job should run. agent can be at pipeline level or stage level. It’s mandatory to define an agent.

Possible values-

any – Run Job or Stage on any available agent.

pipeline {
     agent any
}

none – Don’t allocate any agent globally for the pipeline. Every stage should specify their own agent to run.

pipeline {
     agent none
}

label – Run the job in agent which matches the label given here. Remember Jenkins CI/CD can work on Master/Agent architecture. Master nodes can delegate the jobs to run in Agent nodes. Nodes on creation given a name & label to identify them later.

E.g All linux nodes can be labeled as linux-machine

pipeline {
       agent {
           label 'linux-machine'
       }
}

docker – Run the job in given Docker container

A sample can be found here at GitHub.

stages

stages block constitutes different executable stage blocks. At least one stage block is mandatory inside stages block.

pipeline {
       agent {
           label 'linux-machine'
       }
     stages {
     }
}

stage

stage block contains the actual execution steps. Stage block has to be defined within stages block. It’s mandatory to have at least one stage block inside the stage block. Also its mandatory to name each stage block & this name will be shown in the Stage View after we run the job.

In below example, the stage is named as “ build step ”

pipeline {
       agent {
           label 'linux-machine'
       }
     stages {
         stage('build step') {
         }
     }
}

A sample can be found here at GitHub.

steps

steps block contains the actual build step. It’s mandatory to have at least one step block inside a stage block.

Depending on the Agent’s operating system (where Jenkins job runs), we can use shell, bat, etc., inside the steps command.

pipeline {
     agent any
     stages {
         stage('build step') {
              steps {
                 echo "Build stage is running"
              }
         }
     }
}

Scripted Pipeline in Jenkins job

Sample can be found here at GitHub.

parameters

The parameters directive provides a way for Jenkins job to interact with Jenkins CI/CD users during the running of the build job.

parameter can be of the following types – string, text, booleanParam, choice & password

string – Accepts a value of String type from Jenkins user.

E.g.

string(name: ‘NAME’, description: ‘Please tell me your name?’)

text – Accepts multi line value from Jenkins user E.g.

text(name: ‘DESC’, description: ‘Describe about the job details’)

booleanParam – Accepts a true/false value from Jenkins user E.g.

booleanParam(name: ‘SKIP_TEST’, description: ‘Want to skip running Test cases?’)

choice – Jenkins user can choose one among the choices of value provided E.g.

choice(name: ‘BRANCH’, choices: [‘Master’, ‘Dev’], description: ‘Choose the branch’)

password – Accepts a secret like password from Jenkins user E.g.

password(name: ‘SONAR_SERVER_PWD’, description: ‘Enter SONAR password’)

Let’s look at a sample on how to use parameters directive-

pipeline {
    agent any
    parameters {
        string(name: 'NAME', description: 'Please tell me your name?')

        text(name: 'DESC', description: 'Describe about the job details')

        booleanParam(name: 'SKIP_TEST', description: 'Want to skip running Test cases?')

        choice(name: 'BRANCH', choices: ['Master', 'Dev'], description: 'Choose branch')

        password(name: 'SONAR_SERVER_PWD', description: 'Enter SONAR password')
    }
    stages {
        stage('Printing Parameters') {
            steps {
                echo "Hello ${params.NAME}"

                echo "Job Details: ${params.DESC}"

                echo "Skip Running Test case ?: ${params.SKIP_TEST}"

                echo "Branch Choice: ${params.BRANCH}"

                echo "SONAR Password: ${params.SONAR_SERVER_PWD}"
            }
        }
    }
}

If a parameters directive is used in the pipeline, Jenkins CI/CD can sense that it needs to accept the user’s input while running the job. Hence Jenkins will change the Build now link in the left side menu to Build with parameters link.

When we click on the Build with Parameters link, Jenkins CI/CD will let us pass values for the parameters we configured in the declarative pipeline.

Once we enter each parameter’s values, we can hit the build button to run the job.

script

script block helps us run Groovy code inside the Jenkins declarative pipeline.

pipeline {
    agent any
    parameters {
        string(name: 'NAME', description: 'Please tell me your name')
        choice(name: 'GENDER', choices: ['Male', 'Female'], description: 'Choose Gender')
    }
    stages {
        stage('Printing name') {
            steps {
                script {
                    def name = "${params.NAME}"
                    def gender = "${params.GENDER}"
                    if(gender == "Male") {
                        echo "Mr. $name"    
                    } else {
                        echo "Mrs. $name"
                    }
                }
            }
        }
   }
}

script block is wrapped inside the steps block. In the above example, we are printing the name passed as parameter suffixed with Mr. or Mrs. based on the Gender chosen.

We used build with parameters to pass params at the time of running the job.

environment

Key value pairs which helps passing values to job during job runtime from outside of Jenkinsfile. It’s one way of externalizing configuration.

Example- Usually, Jenkins jobs will run in a separate server. We may not be sure where the installation path of JAVA or JMeter is that server. Hence these are ideal candidates to be configured in Environment variables & passed during job run.

Method 1 : Configure Environment Variable in Jenkins CI/CD portal

Step 1: Open Jenkins Server URL (http://localhost:8080)

Step 2: Click on Manage Jenkins from the left sidebar menu.

Step 3: Click on Configure System under System Configuration.

Step 4: Scroll down to the Global Properties section. This is where we will add our Environment variables.

Step 5: Click on the Add button under Environment Variables & enter the Key & value.

We have added the Java installation path under the variable name JAVA_INSTALLATION_PATH

Step 6: Click on Save Button.

Refer Environment variable in Jenkinsfile

We can refer to the Environment variables in declarative pipeline using the ${} syntax

pipeline {
    agent any
    stages {
        stage('Initialization') {
            steps {
                echo "${JAVA_INSTALLATION_PATH}"
            }
        }
   }
}

Method 2 : Creating & Referring Environment Variable in Jenkinsfile

We can create key value pairs of environment variables under environment block. It’s an optional block under pipeline.

pipeline {
    agent any
    environment { 
        DEPLOY_TO = 'production'
    }
    stages {
        stage('Initialization') {
            steps {
                echo "${DEPLOY_TO}"
            }
        }
    }
    }

Method 3 : Initialize Environment variables using sh scripts in Jenkinsfile

Let’s say we need the timestamp when the job gets run for logging purposes. We can create an Environment variable which can hold the timestamp. But how to initialize it ?

We can use the shell script to fetch the current timestamp and assign it to the Environment variable.

Example-

The following command will print date & time in shell

>  date '+%A %W %Y %X' 
Tuesday 03 2021 22:03:31

Lets see how to use the above command to initialize the Environment variable in Jenkinsfile.

pipeline {
    agent any
    stages {
        stage('Initialization') {
            environment { 
                   JOB_TIME = sh (returnStdout: true, script: "date '+%A %W %Y %X'").trim()
            }
            steps {
                sh 'echo $JOB_TIME'
            }
        }
    }
}

returnStdout: true makes sh step returning the output of the command so you can assign it to a variable.

Sample can be found here at GitHub.

credentials() is a special method that can be used inside the environment block. This method helps loading the credentials defined at Jenkins configuration.

Lets see it with an example. First lets configure credential in Jenkins CI/CD-

Creating Credential in Jenkins portal

Step 1: Open Jenkins Server URL (http://localhost:8080)

Step 2: Click on Manage Jenkins from the left sidebar menu.

Step 3: Click on Manage Credentials under Security.

Step 4: Click on the Global hyperlink.

Step 5: Click on Add Credentials from the left side menu.

For demonstration, let me use the following values

Kind – Username with password
Scope – Global
Username – admin
Password – root123
ID – MY_SECRET
Description – Secret to access server files

Step 6: Click the OK button. Now our credentials are configured.

Referring credential in Jenkinsfile

We can use the special method called credentials() to load credentials we configured. We need to use the ID we used while configuring credentials to load a particular credential.

Example- credentials(‘MY_SECRET’)

To refer to the username, append the word _USR to the variable we assigned credentials() output & append the word _PSW to get the password.

Example- Lets load the credential at MY_CRED variable using the credentials(‘MY_SECRET’) method. We need to append _USR ($MY_CRED_USR) & _PSW ($MY_CRED_PSW) to MY_CRED variable to get the username & password.

pipeline {
    agent any
  environment { 
    MY_CRED = credentials('MY_SECRET') 
    }
    stages {
        stage('Load Credentials') {
            steps {
                echo "Username is $MY_CRED_USR"
                echo "Password is $MY_CRED_PSW"
            }
        }
    }
}

Interestingly, Jenkins print username & password as **** to avoid accidental leakage of credentials.

when

Acts like if condition to decide whether to run the particular stage or not . Its an optional block.

when block

pipeline {
     agent any
     stages {
         stage('build') {
              when {
                  branch 'dev'             
              }
              steps {
                 echo "Working on dev branch"
              }
         }
     }
}

when block using Groovy expression

pipeline {
     agent any
     stages {
         stage('build') {
              when {
                  expression {
                     return env.BRANCH_NAME == 'dev';
                  }             
              }
              steps {
                 echo "Working on dev branch"
              }
         }
     }
}

when block with environment variables

pipeline {
    agent any
    environment { 
        DEPLOY_TO = 'production'
    }
    stages {
        stage('Welcome Step') {
                when { 
    environment name: 'DEPLOY_TO', value: 'production'
}
            steps { 
                echo 'Welcome to LambdaTest'
            }
        }
    }
}

when block with multiple conditions & all conditions should be satisfied

pipeline {
    agent any
    environment { 
        DEPLOY_TO = 'production'
    }
    stages {
        stage('Welcome Step') {
            when { 
                allOf { 
                    branch 'master'; 
                    environment name: 'DEPLOY_TO', value: 'production'
                } 
            }
            steps { 
                echo 'Welcome to LambdaTest'
            }
        }
    }
}

when block with multiple conditions & any of the given conditions should be satisfied

pipeline { agent any environment { DEPLOY_TO = 'production' } stages { stage('Welcome Step') { when { anyOf { branch 'master'; branch 'staging' } } steps { echo 'Welcome to LambdaTest' } } } }

Sample can be found here at GitHub.

tools

This block lets us add pre configured tools like Maven or Java to our job’s PATH. It’s an optional block.

To use any tool, they have to be pre-configured under the Global Tools Configuration section. For this example, let’s see how to configure Maven. You can also refer to our Jenkins Maven integration tutorial for more information.

Step 1: Open Jenkins Server URL (http://localhost:8080)

Step 2: Click on Manage Jenkins from the left sidebar menu.

Step 3 : Click on Global Tools Configuration under System Configuration.

Step 4: Scroll down to the Maven section & click on Maven Installations.

Step 5: Click on the Add Maven button. Enter the following values in the configuration.

Name – Maven 3.5.0
MAVEN_HOME – Enter the maven installation path in local

Alternatively we can download Maven from Internet instead of pointing to the local installation path by enabling the Install Automatically checkbox.

Step 6: Click on Add Installer button & choose Install from Apache.

Step 7: Choose the Maven version to download. We have chosen the Maven version 3.6.3.

Step 8: Click on the Save button.

Refer to Maven tool in Pipeline in tools block with the name we used while configuring in Global Tools Configuration (MAVEN_PATH in this example).

pipeline { agent any tools { maven 'MAVEN_PATH' } stages { stage('Load Tools') { steps { sh "mvn -version" } } } }

Sample can be found here at GitHub.

Console Output-

Run the job & we should see the mvn -version command response in console output-

Similarly we can also configure & use tools like Java, Gradle, Git etc from tools block in pipeline code.

parallel

parallel blocks allow us to run multiple stage blocks concurrently. It’s ideal to parallelize stages which can run independently. We can define agents for each stage within a parallel block, so each stage will run on its own agent.

Example- When we want to run a piece of script in windows agent & another script in linux agent as part of the build, we can make them run concurrently using parallel blocks.

pipeline { agent any stages { stage('Parallel Stage') { parallel { stage('windows script') { agent { label "windows" } steps { echo "Running in windows agent" bat 'echo %PATH%' } } stage('linux script') { agent { label "linux" } steps { sh "Running in Linux agent" } } } } } }

Sample can be found here at GitHub.

post

post block contains additional actions to be performed on completion of the pipeline execution. It can contain one or many of the following conditional blocks – always, changed, aborted, failure, success, unstable etc.

post block conditions

always – run this post block irrespective of the pipeline execution status

changed – run this post block only if the pipeline’s execution status is different from the previous build run. E.g., the build failed at an earlier run & ran successfully this time.

aborted – if the build is aborted in the middle of the run. Usually due to manual stopping of the build run

failure – if the build status is failure

success – if the build ran successfully

unstable – build is successful but not healthy. E.g. On a particular build run, test cases ran successfully, but test coverage % is less than expected, then the build can be marked as unstable

Example-

pipeline { agent any stages { stage('build step') { steps { echo "Build stage is running" } } } post { always { echo "You can always see me" } success { echo "I am running because the job ran successfully" } unstable { echo "Gear up ! The build is unstable. Try fix it" } failure { echo "OMG ! The build failed" } } }

Sample can be found here at GitHub.

Marking build as Unstable

There are scenarios where we don’t want to mark build as failure but want to mark build as unstable.

Example- When test case coverage doesn’t cross the threshold we expect, we can mark the build as UNSTABLE.

pipeline { agent any tools { maven 'MAVEN_PATH' jdk 'jdk8' } stages { stage("Tools initialization") { steps { sh "mvn --version" sh "java -version" } } stage("Checkout Code") { steps { git branch: 'master', url: "https://github.com/iamvickyav/spring-boot-data-H2-embedded.git" } } stage("Building Application") { steps { sh "mvn clean package" } } stage("Code coverage") { steps { jacoco( execPattern: '**/target/**.exec', classPattern: '**/target/classes', sourcePattern: '**/src', inclusionPattern: 'com/iamvickyav/**', changeBuildStatus: true, minimumInstructionCoverage: '30', maximumInstructionCoverage: '80') } } } }

Sample can be found here at GitHub.

jacoco() is a special method which helps us configure Jacoco reports including the minimum & maximum coverage threshold. In the above example, min coverage (minimumInstructionCoverage) check is set as 30 & max coverage (maximumInstructionCoverage) check is set as 80.

So if the code coverage is-

Less than 30 – Build will be marked as Failure.

Between 30 & 80 – Build will be marked as Unstable.

Above 80 – Build will be marked as Success.

triggers

Instead of triggering the build manually, we can configure build to run in certain time intervals using the triggers block. We can use the special method called cron() within triggers block to configure the build schedule.

Understanding cron

Cron configuration contains 5 fields representing minute (0-59), hour (0-23), day of the month (1-31), month (1-12), day of the week (0-7)

Example-

Every 15 minutes – H/15 * * * *

Every 15 minutes but only between Monday & Friday – H/15 * * * 1-5

pipeline { agent any triggers { cron('H/15 * * * *') } stages { stage('Example') { steps { echo 'Hello World' } } } }

Sample can be found here at GitHub.

Conclusion

In this blog, we have done an in-depth dive into Jenkins Declarative pipeline examples and their usage. Instead of configuring build steps using UI in a remote Jenkins portal, we would always recommend you to prefer creating Jenkinsfile with Declarative pipeline syntax. Jenkinsfile, since part of the application’s source code, will provide more control over CI/CD steps to developers. That’s the best way to make the most of Jenkins CI/CD and all the features it has to offer!

Happy building & testing!

How To Use Shared Libraries In A Jenkins Pipeline?

Abeer Mishra — Wed, 28 Apr 2021 07:41:09 +0000

As Agile methodology picks pace, tools that enable faster time to deliver software got more prominence. Jenkins, arguably the widely used DevOps automation tool, helps companies achieve the full benefits of Agile methodology. For most developers & testers, Jenkins is not something new. It actually became part and parcel of their job description. In this article, let’s discuss how to use Jenkins effectively by using Jenkins Shared Library.

For beginners on Jenkins, I would recommend reading our article Best Jenkins Pipeline Tutorial For Beginners before continuing to read this Jenkins pipeline shared library tutorial.

Jenkinsfile

In the world of Jenkins, a pipeline is the smallest unit every Jenkins user interacts with. Jenkins pipeline can be defined either by using a Jenkinsfile or GUI (Graphical user interface). We recommend Jenkinsfile over GUI, as GUI may prove ineffective for complex requirements.

Jenkinsfile is just a text file where we write pipeline code to define the Jenkins pipeline. It can be checked into source control like Git along with our project source code. In most cases, every application will have its own Jenkinsfile to build, test & deploy

There are two ways of writing a Jenkinsfile – One is called Scripted Pipeline, where syntax for pipeline is strictly Groovy. Another is a relatively new way of writing Jenkinsfile called Declarative Pipeline.

For starters,

If Jenkinsfile starts with the word node, then it’s a Scripted pipeline.
If Jenkinsfile starts with the word pipeline, then it’s a Declarative pipeline.

We would recommend using Declarative Pipeline as it offers more advantages over Scripted Pipeline.

Jenkins Shared Library

In today’s Microservices world, large monolith applications are broken down into small applications & deployed separately. Interestingly, most of these applications have the same steps to build, test & deploy the application. So instead of repeating those steps for every application, we can actually create a shared library, which can be used across applications.

Why Use Jenkins Shared Library?

Let’s say we have five different Spring Boot applications in our Microservice architecture. All of them need to be built using Maven, run Unit & Integration tests to ensure the integrity of code, packed as a JAR/WAR file & pushed to the artifactory.

Typically, all five applications need their own Jenkinsfile, but the content of the Jenkinsfiles is going to be mostly the same. Jenkins Shared Library avoids this repetition of pipeline code by creating a shared library.

In brief, here are steps to create & use the Jenkins shared library:

Create a separate git repo for the Jenkins pipeline library & push the shared library code to that repo.
Integrate the shared library repo in Jenkins under the Manage Jenkins section.
Create Jenkinsfile in the project. In that Jenkinsfile, Import & use the shared library.

Creating Jenkins Shared Library

Jenkins Shared Libraries are usually pushed into a separate Git repository & checked out by Jenkins job during the job run.

Steps to create Jenkins shared library:

Step 1: Create vars folder

Create a separate project directory. Inside the project directory, create a directory called vars, which will host the shared library’s source code (usually in files with extension .groovy)

Step 2: Create Groovy file

vars 
| --- welcomeJob.groovy

Step 3: Create call() function inside Groovy file

When a shared library is referred from the Jenkins job, Jenkins, by default, will invoke the call() function within our Groovy file. Consider the call() function like the main() method in Java. We can also specify parameters for the call() function if we want to.

def call(String name = 'User') {
        echo "Welcome, ${name}."
}

In the above example, the name is the parameter. Default value ‘User’ will be assigned to the name in case the parameter is not passed by Jenkinsfile.

Now commit & push the contents of the vars folder to a remote git repository.

Configure Shared Library in Jenkins

Now it’s time to configure the Shared Library in Jenkins.

Steps to configure Jenkins pipeline library:

Step 1: Open Jenkins in your browser. (if local, http://localhost:8080/)

Step 2: Click on manage jenkins on the left side menu.

Step 3: Click on configure system. Scroll down until you find the Global Pipeline Libraries section.

Step 4: Under the Library section, configure values as below.

Name (remember, we will refer to this shared library from Jenkinsfile using this name).
Default version (branch name of our Shared Library git repo).
Under the Retrieval method, choose Modern SCM.
Under Source Code Management, choose Git.
- Enter your Pipeline Shared Libraries repo URL under Project Repository
- Configure credentials if your repo requires credentials to checkout code

Step 5: Click on the save button.

Sample configuration for Global Pipeline Libraries

Now that our shared library is configured in Jenkins, let’s create a new Jenkins job to utilize this Jenkins pipeline library.

Referring Jenkins Shared Library from Pipeline

Now, let’s refer to the Jenkins shared library from the pipeline.

Steps to refer Jenkins pipeline library:

Step 1: In Jenkins, click on New Item on the left side menu, enter Jenkins job name & choose the pipeline as style & click on the OK button.

Step 2: Inside the job, scroll down to the pipeline section. Here we need our Jenkinsfile, which refers to the Shared Library. Loading Jenkinsfile into Jenkins job can be done via two approaches.

Approach 1 : Jenkinsfile – Manual approach (Not preferred for production)

Under the pipeline section, you can see a script textbox where we can manually copy, paste the contents of our Jenkinsfile.

// Jenkinsfile
@Library('first-shared-lib') _
welcomeJob ‘lambdatest’

Note: _ (underscore) is a must after the @Library annotation.

@Library will import the shared library to our Jenkins job. (Remember first-shared-lib is the name we gave while configuring shared libraries in Manage Jenkins. Refer to the previous section of this article).

welcomeJob will invoke the call() function in welcomeJob.groovy created under vars folder. The ‘lambdatest’ string will be sent as a parameter to the call() function.

Click on the save button.

Approach 2 : Jenkinsfile – Refer from Git repository (Preferred Approach)

Instead of manually copy-pasting Jenkinsfile content, we can refer to Jenkinsfile committed in a Git repo.

Step 1: In Jenkins job, under the pipeline section, choose pipeline script from SCM for Definition. Configure Git repo URL & credentials in case the repo needs authentication for code checkout.

Step 2: Click on the Save button.

We recommend Approach 2 to load Jenkinsfile into the Jenkins job.

Step 3: Click on Build Now button on the left side menu to trigger the build.

Step 4: Once the build is complete, check the logs by clicking on the Console Output from the left side menu.

You should see the Welcome, lambdatest message in the Console Output.

So we have successfully created & used a Jenkins shared library that prints the Welcome message. But what is the real use of this Jenkins pipeline library feature? Surely it’s not created just to print Welcome messages.

Jenkins Shared Library with Java/Spring Boot Application

Let’s take the example we discussed earlier in this article – Microservices architecture with five Spring Boot applications, with each of them having its Jenkinsfile.

Here is the sample Jenkinsfile to build, test & pack a Spring Boot application:

pipeline {
       agent any
       tools {
           maven 'Maven 3.5.0'
           jdk 'jdk8'
       }
       stages {
           stage("Tools initialization") {
               steps {
                   sh "mvn --version"
                   sh "java -version"
               }
           }
           stage("Checkout Code") {
               steps {
                   git branch: 'master',
                       url: "https://github.com/iamvickyav/spring-boot-data-H2-embedded.git"
               }
           }
           stage("Cleaning workspace") {
               steps {
                   sh "mvn clean"
               }
           }
           stage("Running Testcase") {
              steps {
                   sh "mvn test"
               }
           }
           stage("Packing Application") {
               steps {
                   sh "mvn package -DskipTests"
               }
           }
       }

In brief, the above pipeline code will first load tools like Java & Maven, then checkout code from Git repo, clean up the workspace, then run the test case & finally pack the application as a JAR.

If you notice, other than the Git repo URL, the rest of the steps are applicable for any Spring Boot application. Instead of creating five different Jenkinsfiles, let’s create one Jenkins pipeline library & share it across all Spring Boot applications.

Moving Common Pipeline steps to Jenkins Shared Library

Let’s create a new shared library called jenkinsForJava by creating jenkinsForJava.groovy under the vars directory.

vars
| --- welcomeJob.groovy
| --- jenkinsForJava.groovy

// jenkinsForJava.groovy
def call(String repoUrl) {
  pipeline {
       agent any
       tools {
           maven 'Maven 3.5.0'
           jdk 'jdk8'
       }
       stages {
           stage("Tools initialization") {
               steps {
                   sh "mvn --version"
                   sh "java -version"
               }
           }
           stage("Checkout Code") {
               steps {
                   git branch: 'master',
                       url: "${repoUrl}"
               }
           }
           stage("Cleaning workspace") {
               steps {
                   sh "mvn clean"
               }
           }
           stage("Running Testcase") {
              steps {
                   sh "mvn test"
               }
           }
           stage("Packing Application") {
               steps {
                   sh "mvn package -DskipTests"
               }
           }
       }
   }
}

We moved our pipeline logic to the call() method in jenkinsForJava.groovy. Instead of hard coding the repoUrl, we made it dynamic by accepting the URL from the call() function’s parameter.

Now commit & push the vars/jenkinsForJava.groovy file.

Update Jenkinsfile in Spring Boot Application to use Shared Library

Let’s update the Jenkinsfile present in the root directory of the Spring Boot project with the following content:

@Library('first-shared-lib') _
jenkinsForJava 'https://github.com/iamvickyav/spring-boot-data-H2-embedded.git'

As the call() function in jenkinsForJava.groovy requires the Git repo URL, we passed it as a parameter here.

_ Note: By referring to jenkinsForJava shared library, Jenkinsfile in all our Spring Boot applications got shortened to just two lines – one for @Library import & the other for calling jenkinsForJava Shared Library._

Now commit & push the changes in Jenkinsfile to the remote repo.

Create a new Job for Spring Boot Application by following steps mentioned in Approach 2 – Jenkinsfile – Refer from Git repository (Preferred Approach) section.

Refer to the below screenshot for the final state of the job

Run the job by clicking on Build Now from the left side menu after saving the job changes. You can see the build running in multiple stages, one after the other in the Stage View.

Accessing LambdaTest from Jenkins Shared Library

Let’s consider the following maven project, which contains Selenium Test cases to test the Sample To-Do App.

src/test/java/com/lambdatest/LambdaTest.java

package com.lambdatest

import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class LambdaTest {

   public RemoteWebDriver driver = null;
   String username = "";
   String accessKey = "";

   @BeforeTest
   public void setUp() throws Exception {
       DesiredCapabilities capabilities = new DesiredCapabilities();
       capabilities.setCapability("platform", "Windows 10");
       capabilities.setCapability("browserName", "Chrome");
       capabilities.setCapability("version", "87.0");
       capabilities.setCapability("resolution","1024x768");
       capabilities.setCapability("build", "First Test");
       capabilities.setCapability("name", "Sample Test");
       capabilities.setCapability("network", true);       capabilities.setCapability("visual", true);        capabilities.setCapability("video", true);        capabilities.setCapability("console", true);
       try {
           username = System.getProperty("username");
           accessKey = System.getProperty("accessKey");
           driver= new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"), capabilities);
       } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
       }
   }

   @Test(enabled = true)
   public void testScript() throws Exception {
       try {
           driver.get("https://lambdatest.github.io/sample-todo-app/");
           driver.findElement(By.name("li1")).click();
           driver.findElement(By.name("li2")).click();
           driver.findElement(By.id("sampletodotext")).clear();
           driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
           driver.findElement(By.id("addbutton")).click();
           driver.quit();
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
   }
}

We want to run this test in LambdaTest’s cloud. Hence, we configured RemoteWebDriver with URL:

https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub

_ Note: Sign Up on the https://www.lambdatest.com/ to get your username & accesskey._

Running Test in LambdaTest Cloud from Local

To execute the test in LambdaTest Cloud from your local, use the following command:

> mvn -Dusername=<USERNAME> -DaccessKey=<ACCESSKEY> test

Running Test in LambdaTest Cloud from Jenkins

You need to create LambdaTest Credentials in Jenkins Server:

Open Jenkins URL (http://localhost:8080 if local) & click on manage jenkins on the left side menu.
Click on Manage Credentials.

Enter the Global credentials section & click on Add Credentials.

Configure Username & Password with username & accessKey taken from LambdaTest site, respectively. Add credentials should look like something below:

Create JenkinsSharedLibrary to run test case on LambdaTest Cloud

Create jenkinsLambdaTest.groovy under vars folder

vars
| --- welcomeJob.groovy
| --- jenkinsForJava.groovy
| --- jenkinsLambdaTest.groovy

def call(String repoUrl) {
   pipeline{
       agent any
       tools {
           maven 'Maven 3.5.0'
           jdk 'jdk8'
       }
       environment {
           LAMBDA_TEST_CRED = credentials('lambdatest-site-cred')
       }
       stages {
           stage("Tools initialization") {
               steps {
                       sh "mvn --version"
                       sh "java -version"
                   }
               }
           stage("Checkout Code") {
               steps {
                   git branch: 'main',
                   url: "${repoUrl}"
               }
           }
           stage("Running Testcase") {
               steps {
                   sh "mvn -Dusername=${LAMBDA_TEST_CRED_USR} -DaccessKey=${LAMBDA_TEST_CRED_PSW} test"
               }
           }
       }
   }
}

We used environment block in pipeline code to load the credentials we created under the Manage Credentials section.

environment {
                LAMBDA_TEST_CRED = credentials('lambdatest-site-cred')
        }

The entire credential is loaded into the LAMBDA_TEST_CRED variable.

_USR is appended with LAMBDA_TEST_CRED to access username & _PSW is appended with LAMBDA_TEST_CRED to access password (accessKey for LambdaTest portal).

So our final mvn test command looks like below:

mvn -Dusername=${LAMBDA_TEST_CRED_USR} -DaccessKey=${LAMBDA_TEST_CRED_PSW} test

Create Jenkinsfile to use Shared Jenkins Library

Create Jenkinsfile in source code repo with the following content

@Library('first-shared-lib') _
jenkinsLambdaTest 'https://github.com/iamvickyav/lambdatest-sample-repo.git'

Now create a new job in Jenkins with pipeline as Job type & configure the pipeline section to refer to the Github repo.

Click on the Save button & run the job by hitting Build now link from the left side menu. You should see test progress in the Jenkins Stage view.

You should also see the test report in LambdaTest cloud.

Wrapping Up

To summarize, in this Jenkins pipeline shared library tutorial we have discussed what is Jenkins shared library, when & how we can use it. Creating Jenkins jobs using GUI is the right place to start learning Jenkins. But it’s just the baby steps. We should not rely on GUI to create our project-related work instead, we should use Jenkinsfile to create our jobs. But it’s also important to learn how to use Jenkinsfile efficiently. Jenkins shared Library is just the first step in that direction.

I hope you found this article useful. Please let us know your feedback in the comment section below.

Selenium SendKeys : All You Need To Know

Abeer Mishra — Thu, 11 Mar 2021 07:33:23 +0000

Selenium automation is not just about navigating and clicking through the links. Yes, you can use it to switch tabs, find broken links, or even drag and drop directly. But there is a lot more to it. An essential aspect of test automation is passing values to the text fields. In this article, we’ll delve into how Selenium helps us pass values to text fields using the Selenium sendKeys() method. Let us start on our journey to learn how to sendkeys in Selenium.

What Is Selenium sendKeys() Method?

Selenium provides sendKeys() method to input content in editable text fields or password fields in a webpage. These fields are like the typical web elements present on the web page that can be identified using any of the Selenium locators. You can refer to our article on Selenium locators to learn more about the different locators you can use.

Let us understand the utility of the sendKeys() method through an example. Consider the below use-case:

Open the website > LambdaTest
Locate the web-element to enter the email address.
Enter your email address.
Click on the ‘Start Free Testing’ button.

Let us now see what the code for the above use-case would look like, and then we will understand the code line-by-line.

package sendkeys;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class SendkeysTest {

WebDriver driver;

    //Method to set up the browser and open the dummy website
    @BeforeClass
    public void setUp() {

            System.setProperty("webdriver.chrome.driver", "D:\\Selenium\\drivers\\chromedriver.exe");
            driver = new ChromeDriver();
            driver.get("https://www.lambdatest.com");
            driver.manage().window().maximize();
    }

    @Test
    public void testSendkeys() {
            //Locate the email and use sendkeys to pass the email to the field
            driver.findElement(By.id("useremail")).sendKeys("----your email id----");

            //Locate the Start Free Testing button and click it
            driver.findElement(By.xpath("//*[@id='testing_form']//button")).click();
    }


    @AfterClass
    public void burnDown() {
            driver.quit();
    }

}

Let us first understand the code above and then see the execution part.

The code under @BeforeClass method- The method setUp() contains the generic code to instantiate the ChromeDriver and navigate to the LambdaTest] website. The page is then maximized.
The code under @AfterClass method- Similar to the setUp method, the burnDown() method simply closes the browser instance.
The code under the main @test method- This is the method consisting of our test case. We simply locate the text field where we have to enter the email ID and then pass on the string (which is our email ID) to the sendKeys() method. Next, we locate the ‘ Start Free Testing ’ button and click the same.

Note: The code to use the Selenium sendKeys() method can also be written as shown below-

WebElement emailField = driver.findElement(by.id(“useremail”));
emailField.sendKeys(“---your email id---”);

This is just the bifurcation of the web element and then passing the string value to the text box.

On running the above test, you will see that the browser actions are performed, and your email is entered into the email ID text field.

Did you see how easy the Selenium sendKeys() method is?

Using Selenium sendKeys To Erase Text

Next, let us consider a scenario where we need to verify that we are able to clear or delete the string entered in the text field. To achieve this case, we will use the Selenium clear() method, which simply erases whatever text is entered in the text field.

Consider the below code for the same-

package sendkeys;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class SendkeysTest {

WebDriver driver;

    //Method to set up the browser and open the dummy website
    @BeforeClass
    public void setUp() {

            System.setProperty("webdriver.chrome.driver", "D:\\Selenium\\drivers\\chromedriver.exe");
            driver = new ChromeDriver();
            driver.get("https://www.lambdatest.com");
            driver.manage().window().maximize();
    }

    @Test
    public void testSendkeys() {
            //Locate the email and use sendkeys to pass the email to the field
            WebElement email = driver.findElement(By.id("useremail"));
            email.sendKeys("---your email id---");

            // Erase the text entered in the email id field
            email.clear();
    }


    @AfterClass
    public void burnDown() {
            driver.quit();
    }

}

The code is the same as we explained earlier, but the only addition is the clear() method used for the email web element. This clear method would erase the text entered in the text field, and you can further enter the text using the sendKeys() method as per your requirement.

Now that we have seen how to sendKeys() in Selenium with its implementation, we hope you understand it better. We have also seen how we can erase the string or text already entered in the text field using the clear() method. We will now explore some other options to enter text in the text field without using sendKeys().

How Can We Type In Selenium Without Using sendKeys?

Although sendKeys() works almost every time, there might be a case where the text input box is disabled, and you need to pass some text to the field. In such scenarios, sendKeys() would not work, and you might have to try some alternate approach. Before we move onto the use case, remember that this is not the recommended way to test as the UI blocks you from entering any text in a field. Just for the sake of understanding our use case, let us consider such a scenario.

Now, you might be wondering if not Selenium sendKeys, then what? One of the most effective ways to send input to text fields is to use the JavaScriptExecutor, which we will discuss below.

Using The JavaScriptExecutor

We will now use JavaScriptExecutor to locate the text box and then pass the text value to it. Let us see how the code for it would look like-

JavascriptExecutor jse = ((JavascriptExecutor)driver);          
WebElement email = driver.findElement(By.id("useremail"));
jse.executeScript("arguments[0].value='---your email id---';", email);

As can be seen from the above code, we are merely passing the text box’s arguments as a script for the JavaScriptExecutor and not using sendKeys(). Try using these code lines in our example above by replacing the sendKeys() code and seeing that you will get the same results as with the sendKeys() method.

Now that you understand how to sendKeys() in Selenium let us now see how the LambdaTest Selenium Grid cloud can efficiently execute your tests across different system configurations.

Implementing Selenium sendKeys On LambdaTest Grid

It is highly likely that you have to run your automation suite across multiple browsers and OS configuration. LambdaTest Grid provides you an easy solution to execute your tests across multiple combinations by leveraging capabilities. These capabilities can be generated directly from the LambdaTest capabilities generator and integrated into your Selenium test.

Note that we will use the same example used above for execution on LambdaTest Grid cloud for one browser, but you can use the same test to perform cross browser testing by changing the capabilities and using Data Provider, as explained in our article on parallel testing.

package sendkeys;
import java.awt.AWTException;
import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class SendkeysTest {


            public String username = "--- your user name ---";
            public String accesskey = "--- your access key ---";
            public static RemoteWebDriver driver = null;
            public String gridURL = "@hub.lambdatest.com/wd/hub";
            boolean status = false;
    //Method to set up the browser and open the dummy website
    @BeforeClass
    public void setUp() {

            DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("browserName", "chrome");
            capabilities.setCapability("version", "81.0");
            capabilities.setCapability("platform", "win10"); // If this cap isn't specified, it will get any available one
            capabilities.setCapability("build", "LambdaTestProject");
            capabilities.setCapability("name", "LambdaTestSendKeysProject");
            capabilities.setCapability("network", true); // Enables network logs
            capabilities.setCapability("visual", true); // Enables step by step screenshot
            capabilities.setCapability("video", true); // Enables video recording
            capabilities.setCapability("console", true); // Captures console logs
            try {
           driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
            } catch (MalformedURLException e) {
           System.out.println("Invalid grid URL");
            } catch (Exception e) {
           System.out.println(e.getMessage());
            }
            driver.get("https://www.lambdatest.com");
    }

    @Test
    public void testSendkeys() throws AWTException {


            //Locate the email and use sendkeys to pass the email to the field

            WebElement email = driver.findElement(By.id("useremail"));
            email.sendKeys("abc@abc.com");


            //Locate the Start Free Testing button and click it
            driver.findElement(By.xpath("//*[@id='testing_form']//button")).click();


    }


    @AfterClass
    public void burnDown() {
            driver.quit();
    }

}

You may change the capabilities settings as per your requirements and execute the test. You will see that the LambdaTest platform provides you a beautiful user interface of the test results, including a video of the execution. You can find these results under the Automation Logs tab in the Automation dashboard as shown below-

See how seamless Selenium automation can be by leveraging the capabilities of LambdaTest Grid cloud? Now, go ahead and try running a test case of your own that uses the sendKeys() method and leverages the capabilities of LambdaTest.

Conclusion

We understood what the Selenium sendKeys() method is and how it can be used in Selenium automation.
We saw how the clear() method could be used to clear off any string that is already present or entered in a text field.
We then saw how we could use the JavaScriptExecutor to enter text or string in a text field if we do not use the sendKeys() method.
Finally, we ran our test on the LambdaTest Grid, which helps us execute our tests in parallel across 2000+ browsers and operating systems.

We hope you found this article informative; we would love to hear what you think. Don’t forget to leave your comments below.

Happy Testing!

Nightwatch Vs Protractor: Which Testing Framework Is Right For You?

Abeer Mishra — Tue, 09 Feb 2021 07:43:03 +0000

Do you know the test automation market is all set to hit $35 billion by 2026? And when it comes to cross browser testing, JavaScript leads from the front? Javascript is probably the best alternative for Selenium automation, considering its protocol transformation to the W3C standard. In order to make the most of it, the first step is to choose the best test automation frameworks. Among all the JavaScript testing frameworks, two frameworks are most popular- Nightwatch and Protractor.

This article will be comparing Nightwatch vs Protractor and help you choose the perfect JavaScript testing frameworks. Let us start by diving deeper into each framework.

What Is Nightwatch.js?

Nightwatch.js is a free automation test framework for websites and web apps. It is written in Node.js and also utilizes the W3C WebDriver API. Nightwatch is an end-to-end testing (E2E) solution that aims to simplify writing automation tests with Javascript for browser apps, web-based apps, and websites. It is one of the most popular test automation frameworks that functions by communicating over a restful HTTP API amid a WebDriver server (like Selenium Server or ChromeDriver).

Nightwatch relies on Selenium and offers various assertions and commands within the framework to carry out operations on the Document Object Model (DOM) elements. The protocol is clearly defined by the W3C WebDriver specification (mainly originated from JSON Wire protocol). The newest version accessible in the market is 1.0.

Why Is Nightwatch.js So Popular?

Before we dive into Nightwatch.js features, pros, and cons, it is significant to understand the reasons behind this testing framework’s fame. Nightwatch.js facilitates end-to-end functional browser tests in a pure Node.js environment, which allows testing of web apps independent from third party software.

The key reason for robust and lightweight test automation frameworks like Nightwatch is facilitating a single integrated solution for app tests. As this automated testing framework is built on Node.js, it has several benefits over any other Selenium test automation tool. The browser tests powered by Nightwatch.js remove the dependency upon third party software, which improves data integrity amongst varied system components.

Crucial Features Of Nightwatch.js

To compare Nightwatch vs Protractor, we must understand the features of both of these JavaScript testing frameworks. First, let us dive deep into the core features offered by Nightwatch.js:

In-Built Command-line Test Runner: Nightwatch comes with an in-built test runner suite with Grunt’s support for performing the test automation.
Selenium Server: It comes with a capacity to control the separate Selenium server automatically by offering a built-in JUnit XML reporting feature.
Smart Testing Strategy: Nightwatch has an exceptional feature to run the tests effectively and can be performed in numerous ways like sequentially, parallelly, or tags and groups.
Assertions, XPath, & CSS: Various assertions and commands for Document Object Model (DOM) operations, XPath and CSS selectors, and can be used to recognize the page’s elements. That’s what makes this framework flexible and easy to extend, particularly while executing the app-specific assertions and commands.
Cloud Services: It offers excellent support for cross browser tests with Selenium JavaScript. It allows easy integration with many well-known cloud-based Selenium test automation providers such as LambdaTest.
Continuous Integration (CI): It provides excellent assistance for CI and can be used to incorporate the testing with the continuous build processing systems like TeamCity, Jenkins, etc., and supports software developers to build and test software continually.

Apart from all the attributes mentioned above, it is also famous for having an easy and straightforward syntax, making it simpler to write the tests rapidly and effectively using XPath locator and Node.js CSS selectors in Selenium.

Core Advantages Of Nightwatch

Nightwatch is one of the most popular test automation frameworks for websites and web apps. The core benefits of using Nightwatch as the preferred JavaScript testing framework are as follows:

Built-in command-line test runner.
The syntax is easy to understand.
Flexible assertions and commands that are easy, quite easy to extend.
Can control individual Selenium servers in a separate child procedure. This automated framework automatically also handles WebDriver services (GeckoDriver, Safari, Edge).

Nightwatch is advantageous for end-to-end test automation as it allows us to write all-inclusive tests in Node.js effortlessly and rapidly. It makes the entire process of test automation and continuous integration much more seamless. Nightwatch lets us configure the Selenium test suite and enables parallel testing that additionally controls the build time.

Why Choose Nightwatch Over Other JavaScript Testing Frameworks?

Selenium is the most in-demand automated testing framework as it offers support for cross browser testing, numerous programming languages and is also used in both the mobile app and web app tests. However, Nightwatch completely utilizes JavaScript as the programming language for comprehensive tests, which has the listed benefits:

Improvise test structuring
Robust configuration
Enables configuration with Cucumber for building a robust Behaviour Driven Development (BDD) setup
Lightweight framework
Incorporates with cloud servers
Excellent performance of the automation implementation
Minimum practice and minimum maintenance of code

How Does Nightwatch.js Work?

This test automation framework mainly connects over a restful API protocol (defined by the W3C WebDriver AP). It requires a restful HTTP API with a JavaScript WebDriver server (such as Selenium JavaScript WebDriver server.)

To execute any operation, i.e., either an assertion or command, Nightwatch typically requires sending fewer than two requests. It functions as follows:

The first and foremost request locates the necessary elements with the given CSS selector or XPath expression.
However, the second request takes the constituent and carries out the definite operation of assertion or command.

Prerequisites For Nightwatch.js

Node.js – You need to have Node.js installed on your computer before installing this test automation framework. To check if you have Node.js pre-installed on your system, simply type:

node -v

You will notice the Node.js version. This must also install the node package manager (npm). To confirm it, type the following:

npm -v

The npm version will be prompted.

WebDriver- This test automation framework supports major browsers, i.e, Firefox, Chrome, Safari, and Internet Explorer. For your Nightwatch.js testing to implement on your chosen browser, you need to find the web driver for that precise browser. You can set up the browser either through npm or through the web pages.

Selenium WebDriver for popular browsers can be downloaded from the links given below:

BROWSER	DOWNLOAD LOCATION
Firefox	https://github.com/mozilla/geckodriver/releases
Chrome	http://chromedriver.chromium.org/downloads
Internet Explorer	https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver
Microsoft Edge	https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/

To run your tests on several browsers you may use a cloud Selenium Grid.

Installing Nightwatch Via npm-

We commence off with standard npm installation of the package using the following command-

$ npm install nightwatch --save-dev

There are some significant things which you require to manually install:

Browser Driver (ChromeDriver)
Selenium Server
Java Development Kit (JDK) (>v7)

You also require a nightwatch.json configuration file to allow this test framework to know how it must run.

Once you have installed all the required tools, you can start running your tests using this command:

nightwatch *.spec.ts

Nightwatch – Pros & Cons

In this section of Nightwatch vs Protractor comparison, we will look into the pros and cons of using Nightwatch as your preferred JavaScript testing framework.

Pros Of Using Nightwatch

A clean syntax lets you write tests rapidly.
Allows use of CSS as well as XPath selectors to locate elements.
It works seamlessly with cloud-based testing platforms like LambdaTest.
CI (Continuous Integration) support – Integrates your testing with systems like Teamcity, Hudson, Jenkins.

Cons Of Using Nightwatch

Since it comes with its own test automation framework and therefore, it offers less flexibility to your own unit tests.
Lack of proper support.

Now that we have understood what Nightwatch is, it is time to dive deeper into Protractor. This will give us a deeper insight into the Nightwatch vs Protractor comparison.

What Is Protractor?

Protractor is one of the crucial automated and JavaScript testing frameworks. It is most commonly used as an end-to-end behavior-driven testing tool, specifically for AngularJS. It functions as a Solution integrator combining robust technologies and tools such as WebDriver, Jasmine, Cucumber, Mocha, Selenium, etc. The Protractor framework’s objective is not merely to test AngularJS apps but also to write automated regression testing for normal web apps. Google Developers originally developed it for supporting Angular apps, and later it was launched as a free framework.

Currently, Protractor supports both Non-Angular and Angular apps. It is one of the most popular JavaScript testing frameworks and is written on top of Webdriver.js. Thus, in addition to Angular-specific traits, the entire feature set supported in Selenium Webdriver is maintained by it. It gets a little tricky to identify web elements in the AngularJS app, and Selenium WebDriver often fails with HTML attributes like ng-model or ng-controller. This is where Protractor has the upper hand as it helps control those components and test the actual functionality.

Why Is Protractor So Popular?

Protractor acts as an e2e test framework for both non-Angular and Angular apps that don’t use CSS elements. Automating web apps built on AngularJS by making use of this tool is a crucial step forward for companies in their efforts to automate the business process. It does not require you to add sleeps and waits. As the webpage completes pending steps, Protractor executes the subsequent moves of the test case by automatically linking with the AngularJS app. Additionally, it is quite simple to install page objects.

This angular framework does not execute WebDriver commands till action is required, e.g., installing page objects so that script can operate on-page elements without affecting the HTML. Protractor also assists in Angular-specific locator strategies as well as native WebDriver locator tactics.

Crucial Features Of Protractor

In this section of the Nightwatch vs Protractor blog, we will understand Protractor’s most crucial features. It has the following core features:

Supports Angular-Specific Locators: It is one of the best automated JavaScript testing frameworks that introduced us with angular precise locators like ng-repeat, ng-bind, ng-model, etc. Needless to say, it offers great support for such locators. You do not need to generate complicated XPath for angular locators. In this framework, those locators are all set for you, so you can simply utilize by.repeater, by.model, etc.
Supports Both Angular & Non-Angular Apps: It has extensive support for Angular; however, it also supports non-Angular apps. Even if one section of your app is non-Angular and another fraction of it is Angular, this test automation framework is your safest bet for comprehensive automated tests.
Supports Cross Browser Tests: You can effortlessly execute your scripts in several browsers such as Edge, Chrome, IE11, Safari, and Firefox. Configuring such browser compatibility testing is easy and doesn’t take much effort and time with Protractor.
Supports Parallel Execution: It also supports parallel test execution. When you have an enormous number of test cases lined up, and every test case requires sequential execution, this feature comes in handy.
Supports Headless Browser: The kind of browser is devoid of the UI. This test framework also lets you run your test cases in headless browser modes.
Supports Extensibility: As it is a node.js app, you can use an extensive range of packages that are accessible in the node. Therefore you can expand this framework or add new traits by setting up node packages. For instance, if one necessitates an HTML report, one could simply use Jasmine HTML Reporter. Similarly, for cleaning up the code, we can set up tslint or eslint, or you can set up node packages of your preference.
Supports Various Assertion Libraries: It also supports various assertion libraries such as Mocha, Jasmine, or you can even make use of your tailor libraries. However, by default, for assertions, it uses the Jasmine framework.
Supports Cloud Testing: Cloud test platforms enable you to execute our specs on various browsers (Safari, Firefox, Chrome, etc.) and several operating systems (Mac, Windows, Mobile, Linux, etc.). It is supported by several cloud-based test platforms like LambdaTest.
Supports CI/CD: Once your automated scripts are in place, you do not have to manually monitor and run them. Each time a new code goes to the repository, these tests automatically run and get you the report. Protractor can be integrated with tools like Azure DevOps, Jenkins, or TFS to automate the procedure. It also supports CI/ CD.

Core Advantages Of Protractor

Next up in this Nightwatch vs Protractor blog, we will be looking at reasons to consider while switching from other test automation frameworks to Protractor. This open-source E2E JavaScript testing framework provides the following benefits −

This open-source tool is simple to set up or install.
Functions well with Jasmine framework for creating the test.
Supports TDD (test-driven development).
Supports parallel testing via manifold browsers.
Comprises automatic waits that means you don’t require to add waits & sleeps to your script explicitly.
Provides the entire benefits of Selenium WebDriver and auto-synchronization.
Offers remarkable testing speed as compared to other tools.
Offers built-in support for Angular.js components like by.repeater, by.exactRepeater, by.binding, by.model, by.excatBinding, by.options, etc.

Why Choose Protractor Over Other JavaScript Testing Frameworks?

We are all aware of the fact that almost every kind of app is using JavaScript for software development today. A QA engineer’s job turns very tricky when JavaScript enhances in size and becomes complicated because of the rising number of JS-based apps. A majority of the time, it turns into a challenging situation due to an inability to locate the web elements in AngularJS apps using expanded HTML syntax or using Selenium WebDriver or JUnit.

Selenium WebDriver is unable to search AngularJS web components. This is because AngularJS apps use some expanded HTML elements like ng-model, ng-controller, ng-repeater, etc., which aren’t counted in Selenium locators.

Therefore, the significance of Protractor comes into play as this framework can easily control and manage those extended HTML components in AngularJS web apps. While most frameworks concentrate on executing unit testing for AngularJS apps, Protractor is used to perform tests of the app’s real functionality

How Does Protractor Work?

This framework is one of the select few JavaScript testing frameworks built on top of WebdriverJS. It is a Selenium-based test framework which allows Protractor to integrate with Selenium WebDrivers and server like SafariDriver, GeckoDriver, ChromeDriver, etc. to imitate the user activities.

Subsequently, it also offers support for several assertions frameworks like Mocha, Jasmine, etc. This assertion framework allows you to verify or validate the values; in turn, the testing will be marked as fail or pass. In simple words, Protractor, Selenium Server, WebdriverJS, Assertion Framework, and Browser Driver give the infrastructure to write and execute our E2E (end-to-end) testing

Prerequisites For Protractor

Node.js- To perform testing, you need to have Node.js installed. One needs to download the Protractor package by making use of npm that mainly comes with Node.js. Verify the Node.js version you need by running node -v.

Afterward, it is better to scrutinize the compatibility notes in the Protractor README to make certain your Node.js version is perfectly compatible with this framework. However, by default, this framework uses Jasmine for its test interface.

Installing the package

npm install -g protractor

In contrast to Nightwatch, one does not have to install Selenium manually as it comes in-built in Protractor. But, it does require ensuring the browser driver versions are latest and updated. Use this command-

webdriver-manager update

The protractor.dev.conf.js configuration file is also required.

For performing the testing, we have to begin the Selenium server firstly earlier than we are capable to run Protractor.

webdriver-manager start

protractor protractor.dev.conf.js

In hindsight of the Nightwatch vs Protractor comparison, the setup procedure is somewhat simpler than Nightwatch.

Protractor – Pros & Cons

Before moving on to the final comparison between Nightwatch vs Protractor, let us take a look at what Protractor has to offer. Listed below are the pros and cons-

Pros Of Using Protractor

Protractor smartly supports TDD (test-driven development).
Supports parallel testing via manifold browsers.
Provides the advantage of auto-synchronization.
Provides rapid testing speed when compared to other tools or libraries.
Supports CI/ CD.

Cons Of Using Protractor

Does not support mobile applications.
Debugging is complicated and tricky.
You must know JavaScript to get well-versed with Protractor.
This framework is a wrapper around WebdriverJs. So if there is any concern with WebdriverJs, it might also be an issue with Protractor.

Comparing Nightwatch Vs Protractor

Conclusion

When it comes to choosing between Nightwatch vs Protractor, it is a tough call to take. Using Protractor with Selenium is better if one needs to carry out full E2E testing that opens a browser and executes a DOM manipulation. Besides, Protractor is particularly better for angular applications. On the other hand, in test automation frameworks like Nightwatch, asserts are prepared automatically. It also creates a test report automatically plus keeps it in a directory.

Remember that Protractor also offers an impressive set of features, especially when some components are not easy to detect and require an element explorer. If you are working on Angular, the project is not big, and Chrome is the prime browser—look no more! You can make use of Protractor. As Protractor is rooted in WebDriver, cross browser testing would not be any problem at all. Additionally, you can use cloud-based cross browser testing platforms like LambdaTest to take advantage of a Selenium grid cloud for test execution. It lets you perform tests on a combination of 2000+ browser and operating systems.

Before selecting a framework, understand the development technique and testing criterion. Once done, pick out the framework that suits your requirements. We hope this will help you pick the right test automation framework.

Happy testing!

21 Of The Best Jenkins Alternatives For Developers

Abeer Mishra — Mon, 04 Jan 2021 09:34:52 +0000

When it comes to CI/CD tools, we’re all too familiar with Jenkins. It has been a popular choice among Java developers for continuous integration and continuous development approach. It is a super-effective tool to build and test projects, thereby making easy integration possible continuously. Also, it is an open-source tool that provides multiple plugins.

However, Jenkins isn’t the only CI/CD tool out there. You can pick a Jenkins alternative as you’ve got a lot of options!

Now, the question is, with so many choices, how do you pick the best alternative to Jenkins? Well, to make it easier for you, we have created a list of 21 of the best Jenkins alternatives. Keep reading to learn about them.

_ Note: The following list of Jenkins alternatives isn’t in any particular order. Its hierarchy does not reflect importance or value in any way, shape, or form._

1. GitLab

GitLab CI/CD tool is a part of GitLab and a powerful alternative to Jenkins. It is an open-source web interface that can be used to apply all the continuous methods like integration, delivery, and deployment to your project without any third-party application. It provides a user-friendly interface along with distributed version control services.

Some of the top features that make it one of the best alternatives to Jenkins are:

Just like Jenkins, it is an open-source tool too.
You can test your build in parallel, thereby reducing time.
It allows docker integration and helps in automating release and application delivery.
It provides better support.

2. Atlassian Bamboo

Bamboo is a product of Atlassian, and it’s a useful tool for continuous integration, development, and deployment. It runs builds and tests and efficiently integrates with JIRA to update issues and commits and connect test results for an end to end visibility within the team. It supports multiple technologies like AWS, Amazon S3 buckets, Git, SVN, Mercurial, etc.

Some of the key features of Bamboo includes:

It can be used to run parallel batch tests.
It provides seamless integration with JIRA, BitBucket, and Fisheye.
It is effortless to set up.

3. CircleCI

CircleCIis a flexible tool with easy maintenance and can run in almost any environment. Every commit leads to automatic build execution. To add to it, if any new build is triggered, any queued or running build is automatically canceled.

Besides, it provides features like:

Integration with GitHub, Bitbucket, and GitHub Enterprise.
It splits tests among multiple containers, thereby reducing build time.
It provides SSH support so that users can access the Virtual Machine via SSH and run commands.
Very easy to maintain as it allows for automatic upgrades.

4. TeamCity

TeamCity is also known as the “Intelligent CI Server” because of its ease of use and integration. It offers different installation packages for different operating systems. It is a powerful tool developed from JetBrains, which allows building, and running tests even before changes are committed, hence keeping the code clean.

Some of its features that make it one of the best Jenkins alternatives are:

It is well documented and provides easy installation.
It provides integration with tools like Docker, JIRA, etc.
It offers well-defined APIs available for extension.

5. Travis CI

Travis CI is a continuous integration and testing CI/CD tool. It is free of cost for open source projects and provides seamless integration with GitHub. It supports more than 20 languages, like Node.js, PHP, Python, etc. along with Docker.

Some of the key features of Travis CI includes:

Very easy to set up with broad user community support.
No project is merged before tests are passed successfully.
You can easily customize the build environment as per your requirements.

6. BuildMaster

BuildMaster by Inedo is one of the best Jenkins alternatives that offers continuous integration on different platforms. With BuildMaster, you can manage your apps and deploy them to the environment without any hassle. Moreover, it doesn’t require extensive expertise to set up the pipelines.

Some of its features include:

Create release management platforms that can be self-managed.
Automated gates prevent the release of untested software.

7. Bitrise

Bitrisecomes as a platform as a service (PaaS) for continuous integration and continuous delivery in mobile applications. Each build runs on its virtual machine, and at the end of the build, the data is scrapped. It offers a free plan and allows integration with services like Slack, HockeyApp, etc.

Also, it provides features like:

Apps are delivered without any manual intervention.
It integrates with major third-party testing and deployment services.
It allows quick setup having service integration with a lot of services.

8. Spinnaker

Spinnaker is an open-source platform developed by Netflix for continuous delivery. It is powerful and provides integration with major cloud providers. It supports multiple hosting technologies like Docker, Kubernetes, etc. It is useful for cloud-focused approaches.

Some of the key features of Spinnaker includes:

Powerful and flexible pipeline management system.
It provides integrations to the major cloud providers like Google Cloud Platform, AWS, Microsoft Azure, and Oracle Cloud.

9. UrbanCode

An IBM product, UrbanCode, is a continuous integration application that provides multiple features like visibility, traceability, and auditing bundled in a single package. It enables you to deliver applications faster. Irrespective of the environment, you can quickly deploy applications to data centers, cloud, or virtual environments with no error.

Some of its features that make it a preferred Jenkins alternative are:

It minimizes deployment errors.
Drag and drop feature in the editor makes it convenient to use.
Increased frequency to deliver applications.

10. Buddy

Buddy, also known as Buddy Works, is a continuous integration and delivery software with an interactive user interface, making for a perfect Jenkins alternative. It helps to build, test, and deploy applications faster quickly. You can get your CI/CD pipeline running in just a few minutes’ configurations.

Besides, it provides feature like:

It offers on-premise solutions.
It provides support for multiple languages.
One can customize the build and test environment as per requirements.

11. Drone.io

Drone is considered one of the best Jenkins alternatives when it comes to integrating and deploying for busy development teams. It is a continuous self-service integration and delivery platform. It provides you the ability to customize multiple features on the go. It integrates easily with GitHub, GitLab, Bitbucket, and GitHub Enterprise.

Some of its top features include:

It supports multiple languages and operating systems.
It provides plugins for pre-configured steps.
Every build is executed in an isolated container.
It provides auto-scaling with a single binary file.

12. AWS CodePipeline

AWS CodePipeline is a continuous integration and continuous delivery service that easily and quickly automates your release pipelines for updates. Every time you change the code, AWS CodePipeline will build, test, and deploy your application. Also, it can be easily integrated with GitHub.

Some of its features that make it an ideal Jenkins alternative are:

Follows the pay for what you use approach. You need not block your money or pay any fees. You only pay for what you are using.
It provides a workflow that can be configured as per your release stages.
It offers parallel execution, thereby increasing the workflow speed.

13. CruiseControl

CruiseControl is a continuous integration tool, and it provides a framework that can be extended to create customized build processes. Though written in Java, it can be used in different projects with the help of builders provided by it. It can integrate with different source control systems.

Some of the key features of CruiseControl includes:

Provide remote management support.
You can build multiple projects on a single server.
Provides email and messaging notifications.

14. Integrity

Integrity is a continuous integration server that builds your code and runs your test as soon as a commit happens. A report is then generated, and the users or the team is notified. The only limitation is that it can be used only with GitHub but can be mirrored with other SCM.

Some of its features include:

It supports multiple notification mechanisms.
It works fine with GitHub Repos, public and private.

15. Shippable

Shippable provides an easy way to set up continuous integration and delivery for applications. It optimizes DevOps operations and provides ready-to-use build images. It provides analytics to help you improve. It also offers machine-level isolation to secure the workflows.

Some of the key features of Shippable includes:

Enable Continuous Improvement with rich analytics and insights.
Secures your workflows with Role-Based Access Control (RBAC)

16. CodeShip

CodeShip is a hosted continuous integration and continuous delivery platform found by CloudBees. It provides fast feedback and customized environments to build applications. It provides integration with almost anything and is good at helping you scale as per your needs. It comes free for up to 100 monthly builds.

Besides, it provides feature like:

Parallel execution for fast feedback and minimum to no wait times.
Easy to configure.
It provides support for headless browsers.

17. Buildkite

Buildkite enables you to run continuous integration pipelines on your infrastructure. It provides fast and secure integration. It allows you to run multiple builds with maximum control. It has an interface that provides visibility of your pipelines, which you can monitor.

Some of its features include:

It provides unlimited language support.
It provides chat support for quick resolutions.
It offers easy integration with tools like Slack, HipChat, etc.

18. GoCD

GoCD comes as a continuous open-source integration and continuous delivery server with an end-to-end map showing the path to production in a single view. You can integrate it with popular environments like Kubernetes, Docker, and many more. It has advanced features of traceability wherein you can easily debug a broken pipeline.

Some of its features that make it a capable Jenkins alternative are:

It has a great support community.
Easy to upgrade even when plugins are integrated.
It provides fast feedback.

19. Semaphore CI

Semaphore provides you features for continuous integration and delivery by removing technical challenges. You need not depend on hiring staff specifically for deployments. You only need to define a workflow, and there you go with building a great application.

Some of the main features of Semaphore CI includes:

It provides flexible pipelines for complex projects.
It offers parallel testing for faster movement.
Debugging capabilities for quick resolutions.

20. Microtica

Microtica is a DevOps tool for automation with a complete software delivery process. It allows you to use reusable pieces of code to help you build infrastructure in no time. With Microtica’s pipeline workflow, you can get an overview of the build process at any given time. It’s not just all. It also allows you to automate sleep cycles, thus reducing AWS cost drastically.

Also, it provides features like:

It allows you to deploy microservices with Kubernetes in no-time.
Reduce AWS costs for non-production environments

21. AppVeyor

AppVeyor provides continuous integration and delivery services for any platform. You can quickly build, test, and deploy your applications in a fast manner. It supports GitHub, Bitbucket, Kiln, etc. Each build executes in an isolated and clean environment.

Some of its features include:

The console output makes it easy to debug the failure.
It provides faster builds with virtual machines and pseudo access.
It integrates with any source control tool.

Wrapping up

With so many options, you can easily pick an alternative to Jenkins. However, while going for any of the Jenkins alternatives, you need to check how well they can be integrated into your QA workflow to fulfill your needs. Do you know tools like Jenkins and most of its alternatives can be integrated well with cross browser testing (CBT) tools like LambdaTest to ensure optimal user experience across all browsers and browser versions? Well, now, you do!

We genuinely hope this guide has helped you find the best Jenkins alternative for your CI/CD needs. It took us a lot of time to narrow down the options so that you can save your research time, so if you did find this list valuable, we’d be grateful if you could share it on your LinkedIn or Twitter.

And if it didn’t help you, we would like to know how to make it better. So, please let us know your honest feedback in the comments below.

Here Are The Top Browsers For Cross Browser Testing In 2020

Abeer Mishra — Thu, 10 Dec 2020 09:58:40 +0000

We all know that user experience matters; it’s the key to delighting our customers. So, whether you are managing a live website or building a new one, you need to ensure a uniform user experience across all browsers and browser versions. Since web browsers don’t render the websites the same way, it becomes essential to perform cross browser testing and check website compatibility on different browsers.

By performing cross browser testing, you can ensure that the website behaves as intended across all the browsers. A website comprises the latest web technologies and languages such as HTML, CSS, Python, SQL, PHP, and JavaScript. All these web techs combine to give a complete look and function of the website. When these websites run on different web browsers, browsers execute the website code and display it to the users. But each browser interacts with websites uniquely and interprets the web components based on their arrangement to represent the website accordingly.

To ensure such uniformity across all the browsers can be tedious as you have to consider testing websites on different browsers and browser versions before making it live for the users. However, there is a better way of handling this while performing cross browser compatibility testing. The first step towards this should be to choose the most relevant browsers for testing. Now you must be wondering how to do that. Well, this blog will answer that. Let’s get to it, shall we?

How To Select Right Browsers For Compatibility Testing?

We all know that website is super important for every business these days. In fact, it is tough to find a successful business that doesn’t have a website. And we also know that first impression matters, and websites play an essential role in creating the first impression in your business. Therefore, it is crucial to perform browser compatibility testing to ensure that the website you designed for your brand works well in all types of browsers in different conditions.

The question arises, which are the most crucial web browsers you need to test your websites on. To answer this, you need to analyze the most critical browser and versions on the following basis:

Basis of Popularity: Select the most commonly used browsers on popular platforms like Windows, Android, and iOS. In this way, you can increase the test coverage.
Basis of Website Analysis: Analyze your website traffic through tools like Google Analytics and try to further breakdown based on browser, OS, and device. This will help you to understand which combination is most popular among your target audience.

Note: Any combination that has over 5% of traffic must be on your priority list.

Do you think you are testing your website on the right browsers? Well, to figure that, you need to take into consideration the geographical location of your visitors, devices they use, and the browser version they prefer. Now you must be wondering how to start or which browser you need to begin testing on. Well, you can start with the popular browsers. Given below are popular browsers in 2020 to articulate and modify your cross browser testing approach this year.

Let’s check the stats:

Familiarize Yourself With Browser Support Worldwide

Chrome – 64.77%
Safari – 17.61%
Firefox – 4.31%
Samsung Internet – 3.33%
Opera – 1.96%
UC Browser – 1.81%

As you can see from the image above, Google Chrome wins the market share among the browsers this year, with 64.77% of the user, making it the most popular browser just like the previous year. So, it is clear that you need to include Chrome in your testing strategy for sure. However, that does not mean that you can neglect other browsers like Safari that takes an overall 17.61% user base, making it the second most used browser.

Firefox is third with 4.31%, Samsung Internet fourth with 3.33%, Opera in fifth place with 1.96% users, and then UC Browser having 1.81% user base. Then comes the rest of the browsers like Microsoft Edge, Opera, Internet Explorer, etc. Though there are browsers that might not be popular globally, they can be critical to your business. For example, outdated browsers like IE and legacy edge need to be included in your browser list if your customers are using it.

It is significant to understand that technologies and business trends keep changing. One example of that change is Microsoft Edge moving to Chromium that will influence future web standards. Before Microsoft edge became Chromium, browser testers would skip the inbuilt testing browsers by Microsoft. After subsequent changes, it became smart to include the new Edge browser to keep up with the current web standards.

Considering browser versions is equally important while you are prioritizing the browser list. For example, considering Chrome as the most popular browser, you can include Chrome for Android and Chrome 80.0 in your priority list as they have the highest share among all versions of Chrome for Desktop and Android.

The above stats show the browser market share irrespective of the platforms being used. If you consider the platforms such as desktop, mobile, tablets, etc. the stats will change.

Browser Popularity On Different Devices Worldwide

We have discussed before how browser compatibility is different on different devices. Now, let’s see the most popular browser based on the device being used.

We can see that Mobile is leading as the most used platform worldwide with 51.24% of market share as compared to Desktop and Tablet, which are 46.02% and 2.74%, respectively. Therefore, it is imperative to consider the popular browsers on mobile devices for cross browser testing.

Mobile

Chrome – 62.6%
Safari – 23.83%
Samsung Internet – 6.5%
UC Browser – 3.37%
Opera – 1.65%
Firefox – 0.44%

62.6% of users prefer Chrome for mobile browsing, making it the number one mobile browser. Safari browser ranks second with 23.83%, therefore including this browser is a must for targeting the mobile device audiences.

Next, we have Samsung Internet with a 6.5% score, and then comes the UC Browser and Opera with 3.37% and 1.65% users, respectively. You can consider including all these browsers while testing your website on mobile browsers.

Desktop

Chrome – 69%
Safari – 8.84%
Firefox – 8.82%
Edge Legacy – 3.26%
IE – 3.06%
Others – 7.02%

When it comes to desktop browsers, the first three positions go to Chrome, Safari, and Firefox, with almost 69%, 8.84%, and 8.82% market share. Edge and Internet Explorer take the fourth and fifth positions. Hence, it will be beneficial to keep these browsers in your plan for browser testing.

Tablets

Safari – 49.33%
Chrome – 36.4%
Android – 11.96%
Firefox – 0.69%
Opera – 0.54%
Others – 1.09%

Safari is the most used browser on tablets, with a market share of 49.33%. Chrome tends to lead the market for overall browser use but stands second on Table with a 36.4% user base. Hence, it is clear from this example why it is crucial to consider every device while performing browser testing.

Imagine you did not test the Safari browser enough, thinking that the Chrome browser is the most popular. In that case, you are neglecting the user-experience of all the Tablet users of your websites. If any of the features are not working fine in Safari, it will not work for all of the Tablet users, creating negative impacts on your business.

Browser Popularity In The Continental Regions On All Platforms

Do you know that user behavior and preference for choosing a browser change when we compare different geographies? Well, now, you do! Which makes it crucial to understand your users, especially if you target specific geography for your business.

United States Of America

Chrome – 47.1%
Safari – 36.47%
Firefox – 4.14%
Edge Legacy – 2.79%
IE – 2.77%
Samsung Internet – 2.36%

Chrome and Safari are the two most essential browsers in the United States Of America, as we can see from the image above that 83.57% of users trust these two browsers. Taking a look at this chart can immensely help you to make the browser testing strategy here. We all should note that the user base here prefers legacy browsers like Edge and Internet Explorer too.

With Microsoft Edge becoming Chromium, it can bring an enormous change in this region’s stat. Compared to other continents, graphs are quite different here; therefore, select your browsers accordingly.

Note: Please keep in mind; these stats depict the overall popularity of the browser, including all the platforms in which users operate them, whether it is Mobile, Desktop, Tablet, etc. Therefore, you need to give priority to these browsers based on the running platforms as well.

Europe

Chrome – 61.31%
Safari – 18.33%
Firefox – 7.14%
Samsung Internet – 3.87%
Opera – 2.28%
Edge Legacy – 2.23%

Chrome is the most popular browser here; with a 61.31% share, it holds first place. Firefox is the second popular browser in Europe, although the difference here is that stats are relatively high compared to other regions with 18.33%.

There is not much change in the European market for the browser except that the Samsung Internet and Opera are now a little forward in share and other browsers like Yandex at the very end. Internet Explorer is quite behind in Europe, but as we know, the market keeps changing every day, and we can expect some changes here as well after Microsoft Edge became Chromium.

Asia

Chrome – 71.09%
Safari – 11.06%
UC Browser – 4.04%
Samsung Internet – 3.7%
Firefox – 2.88%
Opera – 1.82%

If you checked the stats last year, you could notice an immense difference between the UC Browser and Safari this year, which was much less last year, and UC Browser was popular than Safari. Therefore, you can strategize your testing process by giving Safari much more attention. Coming up next in popularity, we have Samsung Internet and Firefox with a small difference in numbers. Microsoft Edge and Internet Explorer are catching up here as well. Hence we have to watch out for these in Asia as well.

Africa

Chrome – 70.14%
Safari – 8.77%
Opera – 7.79%
Firefox – 4.41%
Samsung Internet – 4.12%
UC Browser – 1.25%

If we skip the all-time popular browser Chrome, we will see that Safari dominates the charts this year, leaving the Opera browser behind. Samsung Internet is now in fifth place, which was much behind last year. Surprisingly, Microsoft Edge and Internet Explorer are in the race after the UC Browser, which can be a great example of how going Chromium is beneficial for them. Although we still have to look forward to how new Edge is going to change the market trend in the coming days. For now, you can focus on these browsers for your target audience in Africa.

Oceania

Chrome – 52.84%
Safari – 32.22%
Firefox – 3.82%
Samsung Internet – 3.34%
Edge Legacy – 2.45%
Edge – 1.57%

Catching up with North America’s graphs, the Oceania region also has a large user base, to be precise, 32.22% that uses Safari. Therefore, give priority to this browser for your targeted audience of this geographical area. You can keep Firefox and Samsung Internet as the third preference. Catching up with the competition, Edge Legacy and Edge come next with almost 2.45% and 1.57%, respectively.

From the above statistics of different continents, we can conclude that the user’s preferences vary. Some regions prefer Safari way too much, whereas some have quite similar stats for Safari and Firefox.

In certain areas, Internet Explorer and Edge come next, while Samsung Internet and Opera have a higher user base in other places. Therefore, you need to change and plan your browser testing strategy accordingly.

Wrapping Up

By now, you must be clear that Chrome is the most popular browser in all regions. That doesn’t mean you can overlook other popular browsers like Firefox and Safari. The second or the third most crucial browser based on different devices and geography are equally essential for targeting global audiences. Therefore, it becomes imperative to track the sources of your website traffic. When you have that data, you need to ensure that your website works seamlessly on those browsers and browser versions, including the older ones.

Installing so many browsers on different devices and testing them on those platforms can be very hectic. Therefore, proper planning is a must before browser testing. It would be best to strategize your cross browser testing by breaking down the browsers concerning device and geography. After knowing which browser is more prevalent in a specific device or country, you can test websites on different browsers based on your target audiences. However, to further ease down the cross browser testing effort, you can rely on tools like LambdaTest that provides feature like Geo Location Testing for better coverage along with automation testing, local testing, parallel testing, etc.

Top 10 Java Testing Frameworks For 2020

Abeer Mishra — Thu, 24 Sep 2020 09:26:02 +0000

When we talk about programming in the modern tech world, Java instantly comes to our mind. After all, it is considered as one of the most versatile programming languages. Looking back on its history, Java has always had an extraordinary position in a back-end developer’s heart. A majority of developers enjoy Java due to its platform independency, security, ease of use, variety of accessible resources, and several other essential features. These traits appreciably contributed to the popularity of Java as a programming language – as of 2018, there were seven million or more Java developers globally.

Undoubtedly, Java has positioned itself as one of the admired programming languages for web development projects. Looking back at the results of 2019, Java was positioned in the list of Top 5 Most Popular Technology which, in turn, encouraged the usage of Java testing frameworks.

Let’s look at some statistics:

According to the TIOBE Popularity index, in 2020 Java was the second most famous programming language across the world. It was also the ‘language of the year’ for 2005, 2015 and got the top position in popularity (since 2001.)
In 2019, Java was the most popular programming language globally. It comes with a great system with nine million or more Java developers.

Every year, StackOverflow, (one of the largest online communities for software developers) releases its Developer Survey for tech enthusiasts across the globe. For the 8th year in a row, JavaScript positioned itself as the most commonly and popularly used programming language.

Best Java Testing Frameworks To Use In 2020

Java unit testing frameworks provide programmers with a standardized, sophisticated, and extensible means to build a web application or any other software. It comprises a massive collection of packages that supply pre-written code. Depending on your choice of testing frameworks for Java, they incorporate libraries, compilers, tools, and APIs.

Moreover, extensive Java unit testing frameworks always deliver a secured application. So in case of a security gap, one can resolve it within the framework’s website/support with zero trouble. They even offer built-in functions and modules to enable efficiency and speed for the developers and testers.

What to expect from Java testing frameworks this decade?

Well, here are the best Java testing frameworks that are likely to make a great difference in 2020.

1. JBehave

JBehaveis an incredible and one of the best Java testing frameworks that supports BDD (Behaviour-Driven Development). BDD is an evolution of TDD (Test-Driven Development) and ATDD (Acceptance Test-Driven Development).

Behaviour-Driven Development is intended to make these practices insightful and more accessible for both beginners and specialists. It shifts the terms to behaviour-based from being test-based, and sets itself as a design paradigm, highlighting communication, and automation alike.

Features

JBehave distributions

Core distributions of Jbehave are:

JBehave Web
JBehave Core

Prerequisites For Installing JBehave

One of the proper ways to make use of this testing framework for Java is to incorporate it with Eclipse. Indeed, for this, despite JDK1.7 & above as well as any Eclipse IDE (integrated development environment) above indigo, one would require various jar files such as:

Commons-lang-2.4.jar
Junit-4.1.0.jar
Jbehave-core-3.8.jar
Freemarker-2.3.9.jar
Plexus-utils-1.1.jar
Paranamer-2.5.jar
Org.apache.commons.collections.jar
Org.apacje.commons.io.jar

Pros

JBehave BDD testing framework is also beneficial in multiple ways.

Products have superior specifications because of the fact that this testing framework for Java features reasoning, and intuitiveness in a detailed way.
Serves a great purpose for BDD by offering integration among distinct development teams engaged with varied projects yet similar specifics.
JBehave framework uses a semi-formal language which is a great help for developers. Having a domain vocabulary feature aids in managing consistency in the team structure.
Even, stakeholders, as well as project managers, get better transparency regarding the QA teams & dev team productivity as the specs have the same format.

Cons

There is only one loophole or con of JBehave just like any other BDD testing framework.

BDD testing framework or tool success rate mostly comes down to significant communication carried out among members working in a project. It can be between the management team, the testers, the developers, and the stakeholders.

Improper communication may lead to unanswered doubts and queries. In the end this can lead to a flaw-filled app or an app not meeting up to client requirements, resulting in a blame game between all the involved parties.

Is JBehave One Of The Best Java Testing Frameworks For You?

JBehave- the testing framework for Java works similar to frameworks like Serenity. But, if you plan to create the automated acceptance tests effectively, it is better to incorporate JBehave along with Serenity for utilizing an ideal test experience. The entire concept of Serenity is based on BDD development and it also lets the users write a rich and powerful testing report.

2. JUnit

JUnit is an open-source regression testing framework that is used mainly by expert software developers to execute unit testing, speed up programming, and improve the quality of code in Java. The key purpose of introducing this framework is to allow Java developers to script and implement repeated test cases. This is amongst the most commonly used Java unit test frameworks.

JUnit framework is majorly used by experts to test small bunches of code. You can also carry out automated tests of a site by combining Selenium WebDriver with JUnit for Java automated testing. When any fresh code is added, you will be asked to reboot the complete test cases and ensure about zero breakage.

Features

Test suites
Fixtures
JUnit classes
Test runners

Prerequisites For Installing JUnit

Based originally on SUnit & written in Smalltalk, this Java unit testing framework is extremely attuned with Selenium WebDriver. The key reason being, it is derived from Java. Some prerequisites, you will need to follow these-

Should have the JDK newest version installed in your system.
(Optional) Unzip the $JUNIT_HOME/src. jar file.
Have great know-how and expertise of app growth in an object-oriented language, particularly Java programming.
Download the new JUnit version & set up the environment.

Pros

There are various benefits of using JUnit among the available Java testing frameworks.

It can be used for both integration and unit tests as it supports Java 8 features. Bugs can be easily detected in the early phase, ensuing in an unfailing and reliable code.
Developers or programmers, who work in a test-driven environment, find it extremely useful. They find it easier to read the code and scrutinize any glitches present.
The development of an anomaly free code as well as a more readable code acts as a confidence augmenter.
Almost all major IDEs, like Eclipse, NetBeans, Maven, Ant, and IntelliJIDEA, provide JUnit framework integrations. So, you can easily write and start unit testing straight from those IDEs.
By using the upgraded JUnit version (version 5), one can identify exemption very easily. Plus, they can implement test cases written in the older JUnit version.
One can also use this unit test framework for Java with Java 5 or other versions.

Cons

JUnit framework is not capable of implementing dependency tests. Thus, in this state, we necessitate TestNG.

Is JUnit One Of The Best Java Testing Frameworks For You?

JUnit is a commonly used open-source framework based on Java. Both TestNG as well as JUnit do a similar job and their key traits are somehow the same, excluding the dependency test capabilities. The execution procedure of parameterized testing is also distinct in both frameworks.

Due to the fact that JUnit has been used for an extended period, there is great support from the community. It has been also defined as the standard Java Unit Testing Frameworks by integrating Selenium WebDriver for Java-based applications. Although TestNG has few users and the community is ever-growing. Thus, we are wrapping up with the suggestion that the choice between JUnit or TestNG for a Java test framework entirely depends upon the nature and necessities of specific applications.

3. Serenity

Formerly recognized as Thucydides, Serenity is one of the most extensively-used open-source Java testing frameworks. Serenity BDD framework assists you to write acceptance criteria, which are cleaner, structured, and manageable. It enhances the functionality of both Selenium WebDriver and JUnit.

With this specialized framework, you can create descriptive testing reports. Besides, you can map automated testing back to your needs. In general, this automation framework for Java makes Java development services more reliable and effective.

Features

Open Source project
Complete reports on test results & implementation
Business-readable formatted report for every test

Prerequisites For Installing Serenity

As the automated framework is entirely Java-based, you will certainly need know-how in Java or any other object-oriented programming language. Besides this, your system will necessitate-

JDK 5 or higher version above.
Maven 3.0 or any updated high version.
An IDE tool – Eclipse as well as Maven is generally preferred by all programmers or developers as they are painless to work with.

Pros

Let’s glance over the benefits of using Serenity.

This automation framework for Java helps the tester to craft test cases for REST services.
It maintains a balance, rather a margin between the description and understanding of a test case and its implementation approach.
Users don’t need to pay out extra time to maintain or build their own automated framework.
Serenity can be integrated with plenty of frameworks such as advanced development frameworks for Java like Spring, other frameworks like Selenium, JBehave, and with project management tools like JIRA.

Cons

The con of Serenity is similar to the JBehave framework for Java. Regular communication between the project participants is necessary in order to make the best of the support provided for BDD.

Is Serenity One Of The Best Java Testing Frameworks For You?

This Java testing framework is mainly utilized for writing and reporting acceptance criteria. The reports written using Serenity are very effective, useful, advantageous, rich, and very informative than other BDD frameworks like JBehave. It assists programmers to write superior quality automation test case scenarios. Serenity also supports Selenium WebDriver and Rest Assured, making it faster and easier for the QA engineers to write automated acceptance test criteria.

4. TestNG

TestNG is amongst the most popular and powerful Java testing frameworks used for Integration, Functional, and Unit testing. It was created by Cedric Beust in 2004 and has now been updated to version 7. It is a tough competitor of frameworks like the JUnit framework. TestNG is similar to JUnit, yet it is configured with extraordinary annotations and superior functionalities (not supported by Junit).

The NG in TestNG denotes the ‘next generation.’ TestNG can cover almost every type of software testing, counting end-to-end, unit, integration, and functional testing. Both TestNG and JUnit are Java-based frameworks that allow you to write tests and scrutinize end results. If testing gets succeeded, you will see a green bar, otherwise, a red bar.

Features

Supports dependent methods testing
Test configuration flexible
Supports sturdy execution model
Set in BeanShell for additional flexibility

Prerequisites For Installing TestNG

The Java-based framework helps developers with core features like grouping, sequencing, and parameterizing. This makes the newest test cases adaptable and eradicates the loopholes of frameworks used previously. For installing TestNG, you will need:

JDK latest version installed in your system.
Latest version of Eclipse.
Understanding and practical experience of Java programming language or some other object-oriented programming language.

Pros

Despite overcoming the anomaly of the oldest frameworks, there are quite a few benefits of TestNG.

Allows creating, and running parallel testing on multiple code snippets.
While implementing the test case, you can create an HTML report.
Test cases can be easily organized and grouped in accordance with priorities. Performing the tests is far easier, simply by putting the framework to run front-end testing or database testing.
Priorities can be easily set by data parameterizing and by utilizing annotations.

Cons

TestNG might not be the right fit for you if your project doesn’t need prioritization in the test case. Besides, setting up TestNG requires more time.

Is TestNG One Of The Best Java Testing Frameworks For You?

As we already know, JUnit test framework performs all the same functions as TestNG but it has some drawbacks. JUnit is amazing when the test is performed in isolation; however, when there is some kind of dependency, you won’t get any control over which testing is done earlier. TestNG frameworks for Java aid you by letting you execute test cases the way you want to.

Furthermore, you get added support for Parameterization In TestNG. Even though this particular trait is already found in JUnit 4.5, the TestNG framework is more helpful. If any project is complex and you may necessitate 100 or more test cases, it is better to get some extra time and set up a TestNG framework rather than depending completely on other frameworks like JUnit.

5. Selenide

Selenideis a popular and open-source Java testing framework which is powered by Selenium WebDriver. It is a great tool for writing precise, communicative, and stable UI test cases for a Java app. It expands the WebDriver and JUnit functionalities.

WebDriver is one of the well-admired tools for User Interface testing, yet it is devoid of the trait to deal with a timeout. For instance, testing of web technologies such as Ajax. Selenide framework manages all these issues in an easy manner. Besides, it is simpler to install and learn. You simply need to concentrate on the logic and Selenide will do the rest.

Features

Out of the box and all set to use the framework.
Write less automation code.
Saves a ton of time.
Configuration ideal for CI Tool such as Jenkins.

Prerequisites For Installing Selenide

As this open-source framework is Java-based, you will need experience in Java or other object-oriented programming languages. In your workstation, you will also need-

JDK 5 or updated version
Maven 3.0 or other versions installed
An Integrated Development Environment (IDE) tool – Most commonly, Eclipse is preferred by all developers as the combo of Eclipse & Maven is simpler to work with.

Pros

Selenide continues to make a great impact by offering various benefits for test automation teams:

First and foremost of all, it makes your tests precise and stable by solving (nearly) all Ajax/timing problems.
Brief writing process of test cases that decreases the timeout issues.
Supports app tests developed using AngularJS.
Shortens so many commands which were formerly used by other traditional tools of Selenium.

Cons

Till now, nobody has found any notable drawback of using Selenide.

Is Selenide One Of The Best Java Testing Frameworks For You?

If you wish to go for User Interface tests, you will probably look into Selenium WebDriver first. However, Selenium WebDriver can’t solve issues concerning JavaScript’s slow running or Ajax timeout or any dynamic content which consumes extra time in loading. To conquer these problems, we formerly used “sleep” or “wait_until” techniques in the test cases. With specific Java testing frameworks like Selenide, we don’t have to think about those issues any longer.

6. Gauge

Selenium creators Thoughtworks launched another Java testing framework for carrying automated tests of web apps. Gaugeis an open-source and free test automation framework for Java that takes the stress out of acceptance testing with less code involvement. It is one of the frequently used Java testing frameworks in the mobile website testing category of a tech stack.

Automated tests using this framework for Java can create readable tests with languages of your preference. Similar to Selenium, this test automation framework also offers support for several languages like Ruby, JavaScript, Java, C #, and Python.

Features

Simple to use, flexible syntax
Uses a business-like language
Supports maximum languages and platforms
Uncountable plugins

Prerequisites For Installing Gauge

Download and install Maven.
Operating system versions- Microsoft Windows 10 or higher.
Memory should be 512 MB of RAM (minimum.)
Gauge plugin must be configured with your Integrated Development Environment (IDE) or Gauge framework should be installed if in case you are running the test from CMD/Terminal.

Pros

Gauge continues to make a significant impact by offering numerous rewards for agile teams throughout the DevOps procedure, including immediate feedback and ease of use. Let’s take a look at other advantages:

Gives a business layer on top of the scripts to make them readable & understandable.
Simple-to-use, flexible syntax, and support for all types of languages (Java, Javascript, C#, Ruby, Python, etc.) and platforms.
Lets you create tests in the Integrated Development Environment (IDE) of your choice (IntelliJ, Vi VS Code, Visual Studio, Maven, Gradle, Eclipse,etc.)
Run parallel testing and create tailored reports intelligently.
Effortlessly test with big sets of data, while keeping specifics highly precise and readable.

Cons

Gauge is completely new, and therefore, users don’t prefer this framework. While the open-source community continues to improve upon it on a daily basis.
Gauge doesn’t support the safe parallel implementation of specs inside IntelliJ, because of the fact that the driver is static and has to be shared amid the scripts.

Is Gauge One Of The Best Java Testing Frameworks For You?

Gauge Java testing framework works great specifically for carrying out cross browser testing. This framework has incredibly revolutionized test automation procedures, allowing even non-technical users to write a test automation framework with ease. It solves real anomalies with test maintenance – thanks to its growing community and contribution of early adopters.

7. Geb

Based on Groovy, Geb is a testing framework for browsers built as a cherry on the Selenium WebDriver shaped cake. This makes it perfect for automated testing and you can easily perform cross browser testing on all browsers that are supported by WebDriver. Geb test automation framework for Java provides extraordinary traits for screen scraping, web testing, and many more.

What makes it exceptional is the manner it queries the HTML pages, by giving the jQuery-like syntax. Geb framework also offers built-in support for the Page Object Model. Geb can be used for general scraping, scripting, as well as automation. It is equally well suited as an acceptance, web or functional testing solution through integration with test frameworks like TestNG, JUnit, and Spock.

Features

Elegance of jQuery choice
Licence under the Apache License, Version 2.0.
Power of WebDriver
Page Object Modelling robustness
Articulacy of Groovy

Prerequisites For Installing Geb

You have to download and install Maven
Ensure you have Java installed in the system. It is better to install Java 8 or high versions for steady implementation.
LambdaTest authentication and validation credentials. You can sign up right here.
Replication of LambdaTest GitHub repository for Geb test automation framework.

Pros

Let’s look at the advantages of Geb testing framework for Java:

Page Objects form and Groovy DSL of Geb make tests easily readable as they more or less look like plain English.
Runs the tests with high-speed and saves your cost of testing. Compatible with various browsers like Internet Explorer, HTMLUnit, Firefox, and Chrome.
Runs the tests in real-time and in real environment- the one that the user would observe. It supports maximum test coverage within the single script.
It keeps regression testing trouble-free. You can run Geb test cases to check if any active functionality is breaking following a modification or mend in the application.

Cons

Limitation of the Geb is that it executes WebDriver in the Groovy language. Hence, when using Webdriver, only this specific language will be supported. However, if you try to use WebDriver directly, it supports several other languages like Java, Ruby, C#, and Python.
Geb won’t work great for small projects; it works well for huge tasks. If your web app doesn’t comprise various pages and forms through which the data requires to flow, you might find this framework truly expensive.

Is Geb One Of The Best Java Testing Frameworks For You?

Geb Java testing framework provides smart integration modules for frameworks like Cucumber, TestNG, JUnit, and Spock. However, Spock is a great match with Geb. Using Geb with Spock can give concise, clear, and understandable test specifications with less effort.

8. Spock

Spockis a popular test automation framework for Java. It is written in Groovy and allows testing experts to perform Data-Driven Tests on Java Virtual Machine. Spock provides incredible compatibility to many languages that are supported by JVM. The Spock UI is truly helpful and amazing in comparison to various other Java automation test frameworks.

One of the best features of Spock is that the code documentation and code readability is orderly and neat, plus it can interpret common English sentences. It is frequently used by software developers to build enterprise apps in Java. Thus, making it the most popular and convenient testing frameworks for Java in 2020.

Features

Originally created in 2008 by Peter Niederwieser
Superset of the de facto test framework for Java: JUnit
Spock has its own Mocking
Tests can be written for any language

Prerequisites for Installing Spock

The latest version of JDK
The updated version of Eclipse
Knowledge of Java programming language

Pros

Spock is the most popular test automation framework that provides the following crucial advantages:

Amazing readability, providing compatibility towards plain English sentences compared to other Java automation test frameworks.
Stubbing and Mocking are very easy and painless than ever with Spock. Besides, both Stubbing and Mocking are in-built.
Crispier and shorter parameterization.
Provides surrounding context, hence making it simpler to notice the failure cause.
Simplistic and communicative Domain-Specific Language (DSL).

Cons

It is written in Groovy so you should have a fundamental knowledge of Groovy.
You may find Spock framework to be a bit inconvenient but once you are familiar with it then you won’t start thinking about moving to other Java test frameworks.

Is Spock One Of The Best Java Testing Frameworks For You?

Yes, many consider it to be the best Java testing framework and place it in the top position. Spock is the best test framework for Behaviour-Driven Development because of its powerful DSL, simplistic usage, and intuitive user interface. Particularly if you have some of the applications based on JVM. Spock is inspired by RSpec, jMock, JUnit, Mockito, Vulcans, Groovy, Scala, and other captivating life forms.

9. HttpUnit

HttpUnit is a much-used and open-source software testing framework for performing website testing without any web browser requirement. HttpUnit is extremely suited for the execution of automatic test scripts for web apps. As the name HttpUnit suggests, it can be smartly used for unit tests.

However, general web layer elements such as servlets, JSP (JavaServer Pages) pages, as well as various other template elements don’t lend themselves to unit tests. Written in Java programming language, it permits test code to process returned pages as XML DOM, text, or containers of tables, links, and forms.

Features

Support for cookies
Support for the HTTPS and HTTP protocols
Support for HTML responses
Proxy server support
Superb JavaScript support

Prerequisites For Installing HttpUnit

System needs to support Java JDK 1.4 or the latest.
Add Tidy.jar and httpunit.ja both integrated with HttpUnit, to your classpath. Also, make sure that an XML parser is previously installed.
If running an older Java version, you must incorporate a JAXP-compliant XML parser in your classpath.
Most recent release of HttpUnit is obtainable from this page.

Pros

HttpUnit testing framework is beneficial in myriad ways:

The use of this testing framework for Java allows test automation of web apps and as a result, also aids in regression testing.
One advantage of HTTPUnit is that it is much faster than other test automation frameworks like Selenium.
Great JavaScript support, allows simulating the activities of the configured browser (IE or Firefox).
HTTPUnit uses the Rhino JavaScript engine for the core language & provides the execution for the objects precise to implementation in a browser.
The unit tests of popular JavaScript libraries are integrated in HtmlUnit’s own unit tests, simultaneously based on these unit tests, the libraries like jQuery 1.11.3, MochiKit 1.4.1, MooTools 1.2.1, etc. are acknowledged to function greatly with HtmlUnit.
Capability to inject code into the current page by HtmlPage.executeJavascript(String yourJsCode).

Cons

It’s a good place to start for easy tests, though it will require more and more coding to create complex tests.
A framework like Selenium is more specific and will allow anyone to use browser-centric behavior and not restrict the apps under test. However, with this specific framework, you will get limited support except for some major browsers.

Is HttpUnit One Of The Best Java Testing Frameworks For You?

HttpUnit is extremely easy to use and requires simple steps to get up and running. It’s great to utilize it to start simple tests, but it will require a high level of coding for creating complex tests. As compared to HTTPUnit, the framework for test automation like Selenium is more than just a library; it equips any person better for extra advanced automated testing.

As for several Model-View Controller framework-based elements, these are suitable to test with other types of frameworks. For instance, WebWork 2 actions can be unit tested lacking a Web container and Struts actions can be unit tested with StrutsUnit.

10. JWebUnit

JWebUnit is a Java-based test framework and is one of the JUnit extensions preferred for Integration, Regression, and Functional testing. It wraps current active frameworks like HTMLUnit and Selenium with a simple test interface. Thus you can instantly test the accuracy of your web apps.

JWebUnit can be used to execute screen navigation tests. The framework also offers an advanced-level Java application programming interface to navigate a web app with a set of assertions to scrutinize the application’s accuracy. This counts navigation through links, form entrance and submission, justification of table contents, and other usual business web app traits.

Features

Top-level Java API to navigate a web application
Open source java based framework

Prerequisites for Installing JWebUnit

You need to install Maven.
The current stable version of JWebUnit is 3.3. It requires Java 1.7.
Simply add the plugin you want as a dependency: two available plugins are, HtmlUnit for faster tests & great Javascript support and Webdriver: BETA quality.
To manage dependencies in Eclipse when using Maven 2 make use of the m2e plugin.

Pros

JWebUnit testing framework for Integration, Regression, and Functional testing is also beneficial in myriad ways.

Used to carry out screen navigation testing.
Provides a superior-level API in order to navigate the web applications.
The simple navigation with readily available assertions allows quicker test creation than using JUnit or HtmlUnit.
If anyone wishes to switch from HtmlUnit to other kinds of plugins like Selenium, there is no requirement to rewrite the tests.

Cons

Both TestNG as well as JWebUnit, does a similar job and features are quite similar, excluding the dependency tests capabilities.

Is JWebUnit One Of The Best Java Testing Frameworks For You?

Htmlunit is an ideal option for JavaScript support. However, JWebUnit offers app programming interfaces and it is easy to write crisp code using JWebUnit which is often impossible by HttpUnit. JWebUnit has an intuitive API, making it accessible and simple to use even if a person has merely a rough idea of the exact HTML facts of the app screens.

JWebUnit works fine but sometimes adding a little BDD-flavouring to the mix can turn things for better. Behaviour-driven design or Behaviour-driven development is an incredible way to model user interaction with your app using JWebUnit.

Wrapping Up

It is almost a necessity for developers to be experts in software testing skills and have an excellent understanding of testing. This is what separates expert Java developers from novice developers. To get closer to perfection, the 10 best Java testing frameworks mentioned above are highly recommended for developers across the world. They will make it supremely easy for you to test an application.

Apart from choosing the best Java testing frameworks, you must also choose the right Selenium test automation platform to suit your project requirement. There are countless frameworks for Java and LambdaTest supports almost all of them. Also, you get to test your website on 2000+ browsers, operating systems, and devices. Use this article as a guide to assess your requirements and pick the framework cleverly to grab the benefits of features provided by Java.

Happy Testing!!

10 Biggest Remote Testing Challenges (& How To Overcome Them)

Abeer Mishra — Wed, 09 Sep 2020 08:19:05 +0000

In 2019, when Gartner predicted that working remotely will be on high demand, most businesses didn’t agree with the likelihood. But, guess who is working remotely now?

After the COVID-19 pandemic hit the world, almost every organization was forced to allow its employees to work from home which made us realize the challenges of working remotely. Although most industries coped up with the remote working process, it was a bit intimidating for software companies. Software testing teams were impacted the most due to the location and synchrony constraints. The dependence on physical devices, infrastructure, and the internet makes it even more complicated for remote testing teams to execute tasks and overcome the key challenges of software testing.

No doubt, remote testing offers the flexibility and freedom to work from home, but QA teams and the IT companies cannot overlook some key challenges of software testing. This blog will explore all the major challenges associated with remote testing and offer guidance about overcoming the challenges of working remotely. Let’s start!

Key Challenges Of Remote Testing

In the US alone, there was a significant rise of 159% in remote work between 2005 and 2017 (Source: FlexJobs). We can imagine how drastically these numbers have gone up over the last few months. And so have the challenges of working remotely. Software testers particularly bore the brunt of the suddenness in remote work. Remote testing teams have been scrabbling hard to get back on track and we could not help but notice the key challenges of software testing. After interacting with various testers, who are working remotely, we got to know about the biggest remote testing challenges faced by them. Here they are-

1. Lack of Communication

“You can never over-communicate enough as a leader, but at a remote company, nothing could be truer. Since you don’t physically see people in-person, information doesn’t spread in the same way. So leaders need to do the heavy lifting for evangelizing the message.”

— Claire Lew

Lack of communication has turned out to be one of the significant challenges for software teams while working remotely. As per Forbes, it has been observed that working remotely makes it more complicated for employers to communicate, especially when it comes to having discussions that involve critical interpretations. Although individuals use effective communication tools like Slack, Teams, or Google Meetup, sometimes it becomes awkward to clarify the tone and urgency of some messages.

For instance, if your colleagues are working from a different country and they use phrases to describe a problem, chances are you might not get it. That’s why it is crucial to have an effective communication environment, where employees feel comfortable and communicate concisely.

In our opinion, it is recommended to use video calls while communicating with co-workers to understand things like testing requirements, test scenarios, or tools more precisely.

2. Teaming Up

While working in the office, there are superiors or team leaders to see what their employees are working on. But, in a distributed testing team, there is no one to look after, and that’s where QAs find it challenging to make changes in application code. Also, your team members cannot see all the changes that you make in a test script, which makes it difficult to understand whether you’re succeeding at your job or not.

This is one of the key challenges of software testing and that’s where it becomes critical to be in sync with your colleagues. You’ll have to provide continuous updates to your teammates, inform them about the issues that you’re facing, and much more.

Moreover, you can also inform your team members about the features you have tested, how you have tested them, and what changes you noticed after testing a feature. It will make it easier for your co-workers to understand what you’re working on and what you have achieved so far.

3. Technical Failures

Remote testing teams use a lot of technological components, such as a system with multiple applications running on it, third-party screen sharing tools, recording tools, and IM clients. But, no matter how reliable configurations your system has, things can always go wrong. For example, you never know when you run into problems with the internet connection, muddy international phone calls, software not running properly on your computer, etc.

Any of these can delay your work by a considerable time, and you might not be able to get excuses to get over these issues. Thus, it is recommended to test everything a day before you start the testing process. A few things that you could check instantly involve:

Screen sharing – Make sure it is not interrupted throughout the testing process due to internet connection.
Recordings not working – The last thing you would want after recording a testing scenario is that there is no sound in it, so make sure the recordings are working fine.
Video recording – Test the configuration of the recording tool and make sure it doesn’t stop or fluctuate while running multiple applications in the background.
Internet connection – Most of the testing scenarios would be executed over the browser, so check the internet connectivity.

Sometimes, a normal technical problem can abruptly end everything in the process, even if you have tested it over a thousand times. Well, we cannot stop technical issues from occurring, but we can prepare ourselves by planning and setting everyone’s expectations ahead of time. The only trick is to stay prepared for all the challenges of working remotely.

4. Cross-cultural Differences

In most companies, remote testing teams work from different areas and countries. For instance, in my company, two testing members work from the USA, while others work from India. Now, the working culture might be similar here and there, but from where we belong does affect our behavior and understanding.

Also, it’s not necessary that all your remote testing team members work in the same way as you do. There can be variations in the ways they execute a task or communicate with others. Thus, before moving on to working with a remote testing team, it is crucial to understand their working behavior and nuances.

Understanding these distinctions is one of the key challenges of software testing. It will help you know the people in a better way, and your remote testing team will be able to function more efficiently.

5. Productive Collaboration

When you work with a team that is distributed geographically, it becomes hard to collaborate with them continuously. Most testers need to stay in front of their laptop at varied time zones to catch up with their team members, and they end up losing a lot of time.

One thing is for sure that you cannot have last-minute meetings while working remotely, especially in varied time zones. Thus, it is better to plan ahead by keeping all the time zones in mind so that every team member can join the meeting as per their convenience.

Besides, you can also opt for a collaboration tool that makes it easier for team members to collaborate closely. For instance, the Screenhero feature of Slack allows two users to see the same screen at the same time. Using such tools is one of the easiest ways to overcome the key challenges of software testing.

6. Synchronizing Releases

Software testers are responsible for the final release of an application, as they ensure that the application is ready to launch after testing all the components. Also, they need to give continuous updates about the release to the stakeholders as well as other team members involved in the project. But, with remote testing, it becomes a little complicated to give continuous updates about the product release.

Thus, to avoid any bottlenecks in the release cycle, testers should test early, test often, and share the status with others as soon as possible. This way, you can prepare yourself for future releases in advance. Moreover, you can go with the QAOps principle of integrating and testing in parallel for the continuous delivery of products.

Using agile methodologies, you will be able to execute tests early by setting smaller targets. It will also help you analyze the ability and speed of testers at which they accomplish their tasks.

7. Improper Documentation

Even after working remotely for a while, many remote testing teams still believe in communicating verbally rather than keeping documentation about how the product was developed. This, in turn, can delay the release of the product.

In order to release your product at the given timeline, it is recommended to use a checklist and follow along. You can create a checklist of all the tasks that need to be carried out by each member while keeping every team member in the loop with full visibility and transparency. So, when there is an issue with any task, you can update the checklist and inform everyone about it.

Also, if you’re reporting a bug or issue, then specify it clearly, like where it happened and how it happened, to your team. You can also take screenshots to explain the problem in detail. Cross browser testing tools like LambdaTest allow you to take screenshots while you test web pages and applications. A special feature called Automated Screenshot Testing lets you do that for over 2000 browsers and operating systems.

8. Multitasking

While moderating a remote testing session, testers have to keep their eyes on multiple things like communicating with the user, onscreen behavior, observing questions and queries via IM, total time remaining in the session, the status of executing the task, and much more. Keeping up with all these activities at a single time can be very confusing for any individual.

Therefore, it is good to have a task management tool in hand that allows you to schedule your tasks and execute them accordingly. By doing so, you will be not only able to moderate remote sessions, but also perform other functions that are crucial for the testing. We further recommend focusing on one task at a time to overcome the most common challenges of working remotely.

9. Lack Of Positive Feedback

Let us consider a scenario- When you spend a lot of time performing a test and later found out that it wasn’t supposed to happen this way. Or you’re working from a remote location with a distributed team, and there is no one to give suggestions on your ideas. Has it ever happened to you?

If yes, then you might understand the importance of feedback. However, not every feedback is provided positively. Let’s say you have developed documentation for testing a specific feature, and your team leader says it looks good.

Later, you realize that the documentation was never published and neither put to any use, which makes you wonder what went wrong. So, you can see that the ‘good’ feedback was actually a no-feedback.

To get positive feedback on your ideas, you can create a community where everyone can speak of what’s in their mind and how they can implement it effectively. If you think this is not one of the key challenges of software testing, remember what Zig Ziglar said- “People often say motivation doesn’t last. Neither does bathing—that’s why we recommend it daily.”

10. Security & Privacy

Security and privacy are two major concerns of every remote testing team, as the product is in the testing stage and yet to be released to the market. While working remotely, testers need to communicate with their colleagues and stakeholders on a daily basis to give status updates. Also, it is crucial to keep everything confidential before the product release. But, there are always risks involved in losing the internal information to outsiders.

To avoid loopholes while sharing information with team members, it is recommended to use a cloud-based platform that offers password-protected sharing so that no outside user can access the information that you share with your co-workers.

Remote working has become a daily activity for most businesses, especially after the outbreak of the COVID-19 pandemic. This has made it hard for remote testers to execute testing tasks, as they face many challenges of working remotely. However, most of these challenges can be resolved by using a cloud-based automated testing platform like LambdaTest or by following the tips below.

Tips To Overcome Remote Testing Challenges

In the above section, we saw how tough it can be to manage remote testing while overcoming the key challenges of software testing. Depending on your team, product, and project requirements, the challenges of working remotely can vary greatly. The best way to ease your remote testing processes is to use automation. It allows you to ease up the pressure on the testing team while making it easier for them to find bugs. Automation can be used in multiple ways including Selenium test automation and much more-

Regression Testing

If you choose the manual approaches, then you already know how much time it would take to execute regression testing. However, if you use automation, it can be done in the minimum time possible while improving the testing team’s productivity and providing quick feedback on the changes.

Another advantage of using automation for regression testing is that the QA team can continue working on other tasks while keeping the test automation running in the background. With an automated regression testing strategy, the QA team doesn’t need to be available at ad-hoc times for testing the changes made by developers.

Upgrade to Agile Methodologies

Using agile methodologies is one of the best ways to test remotely; it enables you to test your website at every stage of development with minimum human intervention. Also, having a CI/CD pipeline in the process ensures that the code changes are tested immediately whenever they are integrated into the application interface.

Continuous testing/integration can be executed at different stages of environments like Development, QA, Staging, and Production.

Use Test-Driven Development Approach

The test-driven development approach involves creating test scripts even before developing the feature, which means testers automate the test scripts for components that need to be developed and then integrate it into the system.

However, in test-driven development, the test might fail again and again if it doesn’t meet the expected behavior of the feature. It will only pass if it starts meeting the predicted behavior of the feature. Also, with test-driven development in place, testers and developers need to work hand-in-hand for better flexibility and productivity.

Implement In-Sprint Test Automation

Companies that are using Scrum in their software testing processes need to implement in-sprint test automation for quick results. In-sprint automation not only helps in keeping up with the regression testing, but it also enables testers and developers to focus on other essential tasks. With in-sprint automation, you can also get better results from continuous testing and integration.

Use An Automated Testing Tool

If you haven’t started using automation for remote testing yet, then this is the best time to look for an automation testing tool. For starters, you can begin with the open-source Selenium suite, which gives you access to four different tools for automation testing, including [Selenium Grid], WebDriver, IDE, and RC.

However, Selenium is a tricky tool to be used by beginners; only experts having experience in automation testing can use Selenium to its maximum potential. Also, if you’re looking for a tool that is ideal for an entire testing team, then LambdaTest is your best bet.

LambdaTest enables you to test your web app for multiple scenarios like responsive testing, regression testing, cross browser compatibility testing, and more. Moreover, it allows you to share testing sessions with your team members via screenshots or video recording.

Wrapping Up

Working remotely is not a new trend; many companies have been following it already for a long time. But, it was never implemented to an entire workforce. Before the pandemic, development and testing teams were always working from offices even if other team members were working remotely. However, the pandemic has changed the whole situation; companies are now forced to give all their employees work from home. This has become a little challenging for remote testing teams and that is what we have tried to highlight in this blog. In case we have missed out on the challenges of working remotely, let us know what the key challenges of software testing are and how you overcome them.

Happy testing!

Create TestNG XML File & Execute Parallel Testing

Abeer Mishra — Fri, 21 Aug 2020 09:16:26 +0000

In the previous article, we learned about creating a TestNG project in Eclipse and how to run our first ever Selenium Test Script. Now that you know how to run a TestNG project Eclipse, it is time to dig deeper into TestNG. So far, you’ve run only a single test script, but in practical scenarios, that simply won’t do. When it comes to Selenium test automation, running one test at a time will not be very beneficial. You will have to run multiple test cases to make the most of a Selenium Grid. In this tutorial, let’s dive deep into how we can execute multiple test files from a single file known as the TestNG XML file. We will also see how we can create and execute a parallel testing suite using a TestNG XML file.

In case you are late to the TestNG tutorial series, here’s a step-by-step guide to install TestNG in Eclipse.

What’s the purpose of a TestNG XML File?

The entire point of using a TestNG framework is to run tests in parallel, i.e. run multiple tests simultaneously. In Java, you have to create test cases separately and then define the test later in the primary method. On the other hand, TestNG allows you to create multiple test cases simultaneously, and that is where the TestNG XML file comes in. A TestNG XML file eases this task, and we can write various test cases all within single or multiple classes using annotations.

Uses of TestNG XML file:

Seamless parallel execution
Executing multiple test cases for various Java class files
Group execution of test cases
Supports Parameterisation in TestNG and data-driven testing
Including or excluding a particular test method
Includes names of class, folders, and methods
Clearer test summary with separate HTML and extent reports
TestNG listeners automatically create logs

Creating a TestNG XML File

Now that you understand how vital a TestNG XML file is for running parallel tests in a Selenium Grid, it is time to learn how to create a TestNG XML file. Before we begin, let us go back to the first test we created using TestNG in the previous article and perform the following steps. There are two methods to create a TestNG XML file, feel free to use either of them-

Method 1-

Right-click on the project folder & towards the bottom of the list, select TestNG and then “Convert to TestNG.”

A screen like below would appear. Click on Next.

The next window that pops up will have the refactored source code, which would be applicable after you click Finish.

A new addition to your project directory would be displayed named as testng.xml.

Double click on testng.xml to open the xml file which looks like below-

Method 2-

Right-click on Project, then New, and finally select File.

Next, enter the following file name “testng.xml” and then click on Finish.

In this step, you will have to enter the XML code manually. That is how the two methods differ from each other. After entering the XML code, you can select a name for your liking suite and class.

This is what a basic XML file looks like-

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="Suite">
    <test name="Test">
         <classes>
             <class name="testng.TestNGTestOne"/>
          </classes>
     </test> <!-- Test -->
</suite> <!-- Suite -->

Now you can copy the above code (with your choice of names) on the TestNG XML file we’ve created above.

Voila! You have your very first TestNG XML file ready. That is all you have to do to create a TestNG XML file on a Selenium Grid or for Selenium test automation.

Running a TestNG XML File

The hierarchy of an XML file is quite straightforward. It goes something like this- first < suite > tag, second < test > tag and lastly, < classes > tag. As mentioned above, you can give any name to the suite and test tag, but you have to be careful while naming classes since it is a combination of the Package name and Test name.

Since suite is the topmost hierarchy, this is where multiple test classes can be placed. For example, we have three test classes, one for opening Google, another for searching on Google, and one to open Gmail. All these three classes can be defined under the same test tag for execution.

This example will help you understand it better.

Here, I have created two Java classes- one that opens up Google & verifies its title and another one which again opens Google & searches for a string.

First Class File-

package testNG;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
public class TestNGTestOne {
    WebDriver driver;   
  @Test
  public void f() { 
      System.out.println("Start test");
    //Setting up the chrome driver exe, the second argument is the location where you have kept the driver in your system
      System.setProperty("webdriver.chrome.driver", "E:\\chromedriver.exe");
    //Setting the driver to chrome driver
      driver = new ChromeDriver();
      String url = "https://www.google.com";
      driver.get(url);
      //Capturing the title and validating if expected is equal to actual
      String expectedTitle = "Google";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
  }
  @BeforeMethod
  public void beforeMethod() {
          System.out.println("Starting the browser session");
  }
   @AfterMethod
  public void afterMethod() {
      System.out.println("Closing the browser session");
      driver.quit();
  }
 }

Second Class File-

package testNG;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
 public class TestNGTestTwo {
    WebDriver driver;
      @Test
      public void f() {      
              System.out.println("Start test");
            //Setting up the chrome driver exe, the second argument is the location where you have kept the driver in your system
              System.setProperty("webdriver.chrome.driver", "E:\\chromedriver.exe");
            //Setting the driver to chrome driver
              driver = new ChromeDriver();
              String url = "https://www.google.com";
              driver.get(url);
              //Searching the values on google
              WebElement txtBox = driver.findElement(By.xpath("//input[@class='gLFyf gsfi']"));
              txtBox.sendKeys("Lambda Test");
              txtBox.sendKeys(Keys.ENTER);
              }
      @BeforeMethod
      public void beforeMethod() {       
              System.out.println("Starting the browser session");
      }
      @AfterMethod
      public void afterMethod() { 
              System.out.println("Closing the browser session");
              driver.quit();
      }
}

Next, we will create the TestNG XML file that uses both the above-defined test cases.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="Test Suite">
  <test name="Google Test">
    <classes>
    <class name="testNG.TestNGTestOne"/>
    <class name="testNG.TestNGTestTwo"/>
    </classes>
  </test> <!-- Test -->
</suite> <!-- Suite -->

In the XML above, you can see two class names are written under the test name tag. These are the classes that I would want to run using the TestNG XML file. Also, note that I named my test “Google Test” and suite “Test Suite” respectively. Go ahead and choose any name as per your convenience for these two.

The next step is to run the project using the XML file. Right-click on the testng.xml file and navigate to “Run As >> TestNG Suite.”

By doing this, you would not have to run the classes individually; instead, we will be executing both the classes by a simple click. The output after the execution would look like below-

You can see for yourself that the test classes mentioned in the XML ran successfully, and with it, you can now create your own test suite and run multiple tests all in one go and subsequently get the results.

Parallel Testing Using TestNG.XML File On Selenium Grid Cloud

Now that you have executed your TestNG.xml file successfully. It is pivotal to note the changes you need to make into the TestNG.xml for Selenium test automation over a cloud-based Grid. Because at the end of the day you want a more practical approach and configuring hundreds of browsers and operating systems in your nodes doesn’t look feasible enough.

You can leverage a cloud Selenium Grid such as LambdaTest which provides 2000+ real browsers and operating systems online. That way, you only need to focus on writing better Selenium automation scripts.

So let me show you how you can leverage testng.xml to run parallel testing with Selenium on LambdaTest.

We will take a sample to-do application for the demo. The Selenium testing script will go to the Sample to-do application and click on the checkboxes to indicate the items are done and will add them to the list. After adding it would verify if the items are added.

Let us have a look at our Java test file.

import java.net.MalformedURLException;
import java.net.URL;

//TestNG Todo : Sample App
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;


public class TestNGToDo {
  public String username = "examplelambdatest";
  public String accesskey = "1234abcd9876";
  public RemoteWebDriver driver = null;
  public String gridURL = "@hub.lambdatest.com/wd/hub";
  boolean status = false;

  @BeforeTest
  @org.testng.annotations.Parameters(value={"browser","version","platform"})
  public void setUp(String browser, String version, String platform) throws Exception {
     DesiredCapabilities capabilities = new DesiredCapabilities();
      capabilities.setCapability("browserName", browser);
      capabilities.setCapability("version", version);
      capabilities.setCapability("platform", platform); // If this cap isn't specified, it will just get the any available one
      capabilities.setCapability("build", "LambdaTestSampleApp");
      capabilities.setCapability("name", "LambdaTestJavaSample");
      capabilities.setCapability("network", true); // To enable network logs
      capabilities.setCapability("visual", true); // To enable step by step screenshot
      capabilities.setCapability("video", true); // To enable video recording
      capabilities.setCapability("console", true); // To capture console logs
      try {
          driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);
      } catch (MalformedURLException e) {
          System.out.println("Invalid grid URL");
      } catch (Exception e) {
          System.out.println(e.getMessage());
      }
  }

  @Test
  public void testSimple() throws Exception {
     try {
            //Change it to production page
          driver.get("https://lambdatest.github.io/sample-todo-app/");

            //Let's mark done first two items in the list.
            driver.findElement(By.name("li1")).click();
          driver.findElement(By.name("li2")).click();

           // Let's add an item in the list.
            driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
          driver.findElement(By.id("addbutton")).click();

            // Let's check whether the items we added are in the list.
          String enteredText = driver.findElementByXPath("/html/body/div/div/div/ul/li[6]/span").getText();
          if (enteredText.equals("Yey, Let's add it to list")) {
              status = true;
          }
      } catch (Exception e) {
          System.out.println(e.getMessage());
      }
  }


  @AfterTest
  public void tearDown() throws Exception {
     if (driver != null) {
          ((JavascriptExecutor) driver).executeScript("lambda-status=" + status);
          driver.quit();
      }
  }
}

To make your Selenium test script run over LambdaTest Selenium Grid, you will need to declare a few changes to the script. This would involve specifying your LambdaTest username, your LambdaTest access key and the HubURL in the remote webdriver, for routing your test script to LambdaTest Selenium Grid.

driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), capabilities);

All of these details can be found on your LambdaTest automation dashboard.

By far I am sure you’ve realized the importance of using TestNG.xml for running scripts on cloud Selenium Grid. It is simple really, you don’t want to write down hundreds of test files to test the same scenario over hundreds of browser drivers. Which is why you will need a TestNG.xml file which will allow you to run a single test file over numerous combinations of parameters and values specified in it.

For this purpose, you invoked the Parameters annotations in TestNG. – @org.testng.annotations.Parameters(value={“browser”,”version”,”platform”})

Now you need to provide values to these parameters in your testng.xml file. Then you will be able to run a single test across several browsers, simultaneously.

//TestNG.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite thread-count="3" name="LambaTestSuite" parallel="tests">

  <test name="WIN8TEST">
  <parameter name="browser" value="firefox"/>
  <parameter name="version" value="62.0"/>
  <parameter name="platform" value="WIN8"/>
    <classes>
      <class name="LambdaTest.TestNGToDo"/>
    </classes>
  </test> <!-- Test -->

  <test name="WIN10TEST">
  <parameter name="browser" value="chrome"/>
  <parameter name="version" value="79.0"/>
  <parameter name="platform" value="WIN10"/>
    <classes>
      <class name="LambdaTest.TestNGToDo"/>
    </classes>
  </test> <!-- Test -->
  <test name="MACTEST">
  <parameter name="browser" value="safari"/>
  <parameter name="version" value="11.0"/>
  <parameter name="platform" value="macos 10.13"/>
    <classes>
      <class name="LambdaTest.TestNGToDo"/>
    </classes>
  </test> <!-- Test -->

</suite>

If you go to your LambdaTest platform now. You will notice that the same test has been triggered over multiple browsers + operating systems combinations. Just as we specified in our TestNG.xml file.

This is the reason why Parallel testing is one of the most in-demand features of Selenium test automation.

A Selenium Grid would really boost up your test build practices. Instead of creating new test cases for individual environments, you can leverage testng.xml to define those environments as parameters and simply run a test on various parameters.

Why break your back when you can run parallel tests on a Selenium Grid cloud?

LambdaTest provides a cloud Selenium Grid where you can run your Selenium test scripts over 2000+ real browsers in parallel.

In our upcoming posts, we will learn about TestNG reports and how we can use the different types provided by the framework. Stay tuned and Happy TestNG! 😉

Create TestNG Project In Eclipse & Run Selenium Test Script

Abeer Mishra — Tue, 11 Aug 2020 09:30:46 +0000

In the last article, we installed TestNG in Eclipse and did some environment set up for the same. Subsequently, we saw how we could convert our existing Java projects into TestNG projects in Eclipse. In this article, we will create a TestNG project from scratch and write our very first test script using TestNG. We will begin by setting up a TestNG project first and then move on to writing the scripts.

Before getting started, we will quickly list down the prerequisites for getting started with a TestNG project, so that you can continue without any hiccups. Here’s what you need to have installed in your system-

Eclipse IDE
Download Selenium WebDriver and Client for Java. – Visit the official website and hit the download button for Java file.

Download and extract these Selenium bindings. We will be using these to add External JAR files later in this Selenium TestNG tutorial.

Create TestNG Project In Eclipse

First of all, you will need to launch Eclipse and then follow the steps below to create a new TestNG project.

Step 1: Navigate to File > New > Java Project.

Step 2: Give your project a name for example, ‘ LambdaTestNG ’ and click on Next.

Step 3: On the next screen, you will see the Java settings for your new project. To make it a TestNG project just navigate to the Libraries tab and click on the Add Library button.

Step 4: Choose TestNG from the list of libraries and click Next.

Step 5: Now, you will see TestNG added to your project libraries. Click on Finish and you are all set with your testNG project.

Your Java project has been created successfully and you will be able to see it by clicking on the Package Explorer button on the left panel.

Adding Selenium JAR files To Selenium TestNG Project

Step 1: Next, you need to add the Selenium API JAR files to your TestNG project “LambdaTestNG”. Right-click on the Project and then hit the Properties.

Step 2: Now, you need to perform JAR selection from the Selenium Java language bindings which you downloaded in your systems. Navigate or choose the path where you have downloaded the Selenium Java language bindings. Add all the JAR files (even the ones inside the libs folder).

Step 3: After adding all JAR files, hit the button to Apply and Close.

Awesome, now you will notice a folder for Referenced Libraries in the project LambdaTestNG.

With these steps, your java project is now all set to execute TestNG, the only thing you will have to do is import the Selenium libraries and browser driver(make sure to use the driver compatible with your system browser version) to run Selenium code.

Creating a TestNG class in Eclipse

Creating a TestNG class is as easy as creating a Java class. All you need to do is follow the steps mentioned below and have your first testNG class ready.

Step 1: Navigate to src from the project folder and right-click the same. You will see TestNG as an option in the dropdown towards the bottom. Click on it and you will now see two sub-options to either create a TestNG class or convert the class to TestNG. As we are creating a new TestNG class, you need to select the first option.

Step 2: Generally, the source folder name is auto-filled but if it is not, you can simply browse through the same. Next, you can give any name to your class, for example, ‘ TestNGTestOne ’ and its package. For now, we will keep the basic annotations selected @BeforeMethod and @AfterMethod. However, Annotations can be configured at a later stage as well depending upon your test scenario. If you wish to configure them now, you can refer to the TestNG annotations tutorial.

Step 3: You will now see a class( TestNGTestOne.java ) in your project directory with default methods, viz f(), as well as beforeMethod() and afterMethod() that you can see were checked in the screenshot above.

You are now all set to write code in your first TestNG class, but before doing so let me quickly brief you about the TestNG annotations that we can see in the class we just created.

@test annotation implies that the method is a test method and any code written under it constitutes to be a test case.
@BeforeMethod implies that the method beneath should be running before the test method.
@AfterMethod, just as the name suggests implies that the method should run after the test method.

Now we will write our first script using Selenium and TestNG.

Writing Our First Test Case Using Selenium and TestNG

Test Scenario: We will write a simple test script wherein we will just open up a browser, navigate to Google, verify the title, and then quit the browser session. You will see the utility of the @BeforeMethod and @AfterMethod annotations as well.

Here is the java test file “ TestNGTestOne.java ”.

package testNG;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;

public class TestNGTestOne {

    WebDriver driver;

  @Test
  public void f() {
    //Setting up the chrome driver exe, the second argument is the location where you have kept the driver in your system
      System.setProperty("webdriver.chrome.driver", "E:\\Softwares\\chromedriver.exe");

    //Setting the driver to chrome driver
      driver = new ChromeDriver();
      String url = "https://www.google.com";
      driver.get(url);
      //Capturing the title and validating if expected is equal to actual
      String expectedTitle = "Google";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
    }
  @BeforeMethod
  public void beforeMethod() {
      System.out.println("Starting the browser session");
  }

  @AfterMethod
  public void afterMethod() {
      System.out.println("Closing the browser session");
      driver.quit();
  }
}

Running Selenium TestNG Script

Right-click on the test script and navigate to Run As >> TestNG Test.

After running the test script, as shown above, you can verify the results of the test. This can be seen either on the TestNG reports or the console itself.

TestNG Reports and Results

As we mentioned above, once you have executed the test shown above you will be able to see its corresponding results either in the Eclipse Console or under TestNG reports under the test-output folder that gets created automatically as soon as you run your first test in the project directory.

Results through Console

You have two options to view your results via the eclipse console which are displayed as two tabs viz, Console and Results of running class < your class name >

Console–

TestNG Results–

Results through TestNG Reports

TestNG offers a rich space for detailed reports of your test scripts that are visible under the test-output folder. We shall discuss briefly it as it is a huge topic altogether. These reports can be seen here:

As you can see there are a number of different reports that can be seen and used for subsequent reporting. We shall discuss more about these reports in our upcoming posts. For now, you can go back to any website you like and practice creating a basic test script using the TestNG framework & cover up the basics as shown in this article. In the next post, we will jump on to understand more about the TestNG XML file.

Bonus Pointer: Use A Cloud Selenium Grid For Parallel Testing

Kudos on creating the TestNG project in Eclipse and running the Selenium TestNG script. Right now you have triggered the Selenium TestNG script using a Selenium WebDriver in your own machine but that isn’t a scalable approach. It’s okay if you’re a novice at Selenium testing. However, after some time your test suites are bound to get bigger as you may have to run automated browser testing over dozens or maybe hundreds of browsers + OS combinations.

Doing so with Selenium WebDriver can consume a lot of time and effort because the tests will be queued and executed one after another.

This is where you can leverage a Selenium Grid which can allow you to run these test cases in parallel. So read this Selenium Grid tutorial and fasttrack your Selenium testing experience like a pro!

If you’re already familiar with Selenium Grid and have it set up in your system, even then there are going to be scale issues. You will need to expand the Selenium Grid with new devices and browsers that would be launched in the market. And that would require a lot of investment in hardware and maintenance of your local Selenium Grid. Which is why it is recommended to use a cloud Selenium Grid like LambdaTest.

LambdaTest will help you trigger your Selenium test cases over 2000+ real browsers and operating systems. That way, you won’t even have to worry about which browsers are new in the market or maintaining your in-house Selenium infrastructure so you could focus on writing better Selenium testing scripts.

In order to run your same script on LambdaTest Selenium Grid, you will need to sign up with LambdaTest(Its FREE) and do a couple of changes to your project setup. Run your TestNG scripts on Selenium Grid Cloud. Happy Testing!