DEV Community: adityadwivedi123

Top 7 Python Frameworks for Automation Testing

adityadwivedi123 — Wed, 10 Aug 2022 07:11:00 +0000

Python is the fastest-growing programming language in 2020 as per the Developer Survey by StackoverFlow. In overall ranking Python ranks on 3rd most loved languages. One of the several reasons for the popularity of Python is the extensive support of test automation frameworks. Most of the popular Python frameworks are compatible with the Selenium test automation framework and used for Selenium Python testing & cross browser testing

With the increasing number of Python automation testing frameworks in 2020, it becomes necessary to choose the ideal Selenium test automation framework that suits your requirements. Apart from unittest (or PyUnit) which is the default Python testing framework in 2020, there are many more python frameworks to choose from.

Here are the top Python testing frameworks in 2020 to realize your Selenium test automation needs.

1. PyTest

PyTest is an open-source Python web automation framework that is primarily used for unit testing. This particular Python testing framework in 2020 is scalable as it is useful for writing simple automation tests as well as complex functional tests for applications & libraries. It is easy to get started with PyTest. It is compatible with Python 3.5+ and PyPy 3.

Test suites written using PyTest are more compact as a lot of boiler-plate code is not required and there is no requirement to include tests into large test classes. Unlike the default Python testing framework 2020 which mandates tests to start with test_ (or end with _test), there is no fixed test case nomenclature in PyTest. This is because PyTest has built-in features that support auto-discovery of test modules and functions.

There is no need to remember self.assert* names due to the introduction of the useful feature of assert rewriting that helps in providing detailed information on failing assert statements.

PyTest Official Website — https://www.pytest.org/

PyTest on GitHub — https://github.com/pytest-dev/pytest/

Here are the details about the PyTest project:

Forks – 1.3K	Pull Requests – 49
Starred – 5.7K	Contributors – 504
Used by – 161K	Commits – 12,079

Watch this video to learn about the various sections of the .robot file in the Robot automation framework with their practical demonstration.

This Cypress test automation tutorial will help you learn the benefits of Cypress automation.

What Are The Prerequisites?

The best part about the PyTest, Python testing framework, is that it involves a gentle learning curve. It is easy to get started with PyTest, especially if you have prior working knowledge about any existing Python testing frameworks.

You will just need a Python IDE for development and Python Package Manager for installing PyTest.

Pros of PyTest

There are a number of advantages of the PyTest framework, major ones are below:

It is compatible with other Python testing frameworks such as unittest (or PyUnit).
Along with simple tests, PyTest can also be used for creating complex functional test cases.
It requires less effort to port existing implementations using other Python testing frameworks to PyTest.
PyTest can be used for projects that practice TDD (Test Driven Development) as well as open-source projects.
PyTest is instrumental in creating effective test cases (and test suites) as it supports parameterization. Using parameterization, test cases can be executed with different input configurations thereby resulting in minimal code repetition.
Tests using PyTest are easy to understand as there is very little boiler-plate code.
It supports fixtures and classes due to which common test objects are available through the lifecycle of a module/class/function/session.
PyTest is extensible and the Python testing framework already has rich plugin architecture. There are currently 315+ external plugins with PyTest.
It supports Parallel test execution through the pytest-xdist plugin.
Asserts in PyTest provide detailed information about the failure scenarios.

Cons of PyTest as a Python testing framework

PyTest is not compatible with other Selenium Python testing frameworks as it uses its own special routines for development. Rewriting the complete code is the only way to port an existing implementation using PyTest to some other Python testing framework.

Is PyTest The best Python Testing Framework For You?

You can choose PyTest over the default Selenium Python framework i.e. unittest in case you are developing complex functional tests. Fixtures, Classes, as well as Parameterization can be extremely handy for automation test development.

This certification is for professionals looking to develop advanced, hands-on expertise in Selenium automation testing with Python and take their career to the next level.

Here’s a short glimpse of the Selenium Python 101 certification from LambdaTest:

2. Behave

Behave is one of the widely used Selenium Python testing frameworks for BDD (Business Driven Development) testing. Behave uses the Gherkin language for development of scenarios and feature files. As Gherkin makes use of simple readable language for test case development, tests can also be created for non-technical personnel in the team thus enabling a Business Driven Development.

Usage of a BDD framework enables better communication between the team members as there is increased collaboration between engineers, managers, quality analysts, business development managers, and more. It is relatively easy to get started with a behavior-driven Python testing framework like Behave if you have working knowledge about other BDD frameworks such as SpecFlow, Cucumber, Cucumber-JVM , etc.

As Behave is a BDD framework, it is fundamentally different from other Selenium Python testing frameworks such as unittest (or PyUnit), PyTest, etc. The latest version of Behave is 1.2.7.dev1

Behave Official Website — https://behave.readthedocs.io/en/latest/

Behave on GitHub — https://github.com/behave/behave

Here are the details about the Behave framework:

Forks – 490	Pull Requests – 12
Starred – 2K	Contributors – 62
Watched – 118	Commits – 1,517

What Are The Prerequisites?

Installation of Behave requires Python above 2.7.14. Prior experience with any of the BDD tools can be handy to get started with the Behave framework.

Pros Of Behave

Here are the advantages of using the Behave framework for test automation:

It is easy to ramp-up if the team has prior experience with any existing BDD framework such as SpecFlow, Cucumber, etc.
Availability of environmental functions, configuration settings, fixtures, etc. enables easy setup & cleanup.
Behave is supported with the PyCharm (Professional Edition).
It supports integration with other web frameworks such as Django and Flask.
It has excellent support documentation and tutorials that can be helpful in getting started with behave framework.
It is simpler to add newer test cases as tests consist of different scenario steps, scenario outcomes, feature files, and more.
Apart from technical people, non-technical members can also play a vital role in test case (or test scenario) development.

Run your Playwright automated testing scripts instantly on 50+ browser/OS combinations using the LambdaTest cloud.

Cons Of Behave

