Exception Handling in Selenium WebDriver

Exception handling in Selenium WebDriver is essential for ensuring robust and reliable automated tests. It allows you to anticipate and manage errors, making tests more resilient and accurate. It helps your tests either recover or fail with clear insights.

This guide helps understand and implement effective exception handling to improve test stability and simplify debugging and maintenance.

What is Exception?

An exception is an incident that disturbs the normal flow of a program’s execution. When an unexpected occurrence occurs during the execution of a program, an exception object is created to reflect the specific error or unexpected state.

An Exception could be caused by a variety of factors, including:

• Logical errors occur when the code does not function as expected or when improper reasoning causes an unexpected circumstance.
• Runtime errors occur during program execution and are commonly caused by improper input, division by zero, or attempting to access an array element that does not exist.
• System Errors occur when the software experiences challenges with system resources, such as running out of memory or experiencing file I/O errors.

To properly handle exceptions, programming provide methods such as try-except blocks (try-catch in some ), in which code that may cause an exception is trapped within a try block and potential exceptions are caught and handled in except blocks. This helps to gracefully manage failures and keep the software stable.

Why is Exception Handling in Selenium Important?

Exception handling is significant because it provides critical information about problems encountered during the execution of automated tests or browser interactions.

Here are the key reasons why it is important:

• Prevents abrupt test failures by catching errors.
• Gracefully handles unexpected issues like timeouts and missing elements.
• Simplifies debugging with clear error feedback.
• Enhances overall test stability and reliability.
• Supports consistent performance in CI/CD environments.

Consequences of Failing to Use Exception Handling in Selenium

If you do not use exception handling in Selenium, various negative consequences may arise, compromising the robustness and reliability of your test automation scripts:

1. Uncaught Errors Halt Execution: Errors (e.g., missing elements, timeouts, stale references) cause the script to crash and terminate abruptly. This prevents the remaining test cases from executing, resulting in incomplete test runs and missing defects.

For example, if an element is missing from the page, a NoSuchElementException is issued, and the script terminates without further action.

2. Lack of Error Reporting: Without exception handling, you lose the ability to adequately manage and log errors. This makes debugging difficult because there is no organized means to collect and report faults, resulting in greater time and effort spent diagnosing problems.

For example, if a script fails due to an uncaught exception, the lack of thorough logging may prevent developers from understanding why the failure occurred.

3. Inconsistent Test Results: Tests may react unpredictably if mistakes are not controlled, resulting in inconsistent findings. For example, a test that fails owing to a missing element may pass when the element reappears, suggesting that there was an intermittent problem.

For example, a test that expects an alert to occur may pass without detecting an issue if the alert does not arrive, but the lack of an exception means you miss the fact that anything went wrong.

4. Inability to Handle Dynamic Content: Web pages frequently contain dynamic content, and without exceptions such as StaleElementReferenceException, you cannot effectively manage scenarios in which elements change or update. This can lead to unnecessary test failures.

For example, if the DOM updates after identifying an element, the reference becomes stale (StaleElementReferenceException). Without exception handling, the test fails rather than retrying or relocating the element.

5. Reduced Maintainability: Tests become increasingly difficult to maintain as more hardcoded assumptions are introduced.

For example, presuming that every page load would occur within a certain time limit without accounting for potential timeouts might make scripts brittle. A TimeoutException may arise if a page takes longer to load than expected. Without this, you cannot construct a retry system, resulting in many failures.

Can you do error handling without Exception Handling in Selenium?

While it may not be the best approach, you can handle errors in Selenium without relying directly on exceptions by using alternative techniques and approaches.

Here are some strategies for handling errors in Selenium Python gracefully:

1. Implicit Waits

Implicit waits can help manage situations where elements are not immediately available by setting a default waiting time. This reduces the likelihood of encountering NoSuchElementException when elements are not immediately present.
from selenium import webdriver

driver = webdriver.Chrome()

driver.implicitly_wait(10)  # Waits up to 10 seconds for elements to appear

2. Explicit Waits

Explicit waits allow you to wait for specific conditions to be met before proceeding. This approach can help avoid exceptions related to timing issues.

from selenium.webdriver.common.by import By

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()

wait = WebDriverWait(driver, 10)

element = wait.until(EC.presence_of_element_located((By.ID, 'element_id')))

3.  Polling with Retry Logic

Implement polling mechanisms to check for conditions or element availability without using exception handling directly. This involves creating custom retry logic.

import time

from selenium.webdriver.common.by import By


def wait_for_element(driver, by, value, timeout=10):

    end_time = time.time() + timeout

    while time.time() < end_time:

        elements = driver.find_elements(by, value)

        if elements:

            return elements[0]

        time.sleep(1)

    return None


element = wait_for_element(driver, By.ID, 'element_id')

