DEV Community: Gunjan Kaushik

Debunking The Top 8 Selenium Testing Myths

Gunjan Kaushik — Tue, 11 Apr 2023 07:21:35 +0000

When it comes to web automation testing, the first automation testing framework that comes to mind undoubtedly has to be the Selenium framework. Selenium automation testing has picked up a significant pace since the creation of the framework way back in 2004.

Developers and the QA community hail open-source frameworks like Selenium, since it has a huge community and supports major programming languages like Python, C#, Java, JavaScript, Ruby, and PHP. But, that’s not all. It is relatively easy to port web automation tests from the local Selenium Grid to a cloud-based Selenium Grid like LambdaTest. As per the State of the Open Source report, Selenium is still the king of web automation and holds close to 81 percent market share in this crowded test automation tools market.

In this article, we take a look at some aspects of simulation and discuss some ways through which we can use iPhone Simulator for Windows, including using an iOS emulator for PC.

Fast forward now, Selenium 3.141.59 is the latest stable version of Selenium, and Selenium 4 release is just around the corner. A few weeks back, the Selenium community released the RC1 (Release Candidate — 1) of the most awaited version of Selenium 4.

Source

Even though Selenium is extremely popular for web automation testing, many QA engineers have numerous Selenium testing myths about various facets of the Selenium framework. In this blog, we try to debunk the misconceptions or Selenium testing myths that revolve around the Selenium framework.

Myth #1 Being open-source, Selenium has numerous limitations

Open-source software is one of the most important models to ensure transparency and accountability. Unfortunately, many developers and QA engineers see paid tools as being better than open-source software because there is a misconception that good product features come at a significant cost. This can be attributed to the fact that most people consider open source solutions to be less intuitive, incomplete, or an alternative solution to paid software solutions. However, this discussion does not hold good for the Selenium framework.

Selenium being an open-source framework, has a large community of contributors who keep the project up to date, and it is very easy for any QA engineer to find solutions around Selenium from forums like Stack Overflow, Selenium Slack Community, amongst others. At the time of writing this blog, Stack Overflow has close to 89,000+ questions with the Selenium tag.

Source

Apart from these forums, you can also latch on to the LambdaTest Selenium community if you need answers around Selenium automation testing, Selenium automation frameworks, and more. But, that’s not all. You can also check Selenium documentation on the official website if you are just getting started with the framework or looking to try out the new features in the framework.

Myth #2 Selenium is not secure

The occurrence of data breaches has increased significantly over the past decade. It’s no surprise given the number of sophisticated hackers who constantly discover security vulnerabilities in everything from web applications to Internet of Things (IoT) devices.

Obviously, no open-source software or proprietary framework can guarantee the best security.

For something like Selenium, which is sponsored by the reputable Apache Software Foundation, this does not apply. Selenium is an integrated suite of tools and frameworks, which allows teams to perform automated and manual testing, ensuring the security of all the critical information, critical systems, and the information in transit.

However, a common misconception among testers is that Selenium tests are slow and extremely flaky. To dispel these notions and effectively harness the power of Selenium, test teams must understand how they can improve their efficiency and develop high-quality software.

Selenium, as a framework for supporting automated testing, is robust. This condition is an important factor for ensuring comprehensive automated testing. Another critical element for this purpose is testing on real devices and different browser & platform conditions for improving test coverage.

Read — Code Coverage vs. Test Coverage

A cloud-based cross browser testing solution like LambdaTest, which is GDPR and SOC2 compliant, helps QA testers to run their Selenium tests on cloud browsers and real device cloud to assure accuracy and proximity to real user conditions.

Myth #3 Selenium is not suited for large enterprises

Over the past several years, several automation tools like Cypress framework have been released as there are umpteen benefits of test automation. Though companies and individual developers have been trying out new test automation tools, Selenium is still the most preferred framework for web automation testing.

Many QA engineers have the misconception that Selenium is not enterprise-worthy just because it’s a free tool. However, this misconception is utterly false, as Selenium is a product of the Apache Software Foundation (ASF).

Selenium has become a powerful solution as it can be used for automating business-critical applications like large-scale e-commerce websites, government websites, and more. It is incorporated into even the most stringent automation projects at some of the world’s leading e-commerce, cloud computing, and SaaS companies, including Netflix, Bloomberg, The New York Times, Twitter, eBay, Yahoo!, PayPal, WordPress.com, LambdaTest, and more.

Enterprises looking to leverage the Selenium framework for realizing large-scale web automation testing have the flexibility to choose a cloud-based Selenium Grid like LambdaTest. Such a solution reduces the overhead cost of maintaining in-house infrastructure and helps improve product quality by letting you run automation tests across a range of browser and OS combinations.

In this article, LambdaTest's online mobile emulators allow you to seamlessly test your mobile applications, websites, and web apps on mobile browsers and mobile devices, using an emulator online.

Myth #4 Selenium does not have a proper release cycle

There are many myths about open-source software, but one of the most pervasive one is that open-source software lacks the resources to put forth updates. However, this is not true. Community expertise is one of the major factors behind the growth of any open-source software, and the same principle also holds good for the Selenium framework. Open-source development has access to a plethora of resources provided by fellow open-source hackers who are always willing to help out with bug fixes or updates.

With access to an entire community of developers, open-source is the most efficient and economical way to develop and advance new technologies for immediate and long-term implementation. Large tech communities collaborate and work together to leverage good ideas. Open-source projects also bring together expert individuals who work on these projects to make innovative changes and updates.

Selenium, too, has firm community support from contributors across the world. Since it was released, Selenium WebDriver has continued to progress against its goal of being a comprehensive browser automation tool. LambdaTest is also one of the sponsors of the Selenium framework. It is one of the best ways of nurturing an open-source community!

// Detect dark theme var iframe = document.getElementById('tweet-1412817632793792515-156'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1412817632793792515&theme=dark" }

The below table breaks down some of the latest Selenium releases, starting from the Selenium recent version and working back, and their key features.

Selenium Version	Release Date	Key Features
"Selenium 4.0
Alpha 5
(Selenium Latest Version)"	March 2020	"Improved docker support.
Reuses the same HTTP client.
OpenTelemetry Replaces OpenTracing."
Selenium 4.0 Alpha 4	January 2020	"Latest CDP spec.
Support for creating and removing virtual authenticators.
Debug virtual authenticators debug support."
Selenium 4.0 Alpha 3	July 2019	"Adds “relative” locators.

Post Selenium 4 (Alpha-5), there have been numerous Alpha releases of the framework, and we are eager to get our hands dirty with the Selenium4-RC1 release.

In this Appium automation tutorial, learn about Appium and its benefits for mobile automation testing. Take a look at how Appium works and see how to perform Appium testing of your mobile applications.

Myth #5 Selenium updates break the existing working implementation

Upgrading to a newer version of Selenium WebDriver requires you to upgrade your browser driver as well. However, upgrading the version will bring along with it access to new functionalities, along with ensuring backward compatibility with the previous release.

You just need to make sure that the version of the Selenium jar and the browser driver are in sync. For example, Selenium 4 is a major update over the previous stable version of Selenium (i.e., 3.141.59). In addition, Selenium 4 relative locators let you access nearby WebElements easily, thereby eliminating the need to use Selenium Web locators to locate required elements on the web page.

An army of Selenium enthusiasts are working round the clock to ensure a stable Selenium version is released to the end-users. Stability, reliability, and security are some of the major things taken care of when the community releases any major Selenium update.

Myth #6 Selenium can be used to test APIs

You might have come across the following question when working with Selenium — How can I test APIs using Selenium?

Selenium provides the flexibility to interact with the elements in the DOM by locating the Element and using appropriate Selenium methods to interact with the said element. You need to access them programmatically to test APIs, which can be done using an API testing tool like REST Assured or JMeter.

So, to answer the question, “Can I use Selenium for API testing?”, the short answer is no, but you can use REST Assured or JMeter. However, tools like LambdaTest provide REST APIs for Selenium automation to access relevant details about the tests being run on the cloud grid.

Myth #7 Selenium can be used for performance testing

Selenium is an important tool for automated testing, but many people think that test application (or website) performance can be improved with the Selenium Grid. Actually, the use of Selenium Grid is just an excuse for the poor performance of tests.

Selenium Grid helps to execute tests in parallel, thereby letting you reduce the time spent on test execution and product release. Parallel testing in Selenium Python and other Selenium-supported languages is one of the major reasons why enterprises (and developers) prefer the Selenium framework.

Standalone Selenium cannot be used for performance testing, but when integrated with JMeter can be used for load testing. Though Selenium and JMeter can be used for some level of performance testing, they can only be used for small-scale applications (or projects).

Myth #8 Selenium can automate testing of desktop automation

As already said above, Selenium is a free and open-source tool that allows you to automate interaction with the WebElements on the AUT (Application Under Test). However, in order to handle anything outside of the browser’s scope (e.g., file upload or download within the windows dialog box), you need to use other tools like ROBOT and integrate them with Selenium.

On the whole, the capabilities of Selenium can be best extracted if the framework is used for web automation.

A comprehensive User Acceptance Testing (UAT) tutorial that covers what User Acceptance Testing is, its importance, benefits, and how to perform it with real-time examples.

Conclusion

Selenium is the world leader in browser automation. It’s free, powerful, and extremely easy to use. But these facts have led some testers astray–they believe Selenium is limited because it’s free. So why invest in a paid tool when Selenium does everything you need?

In fact, there is no other tool in the market that offers advanced features like Selenium does while maintaining its small footprint and affordable price; and every tester needs to debunk these Selenium testing myths.

How To Use Annotations In Cucumber Framework [Tutorial]

Gunjan Kaushik — Wed, 04 Jan 2023 10:09:10 +0000

Cucumber is one of the most popular open-source BDD frameworks that facilitates Selenium test automation. It offers a set of tools that helps us to manage the various scenarios available in multiple feature files. We have already seen how to configure Cucumber and write a basic Cucumber test using a feature file in our earlier blog on automated testing with Selenium and Cucumber. However, it doesn’t suffice when you are working on complex projects involving multiple feature files.

To handle multiple feature files and the multiple scenarios in each of the files, there is an inherent need for functionality to manage the execution of these scenarios. This is where Cucumber provides us a handful of utilities to ease the maintenance of our framework.

This Cucumber tutorial will help you learn about Cucumber annotations ranging from tags, Cucumber hooks, and more. However, you can refer to this guide for configuring the Cucumber setup In Eclipse and IntelliJ if you haven’t configured it in your machine yet.

Let’s look into following Cucumber annotations individually and explore more in this Cucumber tutorial.

How To Use Cucumber Tags

Automation frameworks today offer several APIs to cover various situations. But you can’t really mock everything! It’s cumbersome to mock every scenario in a new file, and it’s not a good deal to leave them in the existing file. So instead, we can use cucumber tags to separate the multiple scenarios in a single file and execute only one of them.

If you are familiar with TestNG, you would know how to specify the test method to be included or excluded in the XML file (refer to our TestNG tutorial for more).

While performing automation testing with Cucumber, you may use Tags in the feature file. Tags are nothing but a meaningful name you may give to your test scenario in the feature file. The ideal way to use tags is by using ‘@.’

For example; To mark a scenario as a regression test case in your framework, you may tag it as ‘@RegressionTest’ right above the scenario in the feature file.

Once you define the tags for your scenario, you may specify which scenario you would like to execute in your runner file. You may either tag the scenario or the entire feature file that the Scenario, Outline, etc., will then automatically inherit.

Below is an example of running multiple selective tests or a single feature file using the Cucumber annotation- Tags.

Read — Cucumber Best Practices For Selenium Automation

Execution of Selective Scenarios using Tags

Let us consider an example where multiple scenarios are present in a feature file with different tags, as shown below:

    @Test
    Feature: Testing tagged hooks
    @Regression
    Scenario: Test the search results
      Given Google is open in the browser
      When User searches for Lambda Test
      Then Results are displayed

    @Sanity
    Scenario: Test the search results again
      Given Google is open in the browser
      When User searches for Selenium cross browser testing
      Then Results are displayed

     @E2E
    Scenario: Test the search results for more than two keywords
        Given Google is open in the browser
        When User enters more than two keywords
        Then Results are displayed

    @Sanity @Regression
    Scenario: Test I am Feeling Lucky Button
        Given Google is open in the browser
        When User clicks on I am Feeling Lucky button
        Then Results are displayed

