Selenium JavascriptException Explained

Hari Mahesh

Exceptions are errors that occur during test execution as a part of the Selenium framework’s exception hierarchy that handles various issues while interacting with the web pages. Handling these exceptions is crucial as it helps manage the errors gracefully with proper messages.

One such common exception that happens mostly in Selenium is JavascriptException.

Let’s figure out why this exception is thrown and how we can resolve it.

JavascriptException in Detail

JavascriptExecution is raised when there is an error while executing JavaScript code within the browser while running tests. Selenium allows us to execute JavaScript code in the browser where we execute the automation tests. There can be many reasons that can raise JavascriptExecution; let’s go through a few common ones.

Syntax Errors in JavaScript Code

If the JavaScript code we are trying to execute has syntax errors, then this exception will be thrown. This error will be similar to how the error is displayed if the website we browse has JavaScript errors.

Example: driver.execute_script("console.log('Hello World')") might throw an exception if there is a typo, like consle.log instead of console.log.

Element Not Found

When the JavaScript in our code tries to interact with an element that is not yet loaded or does not exist, then this exception is thrown.

Example: driver.execute_script("document.getElementById('nonexistent').click();") will throw an exception if an element with ID does not exist.

Browser Compatibility Issues

Sometimes, the JavaScript that works in one browser may not work in another browser. If we are running the Selenium tests across different browsers, this can be a cause.

Example: Using modern JavaScript ES6 features in a browser that only supports ES5 could lead to an exception.

Timeouts and Delays

If the JavaScript code depends on certain conditions to be met (like waiting for an element to be visible), and these conditions are not met in time, it could lead to an exception.

Example: driver.execute_script("return document.readyState").equals("complete") might fail if the page has not fully loaded within the expected timeframe.

Invalid Operations

Attempting to perform an operation that’s not supported or is invalid in the current context, like trying to click an element that is not clickable.

Example: Trying to click an element that is hidden or not clickable, like driver.execute_script("document.querySelector('.hidden').click();") where .hidden is a CSS class for non-clickable elements.

Security Restrictions

Browsers have security restrictions in place, and certain JavaScript operations might not be permitted under these restrictions when executed through Selenium.

Example: Trying to access cross-origin frames or content might be blocked by the browser’s same-origin policy.

Incorrect Use of Selenium’s JavaScript Executor

If we are misusing Selenium’s JavaScript executor methods (e.g., wrong arguments, incorrect return types), it can cause exceptions.

Example: driver.execute_script("return arguments[0] + arguments[1]", 5) without providing the second argument.

Resolving JavascriptExecution

To resolve JavascriptException, we can take the following steps.

• Check Syntax: Ensure the JavaScript we are executing has no syntax errors. We can test that by executing the JavaScript in a browser console or any other IDE that supports JavaScript.
• Validate Element Presence and State: If there are JavaScripts that interact with web elements, ensure those elements are present and are in the desired state. We can use Selenium’s default methods like findElement to check the element’s presence.
• Handle Timing Issues: Ensure the webpage is loaded or the specified conditions are met before executing the JavaScript. We can use Selenium’s wait methods to check this.

  new WebDriverWait(driver, Duration.ofSeconds(10)).until(
    webDriver -> ((JavascriptExecutor) webDriver).executeScript("return document.readyState").equals("complete")
  );

• Browser Compatibility: Ensure the JavaScript code we wrote is compatible across all the browsers where we plan to execute the scripts. We can use the features and syntax supported across all browsers.
• Handle Invalid Operators: If the JavaScript code tries to do invalid operations like clicking a hidden element in the webpage, we may need to modify those scripts.
• Adhere to Security Policies: Ensure the code complies with the security policies and does not violate those, as there may be scenarios where we handle sensitive data.
• Use Correct Executor Syntax: Ensure we pass the right arguments and expect the correct return value to the executor.
• Error Handling: Implement try-catch blocks in the JavaScript codes to handle the exceptions and provide more insight into the errors.

Smarter Ways to Handle Exceptions

Selenium was once the favorite tool for automation QA. But when the market strategy for delivering the products and services became more aggressive, Selenium couldn’t find its way to sustain this change, or we can say Selenium couldn’t change accordingly. Here are the 11 reasons for not using Selenium.

With this strategy change, a more robust tool was needed that could save the time and effort of the tester from fixing or enhancing the framework, but the tool should be equipped with many features and frameworks. This is where testRigor stands out.

testRigor is bundled with many features that help the testers ease their work. We can review a few features.

• Cloud-hosted: testRigor is a cloud-based tool that eliminates all the setup headaches. Just grab a license, log in, and you are ready to go – no fuss, just results. A real time-saver!
• Easy Test Script Creation/Maintenance – testRigor allows the crafting of test cases in plain English, eliminating the need for programming languages. This approach empowers anyone to create or modify test cases, simplifying the script debugging. Also, whenever the application UI or element attributes are changed, testRigor automatically accommodates the changes in the test scripts through its groundbreaking self-healing capabilities. This feature removes the huge test maintenance burden of the tester’s shoulders.
• Cross-browser and Cross-platform Support – testRigor effortlessly manages the testing process across different browser versions and platforms.
• Custom Element Locators – testRigor is independent of unreliable XPaths or CSS selectors. Instead, it employs a unique method of identifying elements powered by its AI algorithms, called testRigor locators.
• Supports JavaScript: testRigor supports the execution of JavaScript in the browser. For example:

  execute JavaScript in the browser text starting from the next line and ending with [END]
  document.querySelector("#input1").value = "John Doe";
  [END]

• No need to add Waits: When we use testRigor, we don’t have to add custom waits. testRigor waits for the page to load fully, then only executes the scripts. So many failures due to element interactions will be solved.

We discussed very few features of testRigor, but if you want to know more, you can check more of testRigor’s features.

EndNotes

With the aggressive pace of delivering products and services, the QA automation tool should be intelligent enough to avoid unnecessary errors. The tools should perform fast to help execute more test cases to increase coverage. The tool should be equipped with the latest intelligent technologies to achieve this. Using testRigor, the QA team and any stakeholder can perform testing, which increases not just the execution coverage but the coverage of involvement from an organization to the testing.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT