Great Tips on How to Speed up Selenium Automated Tests in 2023

Selenium comes out as an extraordinarily performing tool than any other manual or automation tool. But, sometimes the automation script can run a little slow.

If compared to integration testing and unit testing, these tests are comparatively faster than Selenium automated tests. At times single tests even take up minutes while running, making it slower when their count is more, which makes it a little difficult to get fast feedback.

There are many ways to speed up automated tests in Selenium test cases, like using web locators, explicit waits, optimizing Selenium infrastructure, and many other things that can be done to enhance and make the software’s performance better.

Here we will discuss automated browser testing in Selenium and the different techniques to speed it up in detail.

 

What Can Selenium Automated Tests Do?

• Using Remote Selenium web driver for Selenium web driver, you can open the URL (which you want to test).
• Using the appropriate Selenium locators (like Link text, XPath, CssSelector, etc.) to find the needed web elements.
• Now on the located WebElements perform all the required actions. Under the test make assertions on the page.
• Webdriver is used by the free resources.

 

How Can You Execute the Selenium Test Faster:

We cannot ignore the performance of Selenium test cases, so right from the beginning make sure you work on accelerating its performance. You must optimize the Selenium test infrastructure, to boost the execution speed of test cases.  Below we have mentioned different ways to speed up the Selenium test.

 

Choosing the Correct Web Locators

For a test scenario, WebLocators are the basic building blocks. To automate the interaction with any of the web elements, we use a web locator to locate the web element, and then later on the required actions are performed.

In conjunction with the find_elemets or find_element method, various web locators are used. Now the question arises which web locators are fast in Selenium to locate the elements?

If we look for the speed then ID is the fastest one out of all the web locators as in this for every element on the page Selenium webdriver has the unique ID locator. This ID locator will return you the web element that matches with the given string (or specified value) The first matching element is returned by get.ElementByID( ) if there is more than one element present in the same ID on the document page. Document.getElementById( ) method is optimized by the well-known web browsers which help in providing the web elements at a faster speed than DOM. If the web element doesn’t have an ID attribute then it is suggested to choose the Name attribute.

If the web element doesn’t have the ID or name as an attribute then you must go to the CSS selector web locator. The CSS Engine is a consistent one in all the major browsers and they are known to have the best performance in Selenium’s CSS  selector. It means that with this web locator you are going to have the least compatibility issues with browsers. CSS selector reduces the execution time and identifies the element faster. This CSS Selector is the best choice for old browsers like Internet Explorer. In comparison to XPath, this CSS Selector will give you better readability. When you are moving from one browser to another then XPath may give you consistency issues, and XPath is also known to be the slowest web locator. It is suggested to use the Xpath if you do not have any reliable web locator.

In ascending order of the execution speed here is the list of web locators:

• ID
• Name
• CSS Selector
• XPath

 

Use Fewer Web Locators

By now to speed up the Selenium test you have chosen the web locators, so the next move for you is to keep the count of locators to be as minimum as possible.

Every time you use find_elements(By) or find_element(By) to locate,  the required Web Elements(s) perform access to DOM and as you increase the count of accesses to the DOM tree then more and more time for execution will be taken up by the Selenium script. The best practice is to use as few web locators as possible for Selenium web testing.

This thing will help you in increasing the readability of the test, which minimizes the maintenance time of the scripts.

 

At Any Cost Avoid Thread. sleep( )

The content of the web application can be either dynamic or static in nature. For dynamic loading of the content on the web page, the websites use AJAX (Asynchronous Javascript and XML), so that elements are loaded on the page at different intervals. This pokes difficulties when you perform operations on the elements not present in the DOM. By monitoring the document.readyState status, you can check the DOM state. It is understood that all the resources on the page are loaded when the document.readyState is complete. Now on the web elements present on the page, you can perform the required operations. Waiting for some time in the test code adds up the delay which is required for loading the resources which are present on the page. There are different methods of adding wait in the Selenium. At any cost you must avoid Thread.sleep. Thread.sleep( )is a Selenium method that puts the code execution on pause for a certain amount of time.

Await for 5 seconds is added in the above snippet. So now if the element gets loaded within the given duration only (consider like in 2 seconds) then in such cases the 3 extra seconds which you added will increase the overall execution timing. The time for page load depends on various external factors like network bandwidth, server load, caching, page design, etc. There is no way in which you can predict the load time of the page. So while performing the automated browser testing in Selenium you must measure the page load time.

 

Re-use the Existing Browser Instance