Now, let us try to execute only the tests with the tag as ‘@sanity’ using the Runner class as shown below:

   package stepDefinitions;

    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;

    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;

    public class SingleOne {
        WebDriver driver;


        @Given("Google is open in the browser")
        public void google_is_open_in_the_browser() {
            System.setProperty("webdriver.chrome.driver", "D:\\Gunjan\\Selenium\\chromedriver.exe");
            System.setProperty("webdriver.chrome.silentOutput", "true");
            driver = new ChromeDriver(); 
            driver.get("https://www.google.com/");
            driver.manage().window().maximize();

        }
        @When("User searches for Lambda Test")
        public void user_searches_for_lambda_test() {
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Lambda Test");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();

        }

        @When("User searches for Selenium cross browser testing")
        public void user_searches_for_Selenium_cross_browser_testing(){
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Selenium Cross Browser Testing");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();
        }

        @When("User enters more than two keywords")
        public void user_enters_more_than_two_keywords(){
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("LambdaTest, Regression");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();

        }


        @When("User clicks on I am Feeling Lucky button")
        public void user_clicks_on_I_am_Feeling_Lucky_button(){
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnI']")).click();

        }

        @Then("Results are displayed")
        public void results_are_displayed() {
           System.out.println("The page title is - " +driver.getTitle());
          driver.quit();
        }



    }

On executing the above file, you will see that only two tests are executed, tagged as @sanity.

Here is one more example where we will execute the entire Feature File using its tag.

Check this out: Cypress Automation Testing Online- Execute & analyse Cypress testing scripts online. Deploy quality builds faster with 40+ browser versions on cloud.

Execution of Feature File using Tags

The updated test runner file would look like below:

   package cucumberOptions;

    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;

    @RunWith(Cucumber.class)
    @CucumberOptions(features="src/test/java/features/single.feature", glue="stepDefinitions", tags="@Tests")
    public class TestRunner {     
    }

On executing this file, we will notice all the scenarios under the feature file are executed.

So far in this Cucumber tutorial, we have seen execution through a single tag. Let us now explore the scenarios under which more than one tag is executed. To implement, we may use the logical operators either AND or OR. Let us see examples of each.

Execution of Scenarios using Tags with Logical Operators

To execute scenarios that are using either @sanity or @E2E tag, we will use the OR keyword as shown in the code below:

   package cucumberOptions;
    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;
    @RunWith(Cucumber.class)
    @CucumberOptions(features="src/test/java/features/single.feature", glue="stepDefinitions", tags="@Sanity or @E2E")
    public class TestRunner {     
    }

You will see that three tests are executed that have either the @sanity or @E2ETest tag.

Similarly, we will use the AND operator to execute scenarios with both @sanity and @Regression tags. The below code has been updated to run the same scenario.

   package cucumberOptions;

    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;

    @RunWith(Cucumber.class)
    @CucumberOptions(features="src/test/java/features/single.feature", glue="stepDefinitions", tags="@Sanity and @Regression")
    public class TestRunner {

    }

And here you go! You will see just one test is tagged while both the tags are getting executed.

Now here comes another use case! What if you want to execute all the tests but ignore a few? How do we do that?

Well, you can use the same tags but with a ‘not’ preceding the tag. If you add ‘not’ before the tag name in the runner class, you will notice that the scenarios under the tag get skipped, as shown in the below example:

    package cucumberOptions;

    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;

    @RunWith(Cucumber.class)
    @CucumberOptions(features="src/test/java/features/single.feature", glue="stepDefinitions", tags="not @Sanity")
    public class TestRunner {

    }

The execution would happen for all the scenarios except the ones tagged with @sanity.

Next in this Cucumber tutorial, we will learn about Cucumber Hooks, which like other Cucumber annotations, are code blocks that can be executed either before or after scenarios.

How To Work With Cucumber Hooks

You may know that multiple prerequisites are required at the start of test execution. Right from setting up the web driver, browser settings to cookies, navigating to the specific URL, etc.

Similarly, some steps must be performed after executing the test scenarios, like killing the web driver connection, clearing browser cookies, generating reports, etc. Such cases can be easily handled using one particular type of Cucumber annotations, namely Cucumber Hooks.

You might have worked across different TestNG annotations, like BeforeTest, BeforeMethod, BeforeSuite, AfterTest, AfterMethod, AfterSuite, etc. Unlike TestNG, Cucumber provides only two hooks, i.e., before and after. We will now see how we can implement these Cucumber hooks in our tests.