Below are some of the major cons of using the behave framework in Selenium test automation:

It is not supported in the PyCharm (Community Edition).
It is very difficult to share scenario steps (_steps.py) between different feature files (.feature) in Behave.
There is no built-in support for parallel test execution which is one of the primary requirements for automated browser testing. Workarounds for parallel test execution require installation of additional software as mentioned in popular discussion threads here and here.
Behave can only be used for black-box testing.
The plugin behave-parallel that facilitated parallel test execution with behave is now deprecated.

Is Behave The Best Python Testing Framework For You?

Behave framework is suited for web testing as test scenarios can be developed using simple English language. On the other hand, behave is not ideal for integration testing as the verbosity can lead to unnecessary complications of the test scenarios.

Many developers prefer pytest-bdd, the BDD library for pytest.runner as it uses the good features available in pytest hence suited for BDD testing.

3. Robot

Robot is another widely-used Python testing framework that is used for Selenium test automation, RPA (Robotic Process Automation), and ATDD (Acceptance Test Driven Development). It is an open-source and extensible Python testing framework. It can be easily integrated with any other tool due to which it is ideal for creating flexible automation testing solutions.

Watch this video to learn the basics of the robot framework for automation testing. This video will give you an understanding of the various functionalities of the Robot Framework with live examples.

The Python testing framework is operating system and application independent i.e. the same implementation is compatible across different platforms namely — Windows, Linux, and MacOS. The syntax of Robot framework is easy to understand as it uses human-readable keywords. The capabilities of Robot framework can be extended by libraries that are implemented in Selenium with Python . It has a rich ecosystem consisting of libraries and tools developed as separate projects.

Robot Official Website — https://robotframework.org/

Robot on GitHub — https://github.com/robotframework/robotframework

Here are the details about the Robot framework:

Forks – 1.4K	Pull Requests – 51
Starred – 4.4K	Contributors – 105
Releases – 87	Commits – 12,224

What Are The Prerequisites?

Robot Framework can be used if you have Python version 2.7.14 or higher installed. Python Package Manager (pip) command is used to install the Python testing framework.

Pros of Robot framework

Here are the advantages of using the Robot framework for Selenium test automation:

You do not require programming knowledge to write test cases using the Robot framework.
As the Python testing framework is platform and application independent, there is no porting effort required when executing code from one platform to another.
It can be used for BDD, ATDD, and key-word driven Selenium test automation.
It is easy to get started with the Robot framework as the test data syntax can be used with ease.
Robot framework has a rich library ecosystem e.g. Appium for mobile automation, database library for DB testing, etc. for testing different applications.
It has a good built-in reporting mechanism as a HTML log is generated after every build.

Cons of Robot

Below are some of the major cons of using the Robot framework:

There is no in-built support for parallel test execution.
Creating customized HTML reports is not an easy task.

Watch this video to learn about the built-in tools and standard libraries.

Is Robot The Best Python Testing Framework For You?

Due to its rich set of libraries and easy syntax, Robot framework is easier to use when compared to PyUnit (or unittest) and PyTest. You should choose Robot framework if we are looking for an ideal Python automation framework for ATDD.

4. PyUnit (or unittest)

PyUnit (also called unittest) is the default Python testing framework that is a part of the Python standard library. The Python Testing Framework, is inspired by the JUnit framework. It is a part of the unittest module that has shipped since the Python version 2.1 was released.

As the unittest Python testing framework is available out of the box, many developers who are getting started with Selenium test automation prefer the unittest framework. Test cases follow a particular nomenclature where tests either start with test_ or end with _test.

TestCase is the base class that contains the assertion methods, SetUp, and TearDown routines. Number of testcases can be grouped together to form a TestSuite class and build customized test runners.

Try this Selenium online Grid to run your browser automation testing scripts.

What Are The Prerequisites?

As PyUnit framework is available out of the box with the Python testing framework, it does not require any additional package installation.

Pros of PyUnit (or unittest)

Here are some of the advantages of the PyUnit framework:

As PyUnit is a derivative of the xUnit framework and has distinct similarities with the xUnit framework, newbie developers in Python also find it easy to get started with unittest framework.
No additional package installation is required.
Test scenarios can be executed independently or they can be grouped together into a TestSuite. The execution process is simple as tests can be executed only by mentioning their names on the terminal.
The default execution output is concise and easy to understand. This Python testing framework also has a number of command-line options that help in providing more detailed output.
Test report generation is very fast and takes only a few milliseconds.

Cons of PyUnit (or unittest)

Here are some of the major shortcomings of the PyUnit framework:

Naming of testcases still based on the camelCase naming convention using in Java.
A large amount of boilerplate code is used for test implementation.
There is no provision for color output.

Is PyUnit The Best Python Automation Framework For You?

As PyUnit (or unittest) is the default Selenium Python testing framework that is shipped with Python, most developers start their automating testing with Python journey with PyUnit. Too much boilerplate code and support for too much abstraction acts as a major hindrance in using the Python Testing Framework for large projects.

5. Lettuce

Lettuce is a Python testing framework that facilitates BDD testing. It draws its inspiration from Cucumber (that was designed for Ruby). The release names of Lettuce are inspired by green stuff. The latest version of Lettuce is 0.2.23 and is termed Kryptonite.

This particular Python testing framework is open-source and hosted on GitHub. As mentioned on their official website, Lettuce was developed to make testing easy and funny.

Lettuce Official Website — http://lettuce.it/

Lettuce on GitHub — https://github.com/gabrielfalcao/lettuce

Here are the details about the Lettuce framework:

Forks – 335	Pull Requests – 18
Starred – 1.2K	Contributors – 81
Releases – 63	Commits – 967

What Are The Prerequisites?

Lettuce can be installed using the Python Package Manager (pip). The prerequisite is Python 2.7.14 (or higher).

Pros of Lettuce

Here are some of the advantages of the Lettuce framework:

Like other Python testing frameworks such as Behave that facilitate BDD, Lettuce also uses the Gherkin language for creation of scenarios and feature files. Getting started with Lettuce is easy if you have prior experience with any BDD testing tool.
Apart from developers and other technical personnel, other project stakeholders namely marketing folks, project managers, etc. can also play a major role in the test process.
It is easy to add new test cases as primary updates are required in feature files and scenario files.

Cons of Lettuce

Here are some of the major shortcomings of the Lettuce framework:

It is primarily used for black-box testing.
Perfect execution using a BDD testing tool like Lettuce requires timely communication between all the respective stakeholders of the project.

Is Lettuce The Best Python Automation Framework For You?

Lettuce makes the entire process of Selenium test automation scalable, readable, and easy. The best part of using a BDD tool like Lettuce is that non-technical people can also participate in the test creation process as tests are derived from business requirements. Python developers and testers have greater inclination towards pytest-bdd as it has majority of the features supported by other BDD tools.

6. Nose2

Nose2 is a Python unit testing framework and a successor of the Nose framework. It is based on the unittest hence; it is also referred to as an extension to unittest. Nose2 adds support to the PyUnit framework by providing plugins for test execution, enabling automatic discovery of test cases, and collecting documentation.

All these added functionalities make testing with PyUnit simple and easy. The plugin ecosystem of Nose2 adds support for decorators, fixtures, parameterized testing, modules, classes, and test discovery. Such in Nose2 is a DSL (Domain-Specific Language) for writing tests with expensive, nested features, also called as functional tests. More details of Such in Nose2 is available on the official website of Such.

Nose2 Official Website — https://docs.nose2.io/en/latest/

Nose2 on GitHub — https://github.com/nose-devs/nose2

Here are the details about the Nose2, python unit testing framework:

Forks – 127	Used by – 2.2K
Starred – 612	Contributors – 58
Releases – 28	Commits – 934

What Are The Prerequisites?

Nose2 only has a dependency on the unittest module which is shipped along with the Python library. Nose2 can be installed using Python Package Manager (pip).

Pros of Nose2

Here are some of the advantages of the Nose2 python testing framework:

It is easy to install and get started with Nose2 as it extends the existing unittest framework.
With features like test discovery, fixtures, parameterized testing, etc., nose2 makes unittest equally useful as PyTest.
Scripts written in Nose2 support a number of command-line options and extensive configuration via config files.
Using the mp plugin in Nose2, tests can be executed in parallel with multiple processes. This speeds up the test execution in case your tests are heavily IO or CPU Bound.
Nose2 has a large number of plugins that can aid in accelerating the Selenium test automation process.

Cons of Nose2

Here are some of the minor shortcomings of the Nose2 python testing framework:

The documentation of Nose2 is not as extensive as the PyTest framework.
Deprecation of nose framework that was supported on Python 2.4 (and above) could be a potential dampener for developers who want to use Nose2 in their projects.

Is Nose2 The Best Python Testing Framework For You?

If your team members are using the unittest framework and do not intend to switch to any other framework (e.g. Lettuce, Behave, PyTest, etc.), it is worth giving Nose2 a try as it is an extension of unittest.

As Nose2 also has support for parallelized testing, it can be used for automated browser testing kind of scenarios where test scenarios are executed on different browser & platform combinations.

7. Testify

Testify is another popular Python testing framework in 2020 that is considered as a replacement of unittest and nose framework. As the framework is modeled after unittest, the tests written for unittest will require minimal adjustments to work with Testify.

Testify can be used for performing automated unit, integration, and system testing. The latest version of Testify is 0.11.0. It has an extensible plugin system that provides useful functionality around reporting. Like the Nose2 framework, Testify also provides enhanced test discovery and class-level SetUp & TearDown fixture methods that are executed once for the entire set of test methods.

Testify Official Website — https://pypi.org/project/testify/

Testify on GitHub — https://github.com/Yelp/Testify

Here are the details about the Testify framework:

Forks – 69	Watched – 19
Starred – 288	Contributors – 33
Releases – 62	Commits – 974

What Are The Prerequisites?

The major advantage of the Testify framework is that it involves a gentle learning curve as it is based on the existing unittest framework. Installation is fairly simple as it only requires the Python Package Manager.

Pros of Testify

Here are some of the advantages of the Testify framework:

It is easy to get started with Testify as it is based on the unittest framework.
The framework has an extensible plugin ecosystem.
It has additional testing utilities that aid in integration, profiling, and code coverage.
Like the Nose2 framework, Testify also comes with enhanced test discovery which makes finding tests very easy.
It has a decorator-based approach for fixture methods.

Cons of Testify

Here are some of the minor shortcomings of Testify framework:

Testify also has the same issue as Nose2, the documentation is not so extensive which could be a roadblock if you are just getting started with the Testify framework.
Parallel testing with Testify could be a hurdle as pointed in a couple of online discussion forums.

Is Testify The Best Python Testing Framework For You?

Like Nose2, if your team is looking for a Python testing framework built on top of unittest, then it is worth trying out Testify. As achieving parallelized testing with Testify is a bit difficult, it might not be suited for scenarios such as automated browser testing.

Wrapping it Up

In this article, we had a look at some of the popular Python testing frameworks that can be used with Selenium. Each of these frameworks have their own share of advantages and disadvantages. If you intend to include the non-technical members in the test creation process, you should try BDD tools such as Behave or Lettuce. To summarize, choosing the right Python testing framework purely depends on the project requirements and the competency available within the team.

Which particular Python testing framework do you use? Do share your experience in the comments section. Also, please feel free to share this article with your friends by retweeting us on twitter. Happy Testing☺

Selenium WebdriverIO Tutorial with Example

adityadwivedi123 — Tue, 09 Aug 2022 06:53:41 +0000

WebdriverIO is Javascript based test automation framework built over nodeJs. It is an open-source project developed for the automation testing community. WebdriverIO is extendible, compatible, feature-rich, and easy to install. This is considered a Next-gen test automation framework which supports both desktop browsers and mobile apps. Which makes this WebDriverIO tutorial a favourable option for Selenium automation testing. It supports BDD and TDD test framework. The latest version of WebdriverIO is 5.X.

So, before jumping into this WebDriverIO tutorial for Selenium, explore what WebDriver is, its features, how it works, best practices, and more in this WebDriver Tutorial.

Also, try this Selenium online Grid to run your browser automation testing scripts. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

WebdriverIO Architecture

The first and foremost topic that you would learn in this WebdriverIO tutorial is going to be the WebdriverIO architecture. This is what happens when you run a WebDriverIO test script.

NodeJS: NodeJS is an open-source project which helps to run the Javascript runtime environment.
WebdriverIO: WebdriverIO built on top of NodeJS which communicates with NodeJS.
JavaScript: The script is written by the user with the help of the WebdriverIO library.

This flow gets executed when the user runs WebdriverIO test script:

JavaScript written by the user sends a request by WebdriverIO via nodeJS to the Services which is in the form of HTTP command using JSON Wire Protocol. Now, services forward the request to browsers to perform user actions.

Why WebdriverIO is a popular test Framework?

WebdriverIO is a widely used test automation framework in Javascript. It has various features like It supports many reports and services, Test Frameworks and WDIO CLI Test Runners
The Following are the supported reporters’ examples:

Allure Reporter
Concise Reporter
Dot Reporter
JUnit Reporter
Spec Reporter
Sumologic Reporter
Report Portal Reporter
Video Reporter
HTML Reporter
JSON Reporter
Mochawesome Reporter
Timeline Reporter
CucumberJS JSON Reporter

The following are an example of the supported services

Appium Service
Devtools Service
Firefox Profile Service
Selenium Standalone Service
Shared Store Service
Static Server Service
ChromeDriver Service
Report Portal Service
Docker Service

The followings are the test framework supports

Mocha
Jasmine
Cucumber

Additionally, It is very popular among the developers and testers. The daily download is around 84,957 and weekly download is around 414,847 and yearly 1,848,479. So far it has released 243 release versions. Also, there are active community and support for the issue and has 5.3K stars in the Github.

You can take this certification as proof of expertise in the field of test automation with JavaScript to empower yourself and boost your career.

Here’s a short glimpse of the Selenium JavaScript 101 certification from LambdaTest:

Prerequisites For This WebDriverIO Tutorial

Before we proceed further to executing Selenium automation testing scripts in this WebDriverIO tutorial, make sure to have the below things set up.

Installing Node and npm

In order to do the basic setup, you required to have node.js installed. To check node.js is installed or not just type node -v command and run, you should see node.js version.

$ node -v

If the node is installed correctly then you will see node installed version.

When you install nodejs, node gives you a javascript runtime environment. Also, it installed by default npm which is nothing but node package manager. npm helps the user to install a third-party library. You can check npm version installed by typing following command on terminal.

$ npm -v

If you see any error then follow the instruction given on NodeJs official website.

Check out our cloud infrastructure, It has 3000+ desktop & mobile environments. The best selenium testing tool.

Creating A Project Workspace For WebDriverIO

Setup the project folder by creating a workspace folder and we will keep all the files in that. As an example to the WebDriverIO tutorial for Selenium testing, we will call that folder as ‘LambdaTestProject’. Run the following command in the terminal.

mkdir LambdaTestProject &amp;&amp; cd LambdaTestProject

Initialize package.json

Create package.json file by typing the following command:

npm init -y

With this command, we have created package.json file where we can add dependencies that we required to run our automation. We have added -y option with the npm init command. When you add -y option then you are skipping all input asking for ‘Yes’ prompts and setup default package.json setting for you. Remember that, the parameter ‘-y’ is optional.

If you do not enter ‘-y’ option then the following option should provide

Install WebdriverIO CLI

Next step in this WebdriverIO tutorial would be the installation of the CLI dependency, we need to run the following command:

npm i --save-dev [@wdio/cli](http://twitter.com/wdio/cli)

As a result of the above command, you can see dependency ( “@wdio/cli”: “⁵.16.11”) get added in the package.json file.

{
  "name": "lambdatestproject",
  "version": "1.0.0",
  "description": "Webdriver First Script",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@wdio/cli": "^5.16.11"
  }
}

Note: If you find any permission error then try to run with the sudo command.