if element:

    element.click()

else:

    print("Element not found within the timeout period")

4. Check Element Properties

Before performing actions on elements, check if they are present, visible, and interactable using methods such as is_displayed().

element = driver.find_element(By.ID, 'element_id')

if element.is_displayed():

    element.click()

else:

    print("Element is not displayed")

5. Use Page Object Model (POM)

Encapsulate interactions and checks in page objects. This can centralize error handling logic and make your tests more maintainable.

class LoginPage:

    def __init__(self, driver):

        self.driver = driver

        self.username_field = (By.ID, 'username')

        self.password_field = (By.ID, 'password')

        self.login_button = (By.ID, 'login')



    def enter_username(self, username):

        element = self.driver.find_element(*self.username_field)

        if element.is_displayed():

            element.send_keys(username)

        else:

            print("Username field is not displayed")



    def enter_password(self, password):

        element = self.driver.find_element(*self.password_field)

        if element.is_displayed():

            element.send_keys(password)

        else:

            print("Password field is not displayed")



    def click_login(self):

        element = self.driver.find_element(*self.login_button)

        if element.is_displayed():

            element.click()

        else:

            print("Login button is not displayed")

Common Exceptions in Selenium WebDriver

When using Selenium WebDriver, you may encounter a few common exceptions. These exceptions can occur as a result of errors with element location, browser interaction, or timing.

Note: All the examples of Exceptions are in Selenium Python

Below are some of the most typical exceptions in Selenium WebDriver:

1. MoveTargetOutOfBoundsException

MoveTargetOutOfBounds Exception occurs when attempting to interact with an element that is not within the viewable area of the browser. For instance, when the element is located outside the viewable area, often due to scrolling issues.

element = driver.find_element(By.ID, "element_out_of_view")

actions = ActionChains(driver)

actions.move_to_element(element).perform()  # Raises exception if element is out of bounds

Solution:

To prevent this exception, you can use JavaScript to scroll the element into view before interacting with it. The specific Selenium method where the JavaScript code should be added is ‘execute_script’.

from selenium import webdriver

from selenium.webdriver.common.by import By

from selenium.webdriver.common.action_chains import ActionChains



# Initialize the Chrome WebDriver

driver = webdriver.Chrome()



# Navigate to the webpage

driver.get("https://example.com")


try:

    # Locate the element that is out of view

    element = driver.find_element(By.ID, "element_out_of_view")


    # Scroll the element into view using JavaScript

    driver.execute_script("arguments[0].scrollIntoView(true);", element)


    # Now perform the action after ensuring the element is in view

    actions = ActionChains(driver)

    actions.move_to_element(element).perform()


except MoveTargetOutOfBoundsException as e:

    print("Element is out of bounds: ", e)


finally:

    # Close the browser session

    driver.quit()

2. InvalidArgumentException

Thrown when an argument passed to a method is invalid. Occurs when incorrect arguments are provided, such as invalid locators or options.

from selenium import webdriver

from selenium.common.exceptions import InvalidArgumentException



driver = webdriver.Chrome()



try:

    # Passing an invalid URL format to the driver

    driver.get("invalid-url")

except InvalidArgumentException as e:

    print("Invalid Argument: ", e)



driver.quit()

Solution:

A good way to resolve this is to:

• Validate Input: Ensure that the input provided to WebDriver methods is correct and valid.
• Use Proper URL Formats: Always pass a correctly formatted URL (including http:// or https://).

url = "http://valid-url.com"

if url.startswith("http://") or url.startswith("https://"):

    driver.get(url)

else:

    print("Invalid URL format")

3. UnhandledAlertException

Raised when an unexpected alert is present. Commonly occurs when an alert appears, but the script doesn’t handle it, and further actions fail.

from selenium import webdriver

from selenium.common.exceptions import UnhandledAlertException



driver = webdriver.Chrome()



driver.get("https://example.com")

# Assuming an alert is triggered by some action

driver.execute_script("alert('This is an alert');")


try:

    # Trying to perform some action without handling the alert

    driver.find_element_by_id("someElement").click()

except UnhandledAlertException as e:

    print("Unhandled Alert: ", e)

    # Handling the alert

    alert = driver.switch_to.alert

    alert.accept()


driver.quit()

Solution: 

A good way to resolve this is to:

• Handle Alerts: Always check for and handle alerts before proceeding with any other interactions.
• Use Try-Catch: Encapsulate actions in a try-catch block and handle alerts if they appear.

try:

    alert = driver.switch_to.alert

    alert.accept()  # or alert.dismiss() if you want to dismiss it

except NoAlertPresentException:

    print("No alert present")

4. JavascriptException

Thrown when executing JavaScript through Selenium fails. Occurs when the script provided in execute_script is incorrect or causes an error in the browser.

from selenium import webdriver

from selenium.common.exceptions import JavascriptException

driver = webdriver.Chrome()

driver.get("https://example.com")

try:

    # Executing incorrect JavaScript

    driver.execute_script("return document.getElementByID('nonExistentId');")

except JavascriptException as e:

    print("JavaScript Execution Failed: ", e)

driver.quit()

Solution:

A good way to resolve this is to:

• Verify JavaScript Code: Ensure that the JavaScript code you are executing is correct and does not contain errors.
• Test JavaScript Independently: Run the JavaScript code independently in the browser console to check for errors before using it in Selenium.

try:

    result = driver.execute_script("return document.getElementById('validId');")

    if result is None:

        print("Element not found")

except JavascriptException as e:

    print("JavaScript Error: ", e)

5. NoAlertPresentException

Raised when an expected alert is not present. Happens when trying to interact with an alert that doesn’t exist.

from selenium import webdriver

from selenium.common.exceptions import NoAlertPresentException

driver = webdriver.Chrome()

driver.get("https://example.com")

try:

    # Attempting to switch to an alert that does not exist

    alert = driver.switch_to.alert

    alert.accept()

except NoAlertPresentException as e:

    print("No Alert Present: ", e)

driver.quit()

Solution: 

A good way to resolve this is to:

• Check for Alerts: Always check if an alert is present before trying to interact with it.
• Use Conditional Logic: Use a try-catch block to safely handle cases where no alert is present.

try:

    alert = driver.switch_to.alert

    alert.accept()

except NoAlertPresentException:

    print("No alert to accept")

Some New Exceptions in Selenium 4.0

Here are some of the new Selenium exceptions:

1. ElementClickInterceptedException

Element Click Intercepted Exception is raised when an element you try to click is not clickable because another element is blocking it.

from selenium import webdriver

from selenium.common.exceptions import ElementClickInterceptedException



driver = webdriver.Chrome()

driver.get("https://example.com")



try:

    driver.find_element_by_id("blockedElement").click()

except ElementClickInterceptedException as e:

    print("Element was blocked by another element: ", e)

    # Possible resolution: Scroll the element into view or use JavaScript to click

    element = driver.find_element_by_id("blockedElement")

    driver.execute_script("arguments[0].click();", element)



driver.quit()

Solution:

• Scroll the Element into View: Use JavaScript to scroll the element into view.
• Click Using JavaScript: If the element is still blocked, clicking via JavaScript can bypass the issue.

2. NoSuchCookieException

Raised when trying to interact with a cookie that doesn’t exist.

from selenium import webdriver

from selenium.common.exceptions import NoSuchCookieException



driver = webdriver.Chrome()

driver.get("https://example.com")



try:

    # Attempting to delete a cookie that does not exist

    driver.delete_cookie("nonExistentCookie")

except NoSuchCookieException as e:

    print("No such cookie: ", e)

    # Possible resolution: Check if the cookie exists before trying to delete it

    if driver.get_cookie("nonExistentCookie") is None:

        print("Cookie does not exist")



driver.quit()

Resolution:

• Check Before Deleting: Use get_cookie to check if the cookie exists before trying to delete or manipulate it.
• Handle Gracefully: Implement a fallback or log that the cookie does not exist.

3. InvalidCoordinatesException

Raised when there is an issue with the coordinates provided for actions like mouse movements.

from selenium import webdriver

from selenium.webdriver.common.action_chains import ActionChains

from selenium.common.exceptions import InvalidCoordinatesException


driver = webdriver.Chrome()

driver.get("https://example.com")


try:

    action = ActionChains(driver)

    element = driver.find_element_by_id("someElement")

    action.move_to_element_with_offset(element, 10000, 10000).perform()  # Invalid coordinates

except InvalidCoordinatesException as e:

    print("Invalid coordinates provided: ", e)

    # Possible resolution: Verify the coordinates before performing the action

    width, height = element.size['width'], element.size['height']

    if 0 <= 10000 < width and 0 <= 10000 < height:

        action.move_to_element_with_offset(element, 10000, 10000).perform()

    else:

        print("Coordinates are out of bounds")


driver.quit()

Resolution:

• Verify Coordinates: Ensure that the coordinates are within the bounds of the element before attempting to move to that position.
• Use Element Size: Use the element’s size to validate that the coordinates fall within the element’s dimensions.

4. InvalidSessionIdException

Raised when the session ID used in a request is invalid or has expired.

from selenium import webdriver

from selenium.common.exceptions import InvalidSessionIdException

driver = webdriver.Chrome()

driver.get("https://example.com")

driver.quit()

try:

    # Attempting to interact after quitting the session

    driver.find_element_by_id("someElement").click()

except InvalidSessionIdException as e:

    print("Session ID is invalid or expired: ", e)

    # Possible resolution: Start a new session

    driver = webdriver.Chrome()

    driver.get("https://example.com")

Resolution:

• Check Session Status: Ensure that the WebDriver session is still active before making requests.
• Restart Session: If the session is invalid or expired, start a new WebDriver session.

5. ElementNotInteractableException

Element Not Interactable Exception is raised when an element is found but is not interactable (e.g., it’s hidden or disabled).

from selenium import webdriver

from selenium.common.exceptions import ElementNotInteractableException

from selenium.webdriver.common.by import By

import time



# Initialize the Chrome WebDriver

driver = webdriver.Chrome()



try:

    # Navigate to the webpage

    driver.get("https://example.com")



    # Attempt to interact with an element (e.g., a hidden or disabled button)

    element = driver.find_element(By.ID, "hiddenButton")

    element.click()



except ElementNotInteractableException as e:

    print("Element is not interactable: ", e)



    # Resolution: Wait until the element becomes interactable

    time.sleep(5)  # Wait for 5 seconds (or use WebDriverWait for a dynamic wait)

    element = driver.find_element(By.ID, "hiddenButton")



    # Try clicking again after waiting

    if element.is_enabled() and element.is_displayed():

        element.click()

    else:

        print("Element is still not interactable.")



finally:

    # Close the browser session

    driver.quit()

Resolution 

The primary resolution method for an ElementNotInteractableException is to ensure that the element is both visible and enabled before interacting with it.

This can be achieved using:

• Explicit Wait: Use WebDriverWait to wait until the element becomes interactable.
• Time Delay: Introduce a delay (using time.sleep()) to give the element time to become interactable.

Some Deprecated Selenium Exceptions

Certain exceptions have been removed or deprecated in newer Selenium versions, most notably Selenium 4. These changes are frequently made to simplify the API, eliminate duplication, or enhance the overall developer experience.

Following are some exceptions that may have been abandoned, made redundant, or deprecated:

1. ElementNotVisibleException

Status: Deprecated in Selenium 3 and eliminated in Selenium 4.

Replaced by ElementNotInteractableException. The new exception better captures scenarios in which an element exists in the DOM but cannot be manipulated, such as when it is hidden or disabled.

2. StaleElementReferenceException

Status: While it has not been completely eliminated, its use has decreased as better practices and tools have been implemented to avoid stale element concerns. The deprecation is mainly about transferring the focus to improved handling techniques.

Replacement: Developers are urged to utilize WebDriverWait to avoid scenarios that cause this exception.

3. InvalidSelectorException

Status: Deprecated as better validation and more specific exceptions for selector errors have been introduced.

Replacement: This broad exception is no longer required because more descriptive exceptions or built-in validation exist.

4. InvalidElementStateException

Status: Although it is still available, its utility is decreasing as Selenium adds more precise exceptions for various phases of element interaction.

Replacement: More typical exceptions include ElementClickInterceptedException and ElementNotInteractableException.

5. WebDriverException

Status: This exception has not been completely deleted, but its widespread use is being discouraged in favor of more precise exceptions that provide more information about the exact problem.

Replacement: Use scenario-specific exceptions for example TimeoutException, or NoSuchWindowException).