Check this out: Cypress Cloud Automation Testing Online- Execute & analyse Cypress test scripts online. Deploy quality builds faster with 40+ browser versions on cloud.

Implementing Cucumber Hooks

In this section of the Cucumber tutorial, we will now see how Cucumber hooks can be implemented for basic scenarios. We will cover examples where we have a single scenario and one with multiple scenarios.

Below is an example of a feature file with a single feature.

   @SingleFeature
    Feature: Testing hooks from a single feature file
    Scenario: Test the search results 
      Given Google is open in the browser
      When User searches for Lambda Test
      Then Results are displayed

Next, let us create a simple step definition file for the feature file we just created.

    package stepDefinitions;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;
    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;
    public class SingleOne {
        WebDriver driver;

        @Given("Google is open in the browser")
        public void google_is_open_in_the_browser() {
            System.setProperty("webdriver.chrome.driver", "D:\\Gunjan\\Selenium\\chromedriver.exe");
            driver = new ChromeDriver();
            driver.get("https://www.google.com/");
            driver.manage().window().maximize();

        }
        @When("User searches for Lambda Test")
        public void user_searches_for_lambda_test() {
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Lambda Test");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();

        }
        @Then("Results are displayed")
        public void results_are_displayed() {
           System.out.println("The page title is - " +driver.getTitle());
           driver.quit();
        }

    }

Further, we will create the Java class for the Cucumber hooks to implement in our framework. This class is created under the stepDefinitions package, as shown in the below code:

   package stepDefinitions; 
    import io.cucumber.java.After;
    import io.cucumber.java.Before;
    public class Hooks {

        @Before
        public void setUp(){
            System.out.println("Starting the test");
        }

        @After
        public void burnDown(){
            System.out.println("Closing the test");
        }
    }

Note that I am using simple text inside hooks methods, and you may use more logical steps and their corresponding code for your Selenium test automation.

We need to create the step definitions for the specific feature by calling the @SingleFeature tag we used for our feature file in the runner class, as shown in the below code snippet:

   package cucumberOptions;

    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;

    @RunWith(Cucumber.class)
    @CucumberOptions(features="src/test/java/features", glue="stepDefinitions", tags="@SingleFeature")
    public class TestRunner {


    }

On executing the above code, you will see that the execution of the @Before and @After hook provides the following result:

Now that we have covered an example with a single feature let’s take the example with multiple feature files. We will add one more feature to the project and execute these scenarios in parallel using the Maven Surefire Plugin.

Feature File 1

    Feature: Testing hooks from a single feature file
    Scenario: Test the search results 
      Given Google is open in the browser
      When User searches for Lambda Test
      Then Results are displayed

    Scenario: Test the search results again
      Given Google is open in the browser
      When User searches for Selenium cross browser testing
      Then Results are displayed

Feature File 2:

  Feature: Testing the hooks in parallel
    Scenario: Test sign up on Lambda Test
      Given LambdaTest is open in browser
      When User enters an email in the email address text box
      Then User lands on registration page

Let’s have a look at the step definition files for these features.

Step Definition File 1:

    package stepDefinitions;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;
    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;
    public class SingleOne {
        WebDriver driver;


        @Given("Google is open in the browser")
        public void google_is_open_in_the_browser() {
            System.setProperty("webdriver.chrome.driver", "D:\\Gunjan\\Selenium\\chromedriver.exe");
            driver = new ChromeDriver(); 
            System.out.format("Thread ID - %2d - from feature file single.\n",
                    Thread.currentThread().getId());
            driver.get("https://www.google.com/");
            driver.manage().window().maximize();

        }
        @When("User searches for Lambda Test")
        public void user_searches_for_lambda_test() {
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Lambda Test");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();

        }

        @When("User searches for Selenium cross browser testing")
        public void user_searches_for_Selenium_cross_browser_testing(){
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Selenium Cross Browser Testing");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();
        }

        @Then("Results are displayed")
        public void results_are_displayed() {
           System.out.println("The page title is - " +driver.getTitle());
          driver.quit();
        }

    }