sudo npm i --save-dev [@wdio/cli](http://twitter.com/wdio/cli)

Once, the dependency is added in the package, you need to create a webdriverIO configuration file for executing Selenium scripts through WebdriverIO.

WebdriverIO Configuration

Enter the following command in order to create WebdriverIO config file:

./node_modules/.bin/wdio config -y

By this command, the following packages are configured automatically, of course, you can change later if you want to.

@wdio/local-runner
@wdio/mocha-framework
@wdio/spec-reporter
@wdio-chromedriver-service
@wdio/sync — chromedriver

Here is the output of the command which says which file needs to run.

Again, here we have used ‘-y’ option so all default options get set up for you. And wdio.conf.js file gets created under your project root folder. We will use this file to configure our project.

By default, this auto-configure set services as the chromedriver, framework as Mocha with BDD options.

The last two lines tell you how to execute the written automation script. If you want to avoid ‘-y’ option then type the following command and you have to give input as shown below:

./node_modules/.bin/wdio config

You can choose displayed options according to your requirements. And, this is the final output after entering the above options.

Create A Test Folder

In every test project, we required to create a folder that keeps all Selenium test cases in one place. Type the following command in the terminal to create a test folder for this WebDriverIO tutorial.

mkdir -p ./test/specs

Note: if you are giving different specs path in above command then you need to make sure that same folder path is mentioned in the wdio.config.js file under specs:.

Create A Test Script File

The next prerequisite for WebdriverIO tutorial will be a Test Script, which is a JavaScript file where we are going to write our Selenium automation testing script.

touch ./test/specs/myFirstScript.js

Open this myFirstScript.js in any of your favorite editors and starts writing your first Selenium testing script.

Verify The wdio Test Runner

WebdriverIO provides a test runner called wdio where you can run your script. It is laid under the /node_modules/.bin directly.

./node_modules/.bin/wdio run wdio.conf.js

It scans your wdio.conf.js file and prepares the Selenium testing suite according to the configuration mentioned in the file. Then it picks the specs file mentioned in the wdio.conf.js and starts executing the script. In our case, we have set specs: [ ‘./test/specs//.js’]* so, it will start all js file present under the ‘./test/specs folder’.

Executing First WebdriverIO Script On Local Selenium WebDriver

Now, that we have all the prerequisites set up for this WebDriverIO tutorial. It is now time to get into the crux of the matter and run our first Selenium automation testing script using the WebDriverIO. As you have already set up your local environment to run your first script using chrome. You can use the below script to start off. Copy the below code and paste in the myFirstScript.js file.

WebdriverIO Example Script

const assert = require("assert");

describe("Lambdatest Demo Test", function() {
    it("Lambdatest Demo TestCase", function() {
        browser.url("https://lambdatest.github.io/sample-todo-app/");
        $("*[name='li1']").click();
        $("*[name='li2']").click();
       $("#sampletodotext").setValue("Lambdatest\n");

        assert.strictEqual(browser.getTitle(), "Sample page - lambdatest.com");

    });
});

WebdriverIO Example Script Walkthrough

Let’s understand the given code. In the first line, You have imported the assert library so that we can use assert in our program.

describe() block allows you to keep all your tests under one describe functions. In this case, you have defined describes, “Lambdatest Demo Test”. In another way, you can think of a suite block.

Each describe() can have multiple it(). it() is nothing but your test cases. You can write N number of test cases under describe function.

Now, let’s understand the Selenium testing steps that we have written. First, browser is a globally defined object. You can use driver object as well instead of ‘browser’. browser.url() method opens the URL provided as a parameter.

$() returns the web element to the user and then the user can perform click() operation.
Syntax is $(selector).

In this example, I have taken a selector as XPath and ID Below is the XPath example with a Name parameter.

Another selector example is ID. if you want to select an element with the help of ID then just add # before id name. So, #sampletodotext is ID selector. Also, You can see the click() method is used to click() on element and setValue() is used to enter a value in the textbox.

Lastly, we have used to Assert.strictEqual() methods to verify browser title. There are many assert methods that can help you to do more assertion in your script.

Test Execution Using Selenium Webdriver On Local Machine

Now, we will have a quick look at how the execution of these WebdriverIO tutorial test scripts that takes place across different operating systems.

Mac Operating System

If you are done with the setup and configuration on Mac Operating system then you do not have to worry about additional setup. Just type following command from your project root directory.

./node_modules/.bin/wdio run wdio.conf.js

Here is the complete execution result console log. In wdio.conf.js default log level is ‘Info’ so you can see info level details.

Windows Operating system

In order to run the same script on windows 10 operating system then perform the following steps

Open Specify Test Files what is wdio.conf.js under the project root folder
Find the “capabilities” section
Add “platformName: ‘Windows 10’”

Kudos! You have successfully run your first Selenium testing script through this WebdriverIO tutorial. We are now going to look into a more of a practical problem around the automation testing with Selenium and WebdriverIO. When your project demands a wider automated browser testing coverage with fast execution results. In such a case, the local selenium setup will not really be an ideal approach to go ahead with. Let’s understand why?

This Cypress automation testing tutorial will help you learn the benefits of Cypress automation.

Challenges Of An In-house Selenium Setup

We are in a world where agile SDLC is being adopted by a majority of the businesses. As a result, we are witnessing fast releases by major vendors for browser, mobile operating systems, desktop operating systems, and more. Be it WebdriverIO, or any other test automation framework, creating and maintaining a Selenium Grid infrastructure could be a challenging call if the market is bringing updates at such a rapid pace. Here are the disadvantages when you scale using an in-house Selenium testing setup.

More test cases coverage, slow result!
In the long run, a project demands more test case coverage and faster result. It takes a lot of time to execute locally with different browsers combinations and operating system and the team has to wait until execution gives the result.
More browsers and Operating systems, along with their version coverage.
Nowadays, product demand more browser and operating coverage as the market user have many options to choose from. In such a case, If you have set up a selenium grid locally, it takes immense effort to maintain that including different browsers and think of setup for the different operating systems and its version. For longer runs, it’s nearly impossible to maintain locally.
Expensive call
As you know, the current market user has many browser options and Operating system. To manage the whole setup including script upgrade, execution and fixing will be costly as you need to have a dedicated team to do all these tasks, which would be costlier for a longer run. You would also have to invest a hefty amount in the hardware.
Maintenance
Last but not least, maintaining the whole setup is a big challenge. The dedicated team has to maintain script, local servers and set up up and environment upgradation. In such a case, the dedicated team would be spending more time behind the maintenance rather than actual QA work.

So what can you do to overcome these challenges?

Overcoming Challenges Using An Online Selenium Grid

This is where cloud-based Selenium automation testing such as LambdaTest can be a handful. An online Selenium Grid for automation testing can help you scale faster, ship your products with speed, along with a robust pipeline. Here is how!

Cost-effective
Running a script with different browsers and its version including various platform would be less costly than running locally setup environment. Nowadays, the cloud-based platform provides an on-demand test environment, session based and concurrent session which is cost-effective. Why? Because the infrastructure provided on the cloud is shared by a pool of users. So instead of making a device lab all for yourself. You can opt to go for a pre-built cloud-based Selenium Grid.
More coverage and fast result
With minimal configuration, cloud-based test automation provides many options to run your script simultaneously, you can cover many test cases on multiple browsers and platforms and get faster results.
Easy access
With the help of a cloud-based test automation platform, users can access the whole project from anywhere and at any time. You do not have to depend on dedicated access and lab to be accessed, just log in to the cloud-based platform and you are ready to access their resources and your project.
More environments and platforms
It is very important to covers many platforms and browsers for the test coverage. Procuring these is very costly. Hence, the cloud-based platform has already set up so that you can take advantage of multiple platforms and environments for your project.
Support team
Many cloud-based platforms have a dedicated support team where they will help you to support an environment-related issue. Having a dedicated support team will really help you to save your lot of time behind environment maintenance.
Team collaboration
A cloud-based test platform helps the team to work on a single project from any location. Hence tester can run the script from any geographical location and any time with zero changes.
Numerous Integrations To Third-Party Tools
Using LambdaTest, you can perform Selenium automation testing with WebdriverIO and enjoy the convenience of multiple third-party integrations for project management, CI CD pipeline, codeless automation, bug tracking, instant messaging, and more.

WebdriverIO Test Execution On An Online Selenium Grid

In this section of WebdriverIO tutorial for Selenium automation testing, we will perform the Selenium script execution over an online Selenium Grid of 2000+ real browsers provided by LambdaTest. Before running your test on LamdaTest, you need to install the dev Dependency. You can install by entering the following command

npm install [@wdio/selenium-standalone-servi](http://twitter.com/wdio/selenium-standalone-servi)ce --save-dev

Now, Suppose you want to run the same script which you have written for the local machine, on LamdaTest you just need to change the Specify Test File that is wdio.conf.js

The below configuration runs on Chrome version 79.0 on windows 10 operating system.

Note: Add actual user name and accessKey from the LamdaTest website.

Most important is the service parameter. You need to set as selenium-standalone otherwise script will not run on LamdaTest. Additionally, you have to change path and baseUrl parameters as shown below.

path: "/wd/hub",

capabilities: [
        {
            maxInstances: 5,
            name: "My First Script - Chrome-Window", // name of the test,
            user: "<YOUR_USERNAME>",
            accessKey: "<YOUR_ACCESSKEY>",
            build: "FirstScript-Demo",
            platformName: "Windows 10", 
            browserName: "Chrome",
            browserVersion: "79.0",
            video: true,
            console: true,
            visual: false
        }
    ],
    coloredLogs: true,
    hostname: "hub.lambdatest.com",
    port: 80,
    baseUrl: "",

After running ./node_modules/.bin/wdio wdio.conf.js , you can find the test case being executed on your LambdaTest account. If you go to the LambdaTest automation dashboard, you can find all the relevant details around the WebdriverIO and Selenium testing script execution. Here is the local console log:

What Details Would You Get On LamdaTest Dashboard?

Dashboard: In the Dashboard view you can check summary where an overview of your total tests run and concurrent session details and others more information.

TimeLine: In the timeline screen, you can see your automation script build version. You can give build version names in your capabilities.

**Automation Logs: **In the Automation Logs you can see each execution in detail including browser version, Operating system version, execution date and time, videos, screenshots and steps of execution.

Exceptions: If you would come across any exception while executing your Selenium and WebdriverIO script on LambdaTest, they would all be listed under the exception tab.

Command: In the command view, you can see each step element status.

Logs: You can view the Selenium log as well as the Console log.

Metadata: Metadata view gives you the supplied meta details and input configuration and browser configuration you passed.

Analytics: In this tab, the user can see the build status by today, weekly and monthly with additional important information.

The intuitive dashboard is not the only feature for which you may choose LambdaTest. Another key feature of great importance is the ability to perform parallel testing with Selenium.

WebdriverIO Example For Parallel Selenium Testing

When your project test script grows and it takes a lot more time to execute and produce results. You need to find a solution to get a faster way to generate results also, many different types of browsers are coming into markets and we have to deal with that. In such a situation, the parallel execution will help us to find the correct solution.

The advantages of using parallels browsers are:

● Speed up the execution

● Browsers and Operating system coverage

In the WebdriverIO there is a property called maxInstances **which helps you to run parallel browsers. Change your current **wdio.conf.js with multiple browsers’ capabilities and run the same script.

The following capabilities will run the Safari browser on the Mac Operating system and Chrome browser on the Windows Operating system.

capabilities: [
        {
            maxInstances: 5,
            name: "My First Script - Chrome-Window", // name of the test,
            user: "<YOUR_USERNAME>",
     accessKey: "<YOUR_ACCESSKEY>",
            build: "MyFirstScript-Demo",
            platformName: "Windows 10", // macOS High Sierra & Windows 10
            browserName: "Chrome",
            browserVersion: "79.0",
            video: true,
            console: true,
            visual: false
        },
        {
            name: "My First Script - Safari-Mac", // name of the test,
            user: "<YOUR_USERNAME>",
     accessKey: "<YOUR_ACCESSKEY>",
            build: "MyFirstScript-Demo",
            platformName: "macOS High Sierra", // macOS High Sierra & Windows 10
            browserName: "Safari",
            browserVersion: "11.0",
            video: true,
            console: true,
            visual: false
        }
    ],

You can add multiple instances based on the target operating system CPU capacity. It advisable to create maxInstances is as required in order to get stable results.

Let’s view the LamdaTest automation dashboard and see the execution details. You can see there are two tests ran under concurrent sessions and details are shown in the below screenshot.

You can see the build name which we have set up in the capability section.

Local console logs:

Run your WebdriverIO tests & start your free testing.

That Is All

I am sure this WebdriverIO tutorial has helped you become proficient in automation testers with Selenium and WebdriverIO examples. Remember, if you are planning to scale your Selenium automation testing suite then it is recommended to go for a Selenium Grid to help you perform parallel testing. However, maintaining a Selenium Grid can be an expensive and strenuous option. Consequently, an online Selenium Grid is a different story that can help you paddle faster through your release cycles. In case you have any questions, feel free to let me know in the comments sections below. I would be happy to answer. Happy testing! 🙂

Test Automation With Selenium Click Button Method(Examples)

adityadwivedi123 — Mon, 08 Aug 2022 14:37:00 +0000

One of the most fundamental and crucial interactions while Selenium automation testing is done by automating click operations over elements on a web page. We facilitate the click interaction using a method called Selenium.click().

Selenium click button method, although, is one of the most basic drills, it is often used inefficiently. Even experienced tester seems to miss out on the entire implementation of the click method is Selenium. They become occupied with writing complex test scenarios and forget that sometimes, a random click in the UI of a web application, can lead to a bug. This is why, today, I will be talking about different ways in which you can make use of Selenium.click() command to help you perform test automation in a faster and better manner.

In this article, I will cover Selenium.click() in great detail. We will automate from basic to advanced interactions through the click.

If you’re new to Selenium and wondering what it is then we recommend checking out our guide — What is Selenium?

If you are an experienced automation tester, you can skip the basic operations and head out to the advanced mouse operations. For beginners, we will start with a basic introduction of Selenium testing. Without further ado, let’s go!

Try this Selenium Testing Tool Grid to run your browser automation testing scripts. Our cloud infrastructure has 3000+ desktop & mobile environments. Try for free!

What Is Selenium?

Selenium is one of the most popular automation testing frameworks. Being a free, and open-source framework has made it a popular choice among the global tester community for automating the web testing experience. Selenium automation testing offers support for multiple programming languages and browsers like Google Chrome, Mozilla Firefox, Safari, Microsoft Edge, Internet Explorer, etc. making it a perfect choice to perform automated cross browser testing. Its popularity as an open-source has helped it to deliver compatibility across numerous test automation frameworks too! Let us have a quick and basic run down.

Selenium has 4 variants:

Selenium IDE(Integrated Development Environment)— It is a framework which is used to automate web application only. it is a record and playback combination tool which is used to automate web app in Firefox and Chrome browser.
Selenium RC(Remote Control)— Selenium Remote control is also called selenium 1.0. It supports all browsers but we need to start the server first if we use selenium RC. its execution is slower. It does not support HTTP protocol.
Selenium WebDriver— Selenium webdriver is a webpage automation tool.while is used to automation web page only. There isn’t any need for a server to work with Selenium WebDriver. Its directly connect to browsers using driver.
Selenium Grid— Selenium Grid is a combination of webdriver client library and RC(Remote Control) library . we use selenium Grid to execute the program in the remote control.

Selenium Webdriver also supports a headless browser like PhantomJS. Meanwhile, Selenium WebDriver has some disadvantages too like WebDriver cannot automate captcha. Using Selenium WebDriver for gaming and audio & video testing is not possible. The biggest flaw for Selenium WebDriver lies with its manner of test execution. Selenium WebDriver allows serial execution of test cases which makes it a little troubling for complex and large web-applications or test suite as it can take quite a while to validate sufficient test coverage.

As a solution, the Selenium Grid was introduced to allow testers to perform parallel testing with Selenium. Today, where automation testing is on the rise, Selenium plays a crucial role in helping startups & large enterprises into-market launch.

For a more detailed difference between these 4 Selenium variants, refer to our Selenium WebDriver tutorial.

Check out this This Cypress automation testing tutorial. This will help you learn the benefits of Cypress automation, and how to install Cypress and execute Cypress automation testing over scores of browsers and operating systems online..

What Is Selenium ‘.click()’?

Selenium offers a ‘.click()’ method to help you perform various mouse-based operations for your web-application. You can use the Selenium click button method for various purposes such as selecting the radio button and checkbox or simply clicking on any button or link, drag and drop, click and hold, etc.

In the next section, I am going to demonstrate the practical implementation of Selenium click button method in for basic operations, and advanced operations. After that, I will also show you how you can use CSS selectors with the Selenium .click method.

Basic Operations Using Selenium.Click()

Let’s start with the basic operations that your perform using the Selenium click button method for automation testing. We will do so with the help of Action class. Action class is an ability used to handle any mouse operation with the Selenium click button method. It comes as an in-built ability for Selenium automation testing. You can also leverage action class for keyboard interactions.

Performing Mouse Click/Left Click In Selenium Testing

The most basic operation using a Selenium click button method is a left-click or a mouse click.

Test Scenario: Visit LambdaTest Homepage and click on the Login button.

Example code for the test scenario:

You can also use the Selenium .click() button for enabling/disabling checkboxes, radio buttons.

Test Scenario 2: After you click on the LambdaTest Login button, tick the checkbox for “Remember me”.

Note: To confirm whether a checkbox or a radio button is selected or not, we make us of the isSelected().

This certification is for anyone who wants to stay ahead among professionals who are growing their career in Selenium automation testing.

Here’s a short glimpse of the Selenium 101 certification from LambdaTest:

Performing Right Click In Selenium Testing

In some of the scenarios while Selenium automation testing of a web page, you may need to automate right click over a button, text, image or more.

**Test Scenario: **Go to LambdaTest Live and open the video in a new tab.

Action class may be ineffective to automate this scenario as we are trying to open a right-click menu of the Google Chrome browser. Action class has few restrictions around the keyboard usage, you can only declare modifier keys such as Shift, Ctrl, CapsLk, etc. using the actions class. However, you can use the Robot class to leverage keyboard inputs that are different from modifier keys.

We will be using the Robot class here to capture the elements of the right-click menu and perform a click on one of those elements to automate using the Selenium click button method.

This Playwright Browser Testing tutorial will guide you through the setup of the Playwright framework, which will enable you to write end-to-end tests for your future projects.

Performing Mouse Hover In Selenium Testing

Mouse hover is a vital part of any cross browser testing checklist. Many times you want to check whether the styling applied over a web element is supported in a consistent manner when accessed from different browsers or not? You can also use a mouse hover to verify a prompt message over a button.

Test Scenario: Visit LambdaTest Pricing and perform a mouse hover on the text “What are parallel tests?”. After understanding what parallel tests are picking a parallel test value from the drop-down.

In a few projects, some time elements are not visible or element is disabled in this case we need to take the help of JavaScript Executor. While working on not visible elements gives an “illegalStateException” and we can get rid of this using the JavascriptExecutor.

Example Script for Test Scenario:

Advanced Operations Using Selenium.Click()

With basic operations covered, we now step into performing advanced operations using the Selenium click button method.

Using Selenium Click Button with X,Y coordinate

We can use movebyOffset to perform a click anywhere on the page by feeding (x,y) coordinates to the WebDriver. You can even generate a click on blank portions of your webpage as long as you are aware of the (X,Y) coordinates.

Test Scenario: Visit LambdaTest Homepage and find the (x,y) coordinates for the button “Start Free Testing”.

In the above image, you can notice the X, Y coordinates specified under the highlighted “Start Free Testing” button.

Note: These (X, Y) coordinates will be different from one screen resolution and screen size to another.

Performing Double Click In Selenium Testing

Double click is an absolute must for Selenium automation testing be it for performance or automated browser testing. Here is an example of how you can perform double click using Selenium automation scripts.

Click And Hold Using Selenium Automation Testing

Many times when you are performing automation testing with Selenium, you may come across a requirement where you would need to highlight a text, image by clicking and holding the mouse. Let us take a scenario to automate this interaction.

Test Scenario: Visit JQuery UI Draggable Interface, perform a click and hold over the draggable box and then move using the offset.

Here is the code to automate click and hold, along with movebyoffset.

Performing Drag and Drop In Selenium Testing

Somewhat similar but slightly different than Click and Hold, is the requirement for Drag and Drop. Here, the place to drop after dragging is specifically prominent in the UI so you know where to place an element.

Test Scenario: Visit JQuery UI Droppable Interface, perform a click on the draggable box, and then drop it in the container box.

Here is how you can automate the above-mentioned test scenario using the Selenium click button method.

Locators & Selenium Click

Selenium locators allow you to locate a web element over a web page. There are 8 types of locators(identifire) in Selenium. Let’s see how you can perform a click in Selenium using different Locators.

1. ID()

Wherever an ID is specified in the HTML code for any web element, you can leverage that in your Selenium automation testing scripts to locate that particular web element. The ID of a web element would always be unique which makes it a very powerful way to locate web elements automatically using Selenium automation testing. To automate clicks using an ID locator you would need to specify in your code as below.

driver.findelement (by.id(“idLocator”)).click();

2. Name()

Similarly, you can find the name of a web element by inspecting the HTML and use it to locate the web element using Selenium automation testing. To use the Selenium click button with Name locator, you need to address it in a similar way.

driver.findelement (by.name(“password”).sendkeys(“123456789”);

3. Class Name()

I rarely use the Class name as an alternative to other locators in Selenium. Inspect a web element, find its class name, and locate it using your Selenium automation scripts.

driver.findelement (by.class.name(“mycheckbox”)).click();

4. Tag Name()

Whenever there is a webelement with unique HTML tag we can use the TagName locator in Selenium automation testing. There can be many types of Unique HTML tag such as:
Hyperlink — < a >
Image – < img >
Header – < h1 >

So for example, if you have a unique Hyperlink TagName using the anchor tag then you can incorporate Selenium click button interaction using the below code.

driver.findelement(by.tagname(“a”)).click();

5. Link Text()

If there is a hyperlink with a unique HTML tag then we can make use of the LinkText locator. Here we specify the text over which a Hyperlink is triggered on a webpage through a click.

driver.findelement(by.linktext(“facebook”).click();

6. Partial Link Text()

You can specify the text for a hyperlink even partially and locate it using the Partial Link Text locator. For example, if we wish to locate a web element with a hyperlink that says Amazon then we can do so using the below command.

driver.findelement(by.partiallinktext(“zon”)).click();

7. CSS Selector()

A more cross browser compatible locator than Xpath is a CSS selector as a primary browser such as Google Chrome and Mozilla Firefox are designed to optimize the execution time for a CSS selector.

driver.findElement(By.cssSelector("#app > section > form > div > div > input:nth-child(3)")).click();

Note: Whenever we use CSS selector or Xpath as a locator we should not use mandatory attribute because mandatory attribute will be the same for similar kind of webelement so it is always recommended to go for additional attributes.

8. Xpath()

XPath is a locator that is used to locate the webelement based on the tag, attribute, text, etc. we can use Xpath for HTML as well as for XML Docs.

Bonus: Random Links Using Click Method In Selenium

Here is a cool tip using which you can click on every hyperlink on a webpage. Gotta click em all!

Test Scenario: Visit LambdaTest Homepage and click on every hyperlink invoked through the anchor tag in HTML.

Below is a script which is generating a list of hyperlinks on the LambdaTest Homepage where the tagName is “a” which represents an anchor tag. After that, it would click on every link a single time, in random order. The script would visit the first link, go to the respective web page and then will roll back to LambdaTest to visit the next link and the cycle will go on till every link is visited a single time.

Console Output:

As you can see there were in total 47 hyperlinks that were accumulated by the test automation scripts. They are visited one by one! I will leave it for you to find a way of incorporating this in your automated browser testing scripts.

Bonus: Java Loop Using Selenium Click Button Method

Sometimes to reproduce a bug on a UI element, you may need to automate a loop to witness whether a bug was encountered in X number of trials. I am going to show you how to create a Java loop for the Selenium click button.

Test Scenario: Login to the LambdaTest application. Go to the profile icon on top-right and click to open the menu, then click to close it. Continue the drill for 75 clicks to see if any anomaly is encountered.

Here is a recording of the test execution:

Did We Click Some New Ideas?

By far, I hope you have a good understanding of how powerful the Selenium .click() button method can be and how you can leverage it. I hope the bonus tips were helpful for your daily automated browser testing scripts. Do you want to share a bonus tip too or a unique way in which you used the Selenium click button method? If so, drop your thoughts in the comment section below! Happy testing! 🙂