The test automation framework which can be used with Selenium gives annotations to boost the speed of test execution and test development time. With annotations, you can execute tests with various inputs. As per the test requirements if you use the right set of annotations then it will increase the Selenium tests speed.

There are scenarios where on the same operating system and browser combination you run a group of tests or any single test. In such scenarios to add up the overhead in the test execution, you can create a new instance of Selenium Webdriver at the beginning itself.

 

Using Explicit Waits in Selenium

To all the web elements in the test script, implicit wait is applied in Selenium. On conditions like Element is selectable, element is visible, element is clickable, etc. you cannot perform the wait. Rather on the other hand with the explicit wait, you can do conditional wait on the web elements which are present on the page.

For example, in explicit if you have specified that webelement is visible then the exception will be thrown for elementnotvisible. TobeClickable method will return an element if the element which is located is clickable.

The combination of ExpectedConditions and WebDriverWait class is used to perform the explicit wait operation on the webelements. The explicit wait will not run on the remote Selenium rather it will run on the code. As soon as the given condition is met explicit wait makes an exit instead of waiting for completing the time duration. The element will be returned as a result of the condition finding the WebElement. Even when the duration specified in the condition is elapsed and Webelement is not there in the DOM then TimeoutException is thrown.

The snapshot below has an explicit wait of 5 seconds which is performed on the condition visibilityOfElement. So in case you have a web element that has the ID=’element’ and it is even located within 5 seconds then the explicit wait will exit and the WebElement which is required is returned.

The explicit wait gives a better performance with the test script because when the element is located, the WebElement is accessible. Selenium tests can be boosted with the explicit waits as the wait is not performed for the complete duration.

 

Use Data-Driven Testing for Parameterization

There are times when you'll want to run a test scenario across numerous browsers and operating systems, or against various input combinations. It is not a good idea to hard code the values in the test methods. Instead, when executing the test on a large data set, you can use parameterization.

In Selenium, parameterization not only increases test coverage but also speeds up the tests. Parameterized tests are supported by all major automation frameworks, including MSTest, NUnit, and others [for Selenium C#]; JUnit, TestNG, and others [for Selenium Java], and PyTest [for Selenium Python].

 

Group Test Scenario

When more files and test methods are added to the suite, the complexity of the test suite increases significantly.  To reduce the difficulties associated with the implementation and maintenance of the test suite, group the tests according to the functionality under test.

Two test groups (i.e., Search and ToDo) are created in the example shown in Grouping test cases in TestNG, and parallelism is performed at the ‘methods' level.

By defining the maximum number of threads to be created during test execution, the thread-count attribute in TestNG allows you to perform parallel execution of test methods. Grouping test scenarios reduces the difficulties of maintaining test suites and allows for shorter execution times (depending on the approach chosen to achieve parallelization).

 

Attain Faster Page Loads by Disabling Images on The Web Page

To open the testing page after the creation of an instance of the Selenium Web driver, you need to use the driver.get() method. The composition of the page is one of the major factors that affect the loading of the page. Multiple images on the page may increase the page loading time.

To address the page loading time issue, a method to disable the loading of images has been introduced to make the page loading faster.

The process to disable image loading in various browsers while the Selenium script is running is given below:

 

Chrome

If you want to reduce the page load time on the Amazon e-commerce website, you can disable the feature of image loading in the script. The script implementing this feature has been provided above.

Fig 6:Disabling image loading in Firefox

 

Disable Image Loading in Firefox

If there are many images on the test page, then the best option to run your Selenium web testing smoothly is by disabling the image loading option from the script. For doing the same, the following step needs to be followed- Set Firefox preference permissions.default.image to 2.

 

How LambdaTest Helps You in Speeding up Your Selenium Automation Tests?

LambdaTest provides a tool called the Selenium automation testing platform. It is a test automation cloud-based testing tool that helps us to test our scripts on 3000+ desktop and mobile browsers. Take a look at this tool.

• We know that parallel testing can cut down the execution time and also helps to release the product faster. This tool provides reliable and secure parallel testing.

• Debugging using this tool is easy with a hawk-eye insight.

• Wherever and whenever you feel stuck, you can share your issues with your colleague and within no time your problem will be solved.

• You can integrate it with your favourite CI/CD testing tool.

• The online Selenium Grid provides support to all sorts of languages and frameworks, so keep all those languages and framework-related issues in the pocket and switch to Selenium Automation testing.

 

Conclusion

When it is about Selenium you don’t have to worry about the framework and languages as Selenium would do that for you. There is complete ease in implementing it, as it supports different operating systems and multi browsers. All you need to care about is the speed by taking the above precautions. Thank you for your attention. Happy Learning!