Step Definition File 2:

   package stepDefinitions;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;
    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;
    public class Second {

        WebDriver driver;


        @Given("LambdaTest is open in browser")
        public void lambda_test_is_open_in_browser() {
            System.setProperty("webdriver.chrome.driver", "D:\\Gunjan\\Selenium\\chromedriver.exe");
            driver = new ChromeDriver();
            System.out.format("Thread ID - %2d - from feature file second.\n",
                    Thread.currentThread().getId());
            driver.get("https://www.lambdatest.com/");
            driver.manage().window().maximize();

        }
        @When("User enters an email in the email address text box")
        public void user_enters_an_email_in_the_email_address_text_box() throws InterruptedException {
            driver.findElement(By.xpath("//div[@class='clearfix w-6/12 mx-auto smtablet:w-full smtablet:mx-0']//input[@name='email']")).sendKeys("tester@test.co.in");
            driver.findElement(By.xpath("//div[@class='clearfix w-6/12 mx-auto smtablet:w-full smtablet:mx-0']//button")).click();
            Thread.sleep(3000);
        }
        @Then("User lands on registration page")
        public void user_lands_on_registration_page() {
            System.out.println(driver.getTitle());
            driver.quit();
        }



    }

Next, in this Cucumber tutorial, we will configure the maven surefire plugin in our pom.xml with the parallel attribute for methods.

Plugin configuration in pom.xml:

    <build>
    <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <version>2.22.0</version>
      <configuration>
          <parallel>methods</parallel>
          <useUnlimitedThreads>true</useUnlimitedThreads>
      </configuration>
    </plugin>
    </plugins>
    </build>

Once you execute the pom.xml using maven install or any other relevant command, you will notice that the execution results clearly show different thread numbers (refer to the three lines highlighted in pink in the logs below) for the two feature files. This indicates that our feature files were executed in parallel.

Integrating parallel test execution for Selenium test automation to the Cucumber framework saves a considerable amount of time. However, for effective parallel execution, you might face challenges in terms of resources and time. As not every user might be using the same browser with the latest version or the same resolution and operating system.

Leveraging cloud platforms like LambdaTest, which offers cross browser testing on cloud, helps you achieve maximum test coverage at a pace. LambdaTest supports an online selenium grid of 2000+ browsers, browser versions, and operating systems to accelerate automation testing with the ability to perform parallel testing at scale.

Now that we have learned about Cucumber hooks let’s explore tagged hooks in Cucumber annotations in depth.

Read: Cucumber.js Tutorial with Examples For Selenium JavaScript

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:

Check this out: Cypress Test Automation Tutorial: E2E Testing with Cypress

Tagged Hooks In Cucumber

Tagged Hooks are basically the problem solvers when you need to perform different Before and After actions for different scenarios. To explain in a more simple way, think you have ten different tags like Sanity, Regression, etc., which need to be tested with different URLs. This is where Tagged hooks help you achieve that.

Let us create a simple feature file with three different scenarios to understand the concept:

    Feature: Testing tagged hooks
    @CaseOne
    Scenario: Test the search results 
      Given Google is open in the browser
      When User searches for Lambda Test
      Then Results are displayed
    @CaseTwo
    Scenario: Test the search results again
      Given Google is open in the browser
      When User searches for Selenium cross browser testing
      Then Results are displayed

Next, we will create the step definition file for the feature.

   package stepDefinitions;

    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;

    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;

    public class SingleOne {
        WebDriver driver;


        @Given("Google is open in the browser")
        public void google_is_open_in_the_browser() {
            System.setProperty("webdriver.chrome.driver", "D:\\Gunjan\\Selenium\\chromedriver.exe");
            driver = new ChromeDriver(); 
            driver.get("https://www.google.com/");
            driver.manage().window().maximize();

        }
        @When("User searches for Lambda Test")
        public void user_searches_for_lambda_test() {
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Lambda Test");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();

        }

        @When("User searches for Selenium cross browser testing")
        public void user_searches_for_Selenium_cross_browser_testing(){
            driver.findElement(By.xpath("//input[@name='q']")).sendKeys("Selenium Cross Browser Testing");
            driver.findElement(By.xpath("//div[@class='FPdoLc lJ9FBc']//input[@name='btnK']")).click();
        }

        @Then("Results are displayed")
        public void results_are_displayed() {
           System.out.println("The page title is - " +driver.getTitle());
          driver.quit();
        }



    }

Now we will create the hooks file and define the tagged hooks in it. This can be done using the @Before or the @After hook followed by the tag name of the scenario as shown in the code below:

   package stepDefinitions;

    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;

    import io.cucumber.java.After;
    import io.cucumber.java.Before;

    public class Hooks {

        @Before
        public void setUp(){
            System.out.println("Execution before every scenario");

        }

        @After
        public void burnDown(){
            System.out.println("Execution after every scenario");
        }

        @Before("@CaseOne")
        public void beforeOne(){
            System.out.println("This will be executed before case one");
        }

        @After("@CaseOne")
        public void afterOne(){
            System.out.println("This will be executed after case one");
        }

        @Before("@CaseTwo")
        public void beforeTwo(){
            System.out.println("This will be executed before case two");
        }

        @After("@CaseTwo")
        public void afterTwo(){
            System.out.println("This will be executed after case two");
        }
    }

Note that I have added Before and After hooks for scenario one and scenario two outlined in the feature file with tags @CaseOne and @CaseTwo, respectively.

Also, I have used a @Before and @After hook to be executed before and after each scenario. Let us run the same test runner file as used earlier and see the results:

This way, we can write unique prerequisite actions and post-execution actions for each scenario.

Let’s learn how the same tagged hooks can be used for multiple scenarios as we move forward. All you have to do is simply append the tag name for the scenarios in the hooks file using the ‘or’ keyword, as shown below.

I am adding @CaseTwo with the @CaseOne tag name in the file we just used and removing the @case tagged hook.

   package stepDefinitions;

    import io.cucumber.java.After;
    import io.cucumber.java.Before;

    public class Hooks {

        @Before
        public void setUp(){
            System.out.println("Execution before every scenario");

        }

        @After
        public void burnDown(){
            System.out.println("Execution after every scenario");
        }

        @Before("@CaseOne or @CaseTwo")
        public void before(){
            System.out.println("This will be executed before case one and two");
        }

        @After("@CaseOne or @CaseTwo")
        public void after(){
            System.out.println("This will be executed after case one and two");
        }
    }

On executing the test, you may see the results in which the same @Before and @After hooks are executed for scenarios with tags @CaseOne and @CaseTwo.

Check this out: Cypress Automation Testing Tutorial: E2E Testing with Cypress

Setting Order or Priority of Cucumber Hooks

If you have worked on TestNG, you must be familiar with the priority of tests and execution order. Similarly, Cucumber hooks can also be executed as per order.

Let us consider an example with a hooks file consisting of two @After hooks and two @Before hooks. We will set the order of the hooks as per our requirement by simply specifying the order as in the hooks file code below:

   package stepDefinitions;

    import io.cucumber.java.After;
    import io.cucumber.java.Before;

    public class Hooks {

        @Before(order=0)
        public void setUp() {
            System.out.println("This will execute first--Before");
        }

        @After(order=1)
        public void tearDown() {
            System.out.println("This will execute first--After");
        }

        @Before(order=1)
        public void setUpTwo() {
            System.out.println("This will execute second--Before");
        }

        @After(order=0)
        public void afterOne() {
            System.out.println("This will execute second--After");
        }
    }

As we execute the code, you will see that hook execution is similar to what we have defined.

Now, you may set the order of execution of hooks as per your requirement.

Check this out: Playwright Tutorial: Getting Started With Playwright Automation Framework

Understanding The ‘Background Keyword’ In Cucumber

So now that we have learned about the different Cucumber annotations that can be used, we will understand another important keyword in Cucumber called the Background Keyword.

We have multiple scenarios that require the same prerequisites, like logging in or navigating to a URL in real-time. Now you may say that we can use the Cucumber hooks to trigger such scenarios. But what if all the scenarios in a feature need this prerequisite, and we are working with multiple features!

To make the code more efficient and manageable, Cucumber provides the Background Keyword, which contains a series of steps executed before each scenario of the feature file. This Background keyword, along with the steps, is placed in the feature file.

Let us see how it works by using an example. Consider a ticket booking application. To search for tickets or to book a ticket, you will have to login to the website. We will use the Background keyword to define the login functionality which each scenario can reuse.