The removal or deprecation of these exceptions simplifies the error-handling process and encourages developers to build more robust, and specific code. As Selenium evolves, developers are guided to better practices through these modifications.​

Talk to an Expert

Selenium Resources

• Selenium Python Tutorial (with Example)
• Page Object Model and Page Factory in Selenium Python
• Understanding ExpectedConditions in Selenium
• Understanding Role of Thread.sleep() in Selenium
• Headless Browser Testing With Selenium Python
• How to install GeckoDriver for Selenium Python?
• How to perform Web Scraping using Selenium and Python
• How to Create and Use Action Class in Selenium Python
• How to download a file using Selenium and Python
• How to Press Enter without Element in Selenium Python?
• UI Automation using Python and Selenium: Tutorial
• Get Current URL in Selenium using Python: Tutorial

Conclusion

Exception handling is a very crucial part of every Selenium Script. Exceptions in Selenium can not be ignored as they disrupt the normal execution of programs. One can write optimal and robust scripts by handling the Exceptions in unique ways. Programmers can handle standard exceptions using various techniques like Try/catch, Multiple catch blocks, Finally, and others depending upon the requirement of scripts.

BrowserStack Automate lets you run Selenium tests on 3500+ real device-browser-OS combinations, ensuring high accuracy and reliable results. With seamless parallel test execution on Selenium Grid, you can speed up testing and cover more ground. It also offers smooth CI/CD integration to streamline your testing workflows and makes it easier to catch and handle exceptions in real-time environments.

Try Exception Handling in Selenium Webdriver