The feature file for our example would look like below:

  Feature: Testing the background keyword

    Background: Logging In of User
    Given Login page is displayed
    When credentials are entered
    Then user is logged in

    Scenario: Search tickets for a destination
    Given Search for destination A
    When Destination A is selected and date is selected
    Then Tickets available are displayed


    Scenario: Book tickets for a destination
    Given Available tickets for a destination are displayed
    When The number of tickets is selected and payment done
    Then the tickets are booked

Since logging in is required in both the scenarios above, we keep the Login functionality under Background. Now, we will create the step definition class.

Note that this is all a dummy representation, and you may use logical code that would trigger the functionality of your application.

   package StepDefinitions;
    import io.cucumber.java.en.Given;
    import io.cucumber.java.en.Then;
    import io.cucumber.java.en.When;

    public class BackgroundTest {



            @Given("Login page is displayed")
            public void login_page_is_displayed() {
                System.out.println("Login page displayed");
            }


            @When("credentials are entered")
            public void credentials_are_entered() {
                    System.out.println("Credentials entered");
            }
            @Then("user is logged in")
            public void user_is_logged_in() {
                    System.out.println("User logged in");
            }
            @Given("Search for destination A")
            public void search_for_destination_a() {
                    System.out.println("Destination searched");
            }
            @When("Destination A is selected and date is selected")
            public void destination_a_is_selected_and_date_is_selected() {
                    System.out.println("Destination & date selected");
            }
            @Then("Tickets available are displayed")
            public void tickets_available_are_displayed() {
                    System.out.println("Available tickets displayed");
            }

                    @Given("Available tickets for a destination are displayed")
                    public void available_tickets_for_a_destination_are_displayed() {
                        System.out.println("Available tickets for a destination are displayed");
                    }
                    @When("The number of tickets is selected and payment done")
                    public void the_number_of_tickets_is_selected_and_payment_done() {
                        System.out.println("Tickets selected and payment made");

                }
                    @Then("the tickets are booked")
                    public void the_tickets_are_booked() {
                        System.out.println("Tickets booked");
                    }

    }

Let us now run this feature using the test runner file.

    package cucumberOptions;
    import org.junit.runner.RunWith;
    import io.cucumber.junit.Cucumber;
    import io.cucumber.junit.CucumberOptions;
    @RunWith(Cucumber.class)

    @CucumberOptions(features="src/test/java/features/background.feature", glue= {"stepDefinitions"} )
    public class TestRunner {
    }

As you can see, the steps under the Background Keyword were executed before both scenarios.

We did not use any of the Cucumber hooks, but the Background Keyword solved our problem of executing a series of steps before each scenario in a feature file.

Now you must be wondering what if we use hooks along with the Background Keyword. Since Cucumber hooks execute before the execution, Background would execute only after @Before hook. We will use the below hooks file for our demonstration-

    package StepDefinitions;
    import io.cucumber.java.After;
    import io.cucumber.java.Before;
    public class Hooks {

        @Before(order=0)
        public void setUp() {
            System.out.println("------This before hook will execute first------");
        }

        @After(order=1)
        public void tearDown() {
            System.out.println("------This after hook will execute first------");
        }

        @Before(order=1)
        public void setUpTwo() {
            System.out.println("------This before hook will execute second------");
        }

        @After(order=0)
        public void afterOne() {
            System.out.println("------This after hook will execute second------");
        }

    }

The execution results would look like this:

And here you go! You have successfully implemented Cucumber hooks along with Background Keywords.

Check this out: Playwright Browser testing Tutorial: Getting Started With Playwright Framework

Wrapping Up!

Like TestNG, Cucumber provides us with various functionalities that can be used as annotations to enhance our test scripts.

Tags are used to identify scenarios in feature files uniquely. Thus, we can efficiently execute particular scenarios using tags and exclude specific scenarios using the same.
Hooks let us define prerequisites to be executed before the scenarios. We may use tags along with hooks so that specific pre-steps are executed before specific scenarios. Additionally, you may define the order of execution tags using the order parameter.
Background keyword comes as an enhancement when we need to run specific steps before each scenario in a feature file. A single background can serve the purpose of that pre-requirement for any feature file.

You can leverage these Cucumber annotations individually or as a combination of multiple annotations to attain maximum benefits for your Selenium test automation. In addition, you may use Cucumber hooks along with Background or tagged hooks as per the requirements of your project.

Happy